diff --git a/README.md b/README.md index 4ce0ddce9..212788763 100644 --- a/README.md +++ b/README.md @@ -52,6 +52,7 @@ Publications: - Features + - [Deployment features](docu/deployment.md) - [Compare your model with a Specification](docu/CompareSpec.md) - [Introspection at design time](docu/simulateRuntime.md) - [Models combination](docu/ModelCombine.md) diff --git a/docu/Installation.md b/docu/Installation.md index 84e193aaf..18acfac06 100644 --- a/docu/Installation.md +++ b/docu/Installation.md @@ -26,7 +26,7 @@ First the java environment have to be setup, for eclipse it is recomended the in ``` sudo apt-get install openjdk-11-jre ``` -Download the official [Eclipse Installer](https://www.eclipse.org/downloads/packages/installer) for your preferred operating system. Execute the installer and choose the advanced mode (menu on the right-up corner). Select the Product *Eclipse Modeling tools* package, for the version it is recommended *2020-12*. +Download the official [Eclipse Installer](https://www.eclipse.org/downloads/packages/installer) for your preferred operating system. Execute the installer and choose the advanced mode (menu on the right-up corner). Select the Product *Eclipse Modeling tools* package, for the version it is recommended *2021-12*. ![alt text](images/eclipse_installer1.png) @@ -35,11 +35,19 @@ Press *Next* and add a new *User project* pressing the green button *+*: Catalog: Github Projects Resource URIs: https://raw.githubusercontent.com/ipa320/ros-model/master/EclipseInstaller/ROSModel.setup ``` +Sometimes eclipse is not able to find the file, for those cases we recommend to download the file to the local memory of the machine and import it: + +``` +wget https://raw.githubusercontent.com/ipa320/ros-model/master/EclipseInstaller/ROSModel.setup +``` + ![alt text](images/eclipse_installer2.png) Select the the ROS Model project (under Github Projects -> ) and press next. -By default the ROS tooling installation will be saved under the folder *ros-model-master* in your home directory. In case your github credentials are not setup on your machine, change the *Ros model Github repository* to the *HTTPs(read-write)* option. +By default the ROS tooling installation will be saved under the folder *ros-model-master* in your home directory. To ensure that you have access to get the source code from GitHub, select the check box *Show all variable* and change the *Ros model Github repository* to the *HTTPs(read-write)* option, verify that the option *Github user ID* is set to "anonymous". + +![alt text](images/eclipse_installer3.png) Follow the installation instructions of the Oompth installer dialog, after the installation eclipse will be restarted to launch the ROS tooling configuration. Finally, when all the startup tasks finished press "Workbench". diff --git a/docu/deployment.md b/docu/deployment.md new file mode 100644 index 000000000..fcbef5bca --- /dev/null +++ b/docu/deployment.md @@ -0,0 +1,93 @@ +## How to get deployment artifacts + + +### Preparation + +Please be sure that the tool is installed and your workspace setup, see the [installation guide](../README.md) for further details. + +Import the example project pub_sub_ros2 (from the [ros-model-examples](https://github.com/ipa-nhg/ros-model-examples) repository) to the workbench of your application: + +``` +pub_sub_ros2 +``` + +Import the example project agriculture_demo_sprint2 (from the [ros-model-examples](https://github.com/ipa-nhg/ros-model-examples) repository) to the workbench of your application: + +``` +agriculture_demo_sprint2 +``` + +Install docker and docker-compose + +### Get get deployment artifacts + +To create deployment artifacts you need to right click "*.rossystem" file. + +#### Rossystem without parameters +In this case, you need to right click "communication.rossystem". Then you need to choose "Deployment Artifacts Generator". + +A dialog will be open and ask you to select a ROS Distro. In this case, the rossystem doesn't contain parameters, so you only need to choose a ROS Distro. + +This process is as shown blow. + +![alt text](images/rostooling_deployment.gif) + +Then deployment artifacts will automatically created, as you can find under "src-gen" folder + +![alt text](images/pub_sub_ros2_deployment_gen.png) + + +#### Rossystem with parameters + +In some case, you need to choose device ports based on parameters defined in a rossystem. + +For example, if you want to run teleop with a joystick in a docker container, docker need to know which port is the joystick connect to. + +In this case, you need to right click "communication.rossystem". Then you need to choose "Deployment Artifacts Generator". + +A dialog will be open and ask you to select a ROS Distro. In this case, the rossystem contains parameters, you need to choose the corresponding parameter to the joystick port value. + +This process is as shown blow. + +![alt text](images/rostooling_deployment_jackal.gif) + +Then deployment artifacts will automatically created. + +![alt text](images/jackal_deployment_gen.png) + +### Use github action to generate docker images + +Once you get deployment artifacts, you can use git action to build and release docker images automatically. + +If you already have a repository in github, you can use it. If not, you need to create a repository. For example, we use ("rossystem-deployment" repository)[https://github.com/ipa-rwu/rossystem-deployment. + +You also need a dockerhub account. Once you have dockerhub account, you need to add your Docker ID as a secret to GitHub. +1. Add your Docker ID as a secret to GitHub. Navigate to your GitHub repository and click Settings > Secrets > New secret. +2. Create DOCKER_USERNAME and DOCKER_PASSWORD + +The result should looks like below. + +![alt text](images/github_secrets.png) + +In this repository, you need to create a folder ".github/workflows". Then you need to put a file with suffix "_workflow.yml" from a generated folder to this folder. For example, you can put "communication_foxy_workflow.yml" or "agriculture_robot_sprint3_noetic_workflow.yml" under ".github/workflows" folder, as shown below. + +![alt text](images/github_workflows_folder.png) + + +Then you need to put the generated folder in this repository. For example, we put "communication_ros2" and "agriculture_robot_sprint3" in the repository. The locations of these two folder as shown below. + +![alt text](images/rossystem_deployment_repo.png) + +You can push them to github. Github action will build docker image and push images in dockerhub. + +### Start the system + +Before starting the system, you need to modify "docker-compose" file. You need to add your docker account as prefix before a docker image name. +For example, we add "kogrob2" (docker hub account name) in front of "communication_foxy:latest", as shown below. + +![alt text](images/docker-compose.png) + +Then you can use the command below to start the system. +``` +docker-compose up +``` diff --git a/docu/images/docker-compose.png b/docu/images/docker-compose.png new file mode 100644 index 000000000..6f8e2ea0e Binary files /dev/null and b/docu/images/docker-compose.png differ diff --git a/docu/images/eclipse_installer1.png b/docu/images/eclipse_installer1.png index 3a91aed89..11df7d306 100644 Binary files a/docu/images/eclipse_installer1.png and b/docu/images/eclipse_installer1.png differ diff --git a/docu/images/eclipse_installer3.png b/docu/images/eclipse_installer3.png new file mode 100644 index 000000000..dfdc847b2 Binary files /dev/null and b/docu/images/eclipse_installer3.png differ diff --git a/docu/images/github_secrets.png b/docu/images/github_secrets.png new file mode 100644 index 000000000..b3b15f14b Binary files /dev/null and b/docu/images/github_secrets.png differ diff --git a/docu/images/github_workflows_folder.png b/docu/images/github_workflows_folder.png new file mode 100644 index 000000000..72c07c894 Binary files /dev/null and b/docu/images/github_workflows_folder.png differ diff --git a/docu/images/jackal_deployment_gen.png b/docu/images/jackal_deployment_gen.png new file mode 100644 index 000000000..94bd39fea Binary files /dev/null and b/docu/images/jackal_deployment_gen.png differ diff --git a/docu/images/pub_sub_ros2_deployment_gen.png b/docu/images/pub_sub_ros2_deployment_gen.png new file mode 100644 index 000000000..b9978c7d6 Binary files /dev/null and b/docu/images/pub_sub_ros2_deployment_gen.png differ diff --git a/docu/images/rossystem_deployment_repo.png b/docu/images/rossystem_deployment_repo.png new file mode 100644 index 000000000..e38dc6f45 Binary files /dev/null and b/docu/images/rossystem_deployment_repo.png differ diff --git a/docu/images/rostooling_deployment.gif b/docu/images/rostooling_deployment.gif new file mode 100644 index 000000000..51846f1bf Binary files /dev/null and b/docu/images/rostooling_deployment.gif differ diff --git a/docu/images/rostooling_deployment_jackal.gif b/docu/images/rostooling_deployment_jackal.gif new file mode 100644 index 000000000..1b7f6c5c5 Binary files /dev/null and b/docu/images/rostooling_deployment_jackal.gif differ diff --git a/plugins/de.fraunhofer.ipa.ros.edit/icons/full/ctool16/CreateInterfaceType_namespace_GlobalNamespace.gif b/plugins/de.fraunhofer.ipa.ros.edit/icons/full/ctool16/CreateInterfaceType_namespace_GlobalNamespace.gif new file mode 100644 index 000000000..931730f4e Binary files /dev/null and b/plugins/de.fraunhofer.ipa.ros.edit/icons/full/ctool16/CreateInterfaceType_namespace_GlobalNamespace.gif differ diff --git a/plugins/de.fraunhofer.ipa.ros.edit/icons/full/ctool16/CreateInterfaceType_namespace_PrivateNamespace.gif b/plugins/de.fraunhofer.ipa.ros.edit/icons/full/ctool16/CreateInterfaceType_namespace_PrivateNamespace.gif new file mode 100644 index 000000000..e5db9ceef Binary files /dev/null and b/plugins/de.fraunhofer.ipa.ros.edit/icons/full/ctool16/CreateInterfaceType_namespace_PrivateNamespace.gif differ diff --git a/plugins/de.fraunhofer.ipa.ros.edit/icons/full/ctool16/CreateInterfaceType_namespace_RelativeNamespace.gif b/plugins/de.fraunhofer.ipa.ros.edit/icons/full/ctool16/CreateInterfaceType_namespace_RelativeNamespace.gif new file mode 100644 index 000000000..6b0229f02 Binary files /dev/null and b/plugins/de.fraunhofer.ipa.ros.edit/icons/full/ctool16/CreateInterfaceType_namespace_RelativeNamespace.gif differ diff --git a/plugins/de.fraunhofer.ipa.ros.edit/icons/full/obj16/InterfaceType.gif b/plugins/de.fraunhofer.ipa.ros.edit/icons/full/obj16/InterfaceType.gif new file mode 100644 index 000000000..9250fecbf Binary files /dev/null and b/plugins/de.fraunhofer.ipa.ros.edit/icons/full/obj16/InterfaceType.gif differ diff --git a/plugins/de.fraunhofer.ipa.ros.edit/plugin.properties b/plugins/de.fraunhofer.ipa.ros.edit/plugin.properties index 757a134d8..59e9aa641 100644 --- a/plugins/de.fraunhofer.ipa.ros.edit/plugin.properties +++ b/plugins/de.fraunhofer.ipa.ros.edit/plugin.properties @@ -182,3 +182,13 @@ _UI_Parameter_value_feature = Value _UI_Package_fromGitRepo_feature = From Git Repo _UI_Package_dependency_feature = Dependency _UI_AmentPackage_type = Ament Package +_UI_InterfaceType_type = Interface Type +_UI_QualityOfService_type = Quality Of Service +_UI_InterfaceType_namespace_feature = Namespace +_UI_InterfaceType_name_feature = Name +_UI_InterfaceType_qos_feature = Qos +_UI_QualityOfService_QoSProfile_feature = Qo SProfile +_UI_QualityOfService_History_feature = History +_UI_QualityOfService_Depth_feature = Depth +_UI_QualityOfService_Reliability_feature = Reliability +_UI_QualityOfService_Durability_feature = Durability diff --git a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ActionClientItemProvider.java b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ActionClientItemProvider.java index 34d0eae2d..cdc94917b 100644 --- a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ActionClientItemProvider.java +++ b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ActionClientItemProvider.java @@ -21,7 +21,7 @@ * * @generated */ -public class ActionClientItemProvider extends NamespacedElementItemProvider { +public class ActionClientItemProvider extends InterfaceTypeItemProvider { /** * This constructs an instance from a factory and a notifier. * diff --git a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ActionServerItemProvider.java b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ActionServerItemProvider.java index 98e354497..b42b8224c 100644 --- a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ActionServerItemProvider.java +++ b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ActionServerItemProvider.java @@ -21,7 +21,7 @@ * * @generated */ -public class ActionServerItemProvider extends NamespacedElementItemProvider { +public class ActionServerItemProvider extends InterfaceTypeItemProvider { /** * This constructs an instance from a factory and a notifier. * diff --git a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/NamespacedElementItemProvider.java b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/InterfaceTypeItemProvider.java similarity index 75% rename from plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/NamespacedElementItemProvider.java rename to plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/InterfaceTypeItemProvider.java index 5943ded6e..e9d8c9094 100644 --- a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/NamespacedElementItemProvider.java +++ b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/InterfaceTypeItemProvider.java @@ -24,17 +24,17 @@ import org.eclipse.emf.edit.provider.ItemProviderAdapter; import org.eclipse.emf.edit.provider.ViewerNotification; -import ros.NamespacedElement; +import ros.InterfaceType; import ros.RosFactory; import ros.RosPackage; /** - * This is the item provider adapter for a {@link ros.NamespacedElement} object. + * This is the item provider adapter for a {@link ros.InterfaceType} object. * * * @generated */ -public class NamespacedElementItemProvider +public class InterfaceTypeItemProvider extends ItemProviderAdapter implements IEditingDomainItemProvider, @@ -48,7 +48,7 @@ public class NamespacedElementItemProvider * * @generated */ - public NamespacedElementItemProvider(AdapterFactory adapterFactory) { + public InterfaceTypeItemProvider(AdapterFactory adapterFactory) { super(adapterFactory); } @@ -64,6 +64,7 @@ public List getPropertyDescriptors(Object object) { super.getPropertyDescriptors(object); addNamePropertyDescriptor(object); + addQosPropertyDescriptor(object); } return itemPropertyDescriptors; } @@ -79,9 +80,9 @@ protected void addNamePropertyDescriptor(Object object) { (createItemPropertyDescriptor (((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(), getResourceLocator(), - getString("_UI_NamespacedElement_name_feature"), - getString("_UI_PropertyDescriptor_description", "_UI_NamespacedElement_name_feature", "_UI_NamespacedElement_type"), - RosPackage.Literals.NAMESPACED_ELEMENT__NAME, + getString("_UI_InterfaceType_name_feature"), + getString("_UI_PropertyDescriptor_description", "_UI_InterfaceType_name_feature", "_UI_InterfaceType_type"), + RosPackage.Literals.INTERFACE_TYPE__NAME, true, false, false, @@ -90,6 +91,28 @@ protected void addNamePropertyDescriptor(Object object) { null)); } + /** + * This adds a property descriptor for the Qos feature. + * + * + * @generated + */ + protected void addQosPropertyDescriptor(Object object) { + itemPropertyDescriptors.add + (createItemPropertyDescriptor + (((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(), + getResourceLocator(), + getString("_UI_InterfaceType_qos_feature"), + getString("_UI_PropertyDescriptor_description", "_UI_InterfaceType_qos_feature", "_UI_InterfaceType_type"), + RosPackage.Literals.INTERFACE_TYPE__QOS, + true, + false, + true, + null, + null, + null)); + } + /** * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or @@ -102,7 +125,7 @@ protected void addNamePropertyDescriptor(Object object) { public Collection getChildrenFeatures(Object object) { if (childrenFeatures == null) { super.getChildrenFeatures(object); - childrenFeatures.add(RosPackage.Literals.NAMESPACED_ELEMENT__NAMESPACE); + childrenFeatures.add(RosPackage.Literals.INTERFACE_TYPE__NAMESPACE); } return childrenFeatures; } @@ -121,14 +144,14 @@ protected EStructuralFeature getChildFeature(Object object, Object child) { } /** - * This returns NamespacedElement.gif. + * This returns InterfaceType.gif. * * * @generated */ @Override public Object getImage(Object object) { - return overlayImage(object, getResourceLocator().getImage("full/obj16/NamespacedElement")); + return overlayImage(object, getResourceLocator().getImage("full/obj16/InterfaceType")); } /** @@ -139,12 +162,12 @@ public Object getImage(Object object) { */ @Override public String getText(Object object) { - String label = ((NamespacedElement)object).getName(); + String label = ((InterfaceType)object).getName(); return label == null || label.length() == 0 ? - getString("_UI_NamespacedElement_type") : - getString("_UI_NamespacedElement_type") + " " + label; + getString("_UI_InterfaceType_type") : + getString("_UI_InterfaceType_type") + " " + label; } - + /** * This handles model notifications by calling {@link #updateChildren} to update any cached @@ -157,11 +180,11 @@ public String getText(Object object) { public void notifyChanged(Notification notification) { updateChildren(notification); - switch (notification.getFeatureID(NamespacedElement.class)) { - case RosPackage.NAMESPACED_ELEMENT__NAME: + switch (notification.getFeatureID(InterfaceType.class)) { + case RosPackage.INTERFACE_TYPE__NAME: fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true)); return; - case RosPackage.NAMESPACED_ELEMENT__NAMESPACE: + case RosPackage.INTERFACE_TYPE__NAMESPACE: fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false)); return; } @@ -181,17 +204,17 @@ protected void collectNewChildDescriptors(Collection newChildDescriptors newChildDescriptors.add (createChildParameter - (RosPackage.Literals.NAMESPACED_ELEMENT__NAMESPACE, + (RosPackage.Literals.INTERFACE_TYPE__NAMESPACE, RosFactory.eINSTANCE.createGlobalNamespace())); newChildDescriptors.add (createChildParameter - (RosPackage.Literals.NAMESPACED_ELEMENT__NAMESPACE, + (RosPackage.Literals.INTERFACE_TYPE__NAMESPACE, RosFactory.eINSTANCE.createRelativeNamespace())); newChildDescriptors.add (createChildParameter - (RosPackage.Literals.NAMESPACED_ELEMENT__NAMESPACE, + (RosPackage.Literals.INTERFACE_TYPE__NAMESPACE, RosFactory.eINSTANCE.createPrivateNamespace())); } diff --git a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ParameterItemProvider.java b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ParameterItemProvider.java index f7de4cbc8..d3b049357 100644 --- a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ParameterItemProvider.java +++ b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ParameterItemProvider.java @@ -25,7 +25,7 @@ * * @generated */ -public class ParameterItemProvider extends NamespacedElementItemProvider { +public class ParameterItemProvider extends InterfaceTypeItemProvider { /** * This constructs an instance from a factory and a notifier. * diff --git a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/PublisherItemProvider.java b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/PublisherItemProvider.java index d1026e14c..428351edf 100644 --- a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/PublisherItemProvider.java +++ b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/PublisherItemProvider.java @@ -21,7 +21,7 @@ * * @generated */ -public class PublisherItemProvider extends NamespacedElementItemProvider { +public class PublisherItemProvider extends InterfaceTypeItemProvider { /** * This constructs an instance from a factory and a notifier. * diff --git a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/QualityOfServiceItemProvider.java b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/QualityOfServiceItemProvider.java new file mode 100644 index 000000000..521d8dbbf --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/QualityOfServiceItemProvider.java @@ -0,0 +1,243 @@ +/** + */ +package ros.provider; + + +import java.util.Collection; +import java.util.List; + +import org.eclipse.emf.common.notify.AdapterFactory; +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.common.util.ResourceLocator; + +import org.eclipse.emf.edit.provider.ComposeableAdapterFactory; +import org.eclipse.emf.edit.provider.IEditingDomainItemProvider; +import org.eclipse.emf.edit.provider.IItemLabelProvider; +import org.eclipse.emf.edit.provider.IItemPropertyDescriptor; +import org.eclipse.emf.edit.provider.IItemPropertySource; +import org.eclipse.emf.edit.provider.IStructuredItemContentProvider; +import org.eclipse.emf.edit.provider.ITreeItemContentProvider; +import org.eclipse.emf.edit.provider.ItemPropertyDescriptor; +import org.eclipse.emf.edit.provider.ItemProviderAdapter; +import org.eclipse.emf.edit.provider.ViewerNotification; + +import ros.QualityOfService; +import ros.RosPackage; + +/** + * This is the item provider adapter for a {@link ros.QualityOfService} object. + * + * + * @generated + */ +public class QualityOfServiceItemProvider + extends ItemProviderAdapter + implements + IEditingDomainItemProvider, + IStructuredItemContentProvider, + ITreeItemContentProvider, + IItemLabelProvider, + IItemPropertySource { + /** + * This constructs an instance from a factory and a notifier. + * + * + * @generated + */ + public QualityOfServiceItemProvider(AdapterFactory adapterFactory) { + super(adapterFactory); + } + + /** + * This returns the property descriptors for the adapted class. + * + * + * @generated + */ + @Override + public List getPropertyDescriptors(Object object) { + if (itemPropertyDescriptors == null) { + super.getPropertyDescriptors(object); + + addQoSProfilePropertyDescriptor(object); + addHistoryPropertyDescriptor(object); + addDepthPropertyDescriptor(object); + addReliabilityPropertyDescriptor(object); + addDurabilityPropertyDescriptor(object); + } + return itemPropertyDescriptors; + } + + /** + * This adds a property descriptor for the Qo SProfile feature. + * + * + * @generated + */ + protected void addQoSProfilePropertyDescriptor(Object object) { + itemPropertyDescriptors.add + (createItemPropertyDescriptor + (((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(), + getResourceLocator(), + getString("_UI_QualityOfService_QoSProfile_feature"), + getString("_UI_PropertyDescriptor_description", "_UI_QualityOfService_QoSProfile_feature", "_UI_QualityOfService_type"), + RosPackage.Literals.QUALITY_OF_SERVICE__QO_SPROFILE, + true, + false, + false, + ItemPropertyDescriptor.GENERIC_VALUE_IMAGE, + null, + null)); + } + + /** + * This adds a property descriptor for the History feature. + * + * + * @generated + */ + protected void addHistoryPropertyDescriptor(Object object) { + itemPropertyDescriptors.add + (createItemPropertyDescriptor + (((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(), + getResourceLocator(), + getString("_UI_QualityOfService_History_feature"), + getString("_UI_PropertyDescriptor_description", "_UI_QualityOfService_History_feature", "_UI_QualityOfService_type"), + RosPackage.Literals.QUALITY_OF_SERVICE__HISTORY, + true, + false, + false, + ItemPropertyDescriptor.GENERIC_VALUE_IMAGE, + null, + null)); + } + + /** + * This adds a property descriptor for the Depth feature. + * + * + * @generated + */ + protected void addDepthPropertyDescriptor(Object object) { + itemPropertyDescriptors.add + (createItemPropertyDescriptor + (((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(), + getResourceLocator(), + getString("_UI_QualityOfService_Depth_feature"), + getString("_UI_PropertyDescriptor_description", "_UI_QualityOfService_Depth_feature", "_UI_QualityOfService_type"), + RosPackage.Literals.QUALITY_OF_SERVICE__DEPTH, + true, + false, + false, + ItemPropertyDescriptor.INTEGRAL_VALUE_IMAGE, + null, + null)); + } + + /** + * This adds a property descriptor for the Reliability feature. + * + * + * @generated + */ + protected void addReliabilityPropertyDescriptor(Object object) { + itemPropertyDescriptors.add + (createItemPropertyDescriptor + (((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(), + getResourceLocator(), + getString("_UI_QualityOfService_Reliability_feature"), + getString("_UI_PropertyDescriptor_description", "_UI_QualityOfService_Reliability_feature", "_UI_QualityOfService_type"), + RosPackage.Literals.QUALITY_OF_SERVICE__RELIABILITY, + true, + false, + false, + ItemPropertyDescriptor.GENERIC_VALUE_IMAGE, + null, + null)); + } + + /** + * This adds a property descriptor for the Durability feature. + * + * + * @generated + */ + protected void addDurabilityPropertyDescriptor(Object object) { + itemPropertyDescriptors.add + (createItemPropertyDescriptor + (((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(), + getResourceLocator(), + getString("_UI_QualityOfService_Durability_feature"), + getString("_UI_PropertyDescriptor_description", "_UI_QualityOfService_Durability_feature", "_UI_QualityOfService_type"), + RosPackage.Literals.QUALITY_OF_SERVICE__DURABILITY, + true, + false, + false, + ItemPropertyDescriptor.GENERIC_VALUE_IMAGE, + null, + null)); + } + + /** + * This returns the label text for the adapted class. + * + * + * @generated + */ + @Override + public String getText(Object object) { + String label = ((QualityOfService)object).getQoSProfile(); + return label == null || label.length() == 0 ? + getString("_UI_QualityOfService_type") : + getString("_UI_QualityOfService_type") + " " + label; + } + + + /** + * This handles model notifications by calling {@link #updateChildren} to update any cached + * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}. + * + * + * @generated + */ + @Override + public void notifyChanged(Notification notification) { + updateChildren(notification); + + switch (notification.getFeatureID(QualityOfService.class)) { + case RosPackage.QUALITY_OF_SERVICE__QO_SPROFILE: + case RosPackage.QUALITY_OF_SERVICE__HISTORY: + case RosPackage.QUALITY_OF_SERVICE__DEPTH: + case RosPackage.QUALITY_OF_SERVICE__RELIABILITY: + case RosPackage.QUALITY_OF_SERVICE__DURABILITY: + fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true)); + return; + } + super.notifyChanged(notification); + } + + /** + * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children + * that can be created under this object. + * + * + * @generated + */ + @Override + protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) { + super.collectNewChildDescriptors(newChildDescriptors, object); + } + + /** + * Return the resource locator for this item provider's resources. + * + * + * @generated + */ + @Override + public ResourceLocator getResourceLocator() { + return RosEditPlugin.INSTANCE; + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/RosItemProviderAdapterFactory.java b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/RosItemProviderAdapterFactory.java index bf5acfa13..20e1fd690 100644 --- a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/RosItemProviderAdapterFactory.java +++ b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/RosItemProviderAdapterFactory.java @@ -532,26 +532,26 @@ public Adapter createPrivateNamespaceAdapter() { } /** - * This keeps track of the one adapter used for all {@link ros.NamespacedElement} instances. + * This keeps track of the one adapter used for all {@link ros.InterfaceType} instances. * * * @generated */ - protected NamespacedElementItemProvider namespacedElementItemProvider; + protected InterfaceTypeItemProvider interfaceTypeItemProvider; /** - * This creates an adapter for a {@link ros.NamespacedElement}. + * This creates an adapter for a {@link ros.InterfaceType}. * * * @generated */ @Override - public Adapter createNamespacedElementAdapter() { - if (namespacedElementItemProvider == null) { - namespacedElementItemProvider = new NamespacedElementItemProvider(this); + public Adapter createInterfaceTypeAdapter() { + if (interfaceTypeItemProvider == null) { + interfaceTypeItemProvider = new InterfaceTypeItemProvider(this); } - return namespacedElementItemProvider; + return interfaceTypeItemProvider; } /** @@ -1083,6 +1083,29 @@ public Adapter createAmentPackageAdapter() { return amentPackageItemProvider; } + /** + * This keeps track of the one adapter used for all {@link ros.QualityOfService} instances. + * + * + * @generated + */ + protected QualityOfServiceItemProvider qualityOfServiceItemProvider; + + /** + * This creates an adapter for a {@link ros.QualityOfService}. + * + * + * @generated + */ + @Override + public Adapter createQualityOfServiceAdapter() { + if (qualityOfServiceItemProvider == null) { + qualityOfServiceItemProvider = new QualityOfServiceItemProvider(this); + } + + return qualityOfServiceItemProvider; + } + /** * This returns the root adapter factory that contains this factory. * @@ -1208,7 +1231,7 @@ public void dispose() { if (globalNamespaceItemProvider != null) globalNamespaceItemProvider.dispose(); if (relativeNamespaceItemProvider != null) relativeNamespaceItemProvider.dispose(); if (privateNamespaceItemProvider != null) privateNamespaceItemProvider.dispose(); - if (namespacedElementItemProvider != null) namespacedElementItemProvider.dispose(); + if (interfaceTypeItemProvider != null) interfaceTypeItemProvider.dispose(); if (parameterListTypeItemProvider != null) parameterListTypeItemProvider.dispose(); if (parameterStructTypeItemProvider != null) parameterStructTypeItemProvider.dispose(); if (parameterIntegerTypeItemProvider != null) parameterIntegerTypeItemProvider.dispose(); @@ -1232,6 +1255,7 @@ public void dispose() { if (parameterStructMemberItemProvider != null) parameterStructMemberItemProvider.dispose(); if (parameterDateItemProvider != null) parameterDateItemProvider.dispose(); if (amentPackageItemProvider != null) amentPackageItemProvider.dispose(); + if (qualityOfServiceItemProvider != null) qualityOfServiceItemProvider.dispose(); } } diff --git a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ServiceClientItemProvider.java b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ServiceClientItemProvider.java index fc87b2fe4..d7ad8164b 100644 --- a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ServiceClientItemProvider.java +++ b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ServiceClientItemProvider.java @@ -21,7 +21,7 @@ * * @generated */ -public class ServiceClientItemProvider extends NamespacedElementItemProvider { +public class ServiceClientItemProvider extends InterfaceTypeItemProvider { /** * This constructs an instance from a factory and a notifier. * diff --git a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ServiceServerItemProvider.java b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ServiceServerItemProvider.java index 077764e1a..8e84df9b7 100644 --- a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ServiceServerItemProvider.java +++ b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/ServiceServerItemProvider.java @@ -21,7 +21,7 @@ * * @generated */ -public class ServiceServerItemProvider extends NamespacedElementItemProvider { +public class ServiceServerItemProvider extends InterfaceTypeItemProvider { /** * This constructs an instance from a factory and a notifier. * diff --git a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/SubscriberItemProvider.java b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/SubscriberItemProvider.java index 4762f0798..bafacf1f9 100644 --- a/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/SubscriberItemProvider.java +++ b/plugins/de.fraunhofer.ipa.ros.edit/src/ros/provider/SubscriberItemProvider.java @@ -21,7 +21,7 @@ * * @generated */ -public class SubscriberItemProvider extends NamespacedElementItemProvider { +public class SubscriberItemProvider extends InterfaceTypeItemProvider { /** * This constructs an instance from a factory and a notifier. * diff --git a/plugins/de.fraunhofer.ipa.ros.feature/feature.xml b/plugins/de.fraunhofer.ipa.ros.feature/feature.xml index 1b380bc0f..8ef9f62f9 100644 --- a/plugins/de.fraunhofer.ipa.ros.feature/feature.xml +++ b/plugins/de.fraunhofer.ipa.ros.feature/feature.xml @@ -288,4 +288,46 @@ POSSIBILITY OF SUCH DAMAGE. version="2.0.0.qualifier" unpack="false"/> + + + + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros.parent/pom.xml b/plugins/de.fraunhofer.ipa.ros.parent/pom.xml index 0b8397748..add7ed7ee 100644 --- a/plugins/de.fraunhofer.ipa.ros.parent/pom.xml +++ b/plugins/de.fraunhofer.ipa.ros.parent/pom.xml @@ -20,7 +20,13 @@ ../de.fraunhofer.ipa.ros ../de.fraunhofer.ipa.ros.xtext ../de.fraunhofer.ipa.ros.xtext.ide - ../de.fraunhofer.ipa.ros.xtext.ui + ../de.fraunhofer.ipa.ros.xtext.ui + ../de.fraunhofer.ipa.ros1.xtext + ../de.fraunhofer.ipa.ros1.xtext.ide + ../de.fraunhofer.ipa.ros1.xtext.ui + ../de.fraunhofer.ipa.ros2.xtext + ../de.fraunhofer.ipa.ros2.xtext.ide + ../de.fraunhofer.ipa.ros2.xtext.ui ../de.fraunhofer.ipa.ros.edit ../de.fraunhofer.ipa.ros.editor ../de.fraunhofer.ipa.rossystem.model.combination @@ -36,7 +42,7 @@ ../de.fraunhofer.ipa.componentInterface.xtext.ui ../de.fraunhofer.ipa.componentInterface.edit ../de.fraunhofer.ipa.componentInterface.editor - ../de.fraunhofer.ipa.componentInterface.xtext.tests + ../de.fraunhofer.ipa.rossystem ../de.fraunhofer.ipa.rossystem.xtext @@ -44,7 +50,7 @@ ../de.fraunhofer.ipa.rossystem.xtext.ui ../de.fraunhofer.ipa.rossystem.edit ../de.fraunhofer.ipa.rossystem.editor - ../de.fraunhofer.ipa.rossystem.xtext.tests + ../de.fraunhofer.ipa.rossystem.deployment ../de.fraunhofer.ipa.ros.plugin diff --git a/plugins/de.fraunhofer.ipa.ros.tests/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.ros.tests/META-INF/MANIFEST.MF index f88a38ed2..8715c44f4 100644 --- a/plugins/de.fraunhofer.ipa.ros.tests/META-INF/MANIFEST.MF +++ b/plugins/de.fraunhofer.ipa.ros.tests/META-INF/MANIFEST.MF @@ -2,12 +2,14 @@ Manifest-Version: 1.0 Bundle-ManifestVersion: 2 Bundle-Name: %pluginName Bundle-SymbolicName: de.fraunhofer.ipa.ros.tests;singleton:=true +Automatic-Module-Name: de.fraunhofer.ipa.ros.tests Bundle-Version: 1.0.0.qualifier Bundle-ClassPath: . Bundle-Vendor: %providerName Bundle-Localization: plugin Bundle-RequiredExecutionEnvironment: JavaSE-1.8 -Export-Package: ros.tests +Export-Package: primitives.tests, + ros.tests Require-Bundle: org.eclipse.core.runtime, de.fraunhofer.ipa.ros;visibility:=reexport, org.eclipse.emf.ecore.xmi;visibility:=reexport, diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/AbstractTypeTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/AbstractTypeTest.java new file mode 100644 index 000000000..af2c0594e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/AbstractTypeTest.java @@ -0,0 +1,55 @@ +/** + */ +package primitives.tests; + +import junit.framework.TestCase; + +import primitives.AbstractType; + +/** + * + * A test case for the model object 'Abstract Type'. + * + * @generated + */ +public abstract class AbstractTypeTest extends TestCase { + + /** + * The fixture for this Abstract Type test case. + * + * + * @generated + */ + protected AbstractType fixture = null; + + /** + * Constructs a new Abstract Type test case with the given name. + * + * + * @generated + */ + public AbstractTypeTest(String name) { + super(name); + } + + /** + * Sets the fixture for this Abstract Type test case. + * + * + * @generated + */ + protected void setFixture(AbstractType fixture) { + this.fixture = fixture; + } + + /** + * Returns the fixture for this Abstract Type test case. + * + * + * @generated + */ + protected AbstractType getFixture() { + return fixture; + } + +} //AbstractTypeTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/ArrayTopicSpecRefTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/ArrayTopicSpecRefTest.java new file mode 100644 index 000000000..2475453de --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/ArrayTopicSpecRefTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.ArrayTopicSpecRef; +import primitives.PrimitivesFactory; + +/** + * + * A test case for the model object 'Array Topic Spec Ref'. + * + * @generated + */ +public class ArrayTopicSpecRefTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(ArrayTopicSpecRefTest.class); + } + + /** + * Constructs a new Array Topic Spec Ref test case with the given name. + * + * + * @generated + */ + public ArrayTopicSpecRefTest(String name) { + super(name); + } + + /** + * Returns the fixture for this Array Topic Spec Ref test case. + * + * + * @generated + */ + @Override + protected ArrayTopicSpecRef getFixture() { + return (ArrayTopicSpecRef)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createArrayTopicSpecRef()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //ArrayTopicSpecRefTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/ByteArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/ByteArrayTest.java new file mode 100644 index 000000000..7d465ad40 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/ByteArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.ByteArray; +import primitives.PrimitivesFactory; + +/** + * + * A test case for the model object 'Byte Array'. + * + * @generated + */ +public class ByteArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(ByteArrayTest.class); + } + + /** + * Constructs a new Byte Array test case with the given name. + * + * + * @generated + */ + public ByteArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this Byte Array test case. + * + * + * @generated + */ + @Override + protected ByteArray getFixture() { + return (ByteArray)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createByteArray()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //ByteArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/ByteTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/ByteTest.java new file mode 100644 index 000000000..ab823afca --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/ByteTest.java @@ -0,0 +1,69 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; + +/** + * + * A test case for the model object 'Byte'. + * + * @generated + */ +public class ByteTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(ByteTest.class); + } + + /** + * Constructs a new Byte test case with the given name. + * + * + * @generated + */ + public ByteTest(String name) { + super(name); + } + + /** + * Returns the fixture for this Byte test case. + * + * + * @generated + */ + @Override + protected primitives.Byte getFixture() { + return (primitives.Byte)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createByte()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //ByteTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/HeaderTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/HeaderTest.java new file mode 100644 index 000000000..2813533f9 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/HeaderTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.Header; +import primitives.PrimitivesFactory; + +/** + * + * A test case for the model object 'Header'. + * + * @generated + */ +public class HeaderTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(HeaderTest.class); + } + + /** + * Constructs a new Header test case with the given name. + * + * + * @generated + */ + public HeaderTest(String name) { + super(name); + } + + /** + * Returns the fixture for this Header test case. + * + * + * @generated + */ + @Override + protected Header getFixture() { + return (Header)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createHeader()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //HeaderTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/MessagePartTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/MessagePartTest.java new file mode 100644 index 000000000..a651eacf1 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/MessagePartTest.java @@ -0,0 +1,89 @@ +/** + */ +package primitives.tests; + +import junit.framework.TestCase; + +import junit.textui.TestRunner; + +import primitives.MessagePart; +import primitives.PrimitivesFactory; + +/** + * + * A test case for the model object 'Message Part'. + * + * @generated + */ +public class MessagePartTest extends TestCase { + + /** + * The fixture for this Message Part test case. + * + * + * @generated + */ + protected MessagePart fixture = null; + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(MessagePartTest.class); + } + + /** + * Constructs a new Message Part test case with the given name. + * + * + * @generated + */ + public MessagePartTest(String name) { + super(name); + } + + /** + * Sets the fixture for this Message Part test case. + * + * + * @generated + */ + protected void setFixture(MessagePart fixture) { + this.fixture = fixture; + } + + /** + * Returns the fixture for this Message Part test case. + * + * + * @generated + */ + protected MessagePart getFixture() { + return fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createMessagePart()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //MessagePartTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/PrimitivesExample.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/PrimitivesExample.java new file mode 100644 index 000000000..b9a542f21 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/PrimitivesExample.java @@ -0,0 +1,121 @@ +/** + */ +package primitives.tests; + +import java.io.File; +import java.io.IOException; + +import org.eclipse.emf.common.util.Diagnostic; +import org.eclipse.emf.common.util.URI; + +import org.eclipse.emf.ecore.EObject; + +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.resource.ResourceSet; + +import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl; + +import org.eclipse.emf.ecore.util.Diagnostician; + +import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl; + +import primitives.MessagePart; +import primitives.PrimitivesFactory; +import primitives.PrimitivesPackage; + +/** + * + * A sample utility for the 'primitives' package. + * + * @generated + */ +public class PrimitivesExample { + /** + * + * Load all the argument file paths or URIs as instances of the model. + * + * @param args the file paths or URIs. + * @generated + */ + public static void main(String[] args) { + // Create a resource set to hold the resources. + // + ResourceSet resourceSet = new ResourceSetImpl(); + + // Register the appropriate resource factory to handle all file extensions. + // + resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap().put + (Resource.Factory.Registry.DEFAULT_EXTENSION, + new XMIResourceFactoryImpl()); + + // Register the package to ensure it is available during loading. + // + resourceSet.getPackageRegistry().put + (PrimitivesPackage.eNS_URI, + PrimitivesPackage.eINSTANCE); + + // If there are no arguments, emit an appropriate usage message. + // + if (args.length == 0) { + System.out.println("Enter a list of file paths or URIs that have content like this:"); + try { + Resource resource = resourceSet.createResource(URI.createURI("http:///My.primitives")); + MessagePart root = PrimitivesFactory.eINSTANCE.createMessagePart(); + resource.getContents().add(root); + resource.save(System.out, null); + } + catch (IOException exception) { + exception.printStackTrace(); + } + } + else { + // Iterate over all the arguments. + // + for (int i = 0; i < args.length; ++i) { + // Construct the URI for the instance file. + // The argument is treated as a file path only if it denotes an existing file. + // Otherwise, it's directly treated as a URL. + // + File file = new File(args[i]); + URI uri = file.isFile() ? URI.createFileURI(file.getAbsolutePath()): URI.createURI(args[i]); + + try { + // Demand load resource for this file. + // + Resource resource = resourceSet.getResource(uri, true); + System.out.println("Loaded " + uri); + + // Validate the contents of the loaded resource. + // + for (EObject eObject : resource.getContents()) { + Diagnostic diagnostic = Diagnostician.INSTANCE.validate(eObject); + if (diagnostic.getSeverity() != Diagnostic.OK) { + printDiagnostic(diagnostic, ""); + } + } + } + catch (RuntimeException exception) { + System.out.println("Problem loading " + uri); + exception.printStackTrace(); + } + } + } + } + + /** + * + * Prints diagnostics with indentation. + * + * @param diagnostic the diagnostic to print. + * @param indent the indentation for printing. + * @generated + */ + protected static void printDiagnostic(Diagnostic diagnostic, String indent) { + System.out.print(indent); + System.out.println(diagnostic.getMessage()); + for (Diagnostic child : diagnostic.getChildren()) { + printDiagnostic(child, indent + " "); + } + } + +} //PrimitivesExample diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/PrimitivesTests.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/PrimitivesTests.java new file mode 100644 index 000000000..db0cb7656 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/PrimitivesTests.java @@ -0,0 +1,46 @@ +/** + */ +package primitives.tests; + +import junit.framework.Test; +import junit.framework.TestSuite; + +import junit.textui.TestRunner; + +/** + * + * A test suite for the 'primitives' package. + * + * @generated + */ +public class PrimitivesTests extends TestSuite { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(suite()); + } + + /** + * + * + * @generated + */ + public static Test suite() { + TestSuite suite = new PrimitivesTests("primitives Tests"); + return suite; + } + + /** + * + * + * @generated + */ + public PrimitivesTests(String name) { + super(name); + } + +} //PrimitivesTests diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/TopicSpecRefTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/TopicSpecRefTest.java new file mode 100644 index 000000000..9dedc3bd8 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/TopicSpecRefTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.TopicSpecRef; + +/** + * + * A test case for the model object 'Topic Spec Ref'. + * + * @generated + */ +public class TopicSpecRefTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(TopicSpecRefTest.class); + } + + /** + * Constructs a new Topic Spec Ref test case with the given name. + * + * + * @generated + */ + public TopicSpecRefTest(String name) { + super(name); + } + + /** + * Returns the fixture for this Topic Spec Ref test case. + * + * + * @generated + */ + @Override + protected TopicSpecRef getFixture() { + return (TopicSpecRef)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createTopicSpecRef()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //TopicSpecRefTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/boolArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/boolArrayTest.java new file mode 100644 index 000000000..43e570556 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/boolArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.boolArray; + +/** + * + * A test case for the model object 'bool Array'. + * + * @generated + */ +public class boolArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(boolArrayTest.class); + } + + /** + * Constructs a new bool Array test case with the given name. + * + * + * @generated + */ + public boolArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this bool Array test case. + * + * + * @generated + */ + @Override + protected boolArray getFixture() { + return (boolArray)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createboolArray()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //boolArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/boolTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/boolTest.java new file mode 100644 index 000000000..56c60aa39 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/boolTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.bool; + +/** + * + * A test case for the model object 'bool'. + * + * @generated + */ +public class boolTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(boolTest.class); + } + + /** + * Constructs a new bool test case with the given name. + * + * + * @generated + */ + public boolTest(String name) { + super(name); + } + + /** + * Returns the fixture for this bool test case. + * + * + * @generated + */ + @Override + protected bool getFixture() { + return (bool)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createbool()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //boolTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/durationTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/durationTest.java new file mode 100644 index 000000000..b166c066e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/durationTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.duration; + +/** + * + * A test case for the model object 'duration'. + * + * @generated + */ +public class durationTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(durationTest.class); + } + + /** + * Constructs a new duration test case with the given name. + * + * + * @generated + */ + public durationTest(String name) { + super(name); + } + + /** + * Returns the fixture for this duration test case. + * + * + * @generated + */ + @Override + protected duration getFixture() { + return (duration)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createduration()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //durationTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float32ArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float32ArrayTest.java new file mode 100644 index 000000000..67c43f5c9 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float32ArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.float32Array; + +/** + * + * A test case for the model object 'float32 Array'. + * + * @generated + */ +public class float32ArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(float32ArrayTest.class); + } + + /** + * Constructs a new float32 Array test case with the given name. + * + * + * @generated + */ + public float32ArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this float32 Array test case. + * + * + * @generated + */ + @Override + protected float32Array getFixture() { + return (float32Array)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createfloat32Array()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //float32ArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float32Test.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float32Test.java new file mode 100644 index 000000000..253bdcfce --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float32Test.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.float32; + +/** + * + * A test case for the model object 'float32'. + * + * @generated + */ +public class float32Test extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(float32Test.class); + } + + /** + * Constructs a new float32 test case with the given name. + * + * + * @generated + */ + public float32Test(String name) { + super(name); + } + + /** + * Returns the fixture for this float32 test case. + * + * + * @generated + */ + @Override + protected float32 getFixture() { + return (float32)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createfloat32()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //float32Test diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float64ArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float64ArrayTest.java new file mode 100644 index 000000000..933e25f6e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float64ArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.float64Array; + +/** + * + * A test case for the model object 'float64 Array'. + * + * @generated + */ +public class float64ArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(float64ArrayTest.class); + } + + /** + * Constructs a new float64 Array test case with the given name. + * + * + * @generated + */ + public float64ArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this float64 Array test case. + * + * + * @generated + */ + @Override + protected float64Array getFixture() { + return (float64Array)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createfloat64Array()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //float64ArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float64Test.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float64Test.java new file mode 100644 index 000000000..810dc09b0 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/float64Test.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.float64; + +/** + * + * A test case for the model object 'float64'. + * + * @generated + */ +public class float64Test extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(float64Test.class); + } + + /** + * Constructs a new float64 test case with the given name. + * + * + * @generated + */ + public float64Test(String name) { + super(name); + } + + /** + * Returns the fixture for this float64 test case. + * + * + * @generated + */ + @Override + protected float64 getFixture() { + return (float64)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createfloat64()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //float64Test diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int16ArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int16ArrayTest.java new file mode 100644 index 000000000..86076e29c --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int16ArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.int16Array; + +/** + * + * A test case for the model object 'int16 Array'. + * + * @generated + */ +public class int16ArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(int16ArrayTest.class); + } + + /** + * Constructs a new int16 Array test case with the given name. + * + * + * @generated + */ + public int16ArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this int16 Array test case. + * + * + * @generated + */ + @Override + protected int16Array getFixture() { + return (int16Array)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createint16Array()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //int16ArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int16Test.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int16Test.java new file mode 100644 index 000000000..7ae371ecd --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int16Test.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.int16; + +/** + * + * A test case for the model object 'int16'. + * + * @generated + */ +public class int16Test extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(int16Test.class); + } + + /** + * Constructs a new int16 test case with the given name. + * + * + * @generated + */ + public int16Test(String name) { + super(name); + } + + /** + * Returns the fixture for this int16 test case. + * + * + * @generated + */ + @Override + protected int16 getFixture() { + return (int16)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createint16()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //int16Test diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int32ArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int32ArrayTest.java new file mode 100644 index 000000000..901ab9350 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int32ArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.int32Array; + +/** + * + * A test case for the model object 'int32 Array'. + * + * @generated + */ +public class int32ArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(int32ArrayTest.class); + } + + /** + * Constructs a new int32 Array test case with the given name. + * + * + * @generated + */ + public int32ArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this int32 Array test case. + * + * + * @generated + */ + @Override + protected int32Array getFixture() { + return (int32Array)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createint32Array()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //int32ArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int32Test.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int32Test.java new file mode 100644 index 000000000..65c22d3d8 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int32Test.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.int32; + +/** + * + * A test case for the model object 'int32'. + * + * @generated + */ +public class int32Test extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(int32Test.class); + } + + /** + * Constructs a new int32 test case with the given name. + * + * + * @generated + */ + public int32Test(String name) { + super(name); + } + + /** + * Returns the fixture for this int32 test case. + * + * + * @generated + */ + @Override + protected int32 getFixture() { + return (int32)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createint32()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //int32Test diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int64ArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int64ArrayTest.java new file mode 100644 index 000000000..adcff00c2 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int64ArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.int64Array; + +/** + * + * A test case for the model object 'int64 Array'. + * + * @generated + */ +public class int64ArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(int64ArrayTest.class); + } + + /** + * Constructs a new int64 Array test case with the given name. + * + * + * @generated + */ + public int64ArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this int64 Array test case. + * + * + * @generated + */ + @Override + protected int64Array getFixture() { + return (int64Array)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createint64Array()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //int64ArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int64Test.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int64Test.java new file mode 100644 index 000000000..564f80f79 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int64Test.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.int64; + +/** + * + * A test case for the model object 'int64'. + * + * @generated + */ +public class int64Test extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(int64Test.class); + } + + /** + * Constructs a new int64 test case with the given name. + * + * + * @generated + */ + public int64Test(String name) { + super(name); + } + + /** + * Returns the fixture for this int64 test case. + * + * + * @generated + */ + @Override + protected int64 getFixture() { + return (int64)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createint64()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //int64Test diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int8ArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int8ArrayTest.java new file mode 100644 index 000000000..d5867d799 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int8ArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.int8Array; + +/** + * + * A test case for the model object 'int8 Array'. + * + * @generated + */ +public class int8ArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(int8ArrayTest.class); + } + + /** + * Constructs a new int8 Array test case with the given name. + * + * + * @generated + */ + public int8ArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this int8 Array test case. + * + * + * @generated + */ + @Override + protected int8Array getFixture() { + return (int8Array)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createint8Array()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //int8ArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int8Test.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int8Test.java new file mode 100644 index 000000000..85b760642 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/int8Test.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.int8; + +/** + * + * A test case for the model object 'int8'. + * + * @generated + */ +public class int8Test extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(int8Test.class); + } + + /** + * Constructs a new int8 test case with the given name. + * + * + * @generated + */ + public int8Test(String name) { + super(name); + } + + /** + * Returns the fixture for this int8 test case. + * + * + * @generated + */ + @Override + protected int8 getFixture() { + return (int8)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createint8()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //int8Test diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/stringArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/stringArrayTest.java new file mode 100644 index 000000000..28c4626a6 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/stringArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.stringArray; + +/** + * + * A test case for the model object 'string Array'. + * + * @generated + */ +public class stringArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(stringArrayTest.class); + } + + /** + * Constructs a new string Array test case with the given name. + * + * + * @generated + */ + public stringArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this string Array test case. + * + * + * @generated + */ + @Override + protected stringArray getFixture() { + return (stringArray)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createstringArray()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //stringArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/stringTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/stringTest.java new file mode 100644 index 000000000..3b026668a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/stringTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.string; + +/** + * + * A test case for the model object 'string'. + * + * @generated + */ +public class stringTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(stringTest.class); + } + + /** + * Constructs a new string test case with the given name. + * + * + * @generated + */ + public stringTest(String name) { + super(name); + } + + /** + * Returns the fixture for this string test case. + * + * + * @generated + */ + @Override + protected string getFixture() { + return (string)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createstring()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //stringTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/timeTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/timeTest.java new file mode 100644 index 000000000..14163d83e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/timeTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.time; + +/** + * + * A test case for the model object 'time'. + * + * @generated + */ +public class timeTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(timeTest.class); + } + + /** + * Constructs a new time test case with the given name. + * + * + * @generated + */ + public timeTest(String name) { + super(name); + } + + /** + * Returns the fixture for this time test case. + * + * + * @generated + */ + @Override + protected time getFixture() { + return (time)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createtime()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //timeTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint16ArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint16ArrayTest.java new file mode 100644 index 000000000..64b42aff1 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint16ArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.uint16Array; + +/** + * + * A test case for the model object 'uint16 Array'. + * + * @generated + */ +public class uint16ArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(uint16ArrayTest.class); + } + + /** + * Constructs a new uint16 Array test case with the given name. + * + * + * @generated + */ + public uint16ArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this uint16 Array test case. + * + * + * @generated + */ + @Override + protected uint16Array getFixture() { + return (uint16Array)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createuint16Array()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //uint16ArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint16Test.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint16Test.java new file mode 100644 index 000000000..8a55339bf --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint16Test.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.uint16; + +/** + * + * A test case for the model object 'uint16'. + * + * @generated + */ +public class uint16Test extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(uint16Test.class); + } + + /** + * Constructs a new uint16 test case with the given name. + * + * + * @generated + */ + public uint16Test(String name) { + super(name); + } + + /** + * Returns the fixture for this uint16 test case. + * + * + * @generated + */ + @Override + protected uint16 getFixture() { + return (uint16)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createuint16()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //uint16Test diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint32ArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint32ArrayTest.java new file mode 100644 index 000000000..d1b351968 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint32ArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.uint32Array; + +/** + * + * A test case for the model object 'uint32 Array'. + * + * @generated + */ +public class uint32ArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(uint32ArrayTest.class); + } + + /** + * Constructs a new uint32 Array test case with the given name. + * + * + * @generated + */ + public uint32ArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this uint32 Array test case. + * + * + * @generated + */ + @Override + protected uint32Array getFixture() { + return (uint32Array)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createuint32Array()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //uint32ArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint32Test.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint32Test.java new file mode 100644 index 000000000..c5f9923c3 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint32Test.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.uint32; + +/** + * + * A test case for the model object 'uint32'. + * + * @generated + */ +public class uint32Test extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(uint32Test.class); + } + + /** + * Constructs a new uint32 test case with the given name. + * + * + * @generated + */ + public uint32Test(String name) { + super(name); + } + + /** + * Returns the fixture for this uint32 test case. + * + * + * @generated + */ + @Override + protected uint32 getFixture() { + return (uint32)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createuint32()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //uint32Test diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint64ArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint64ArrayTest.java new file mode 100644 index 000000000..daeb2201f --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint64ArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.uint64Array; + +/** + * + * A test case for the model object 'uint64 Array'. + * + * @generated + */ +public class uint64ArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(uint64ArrayTest.class); + } + + /** + * Constructs a new uint64 Array test case with the given name. + * + * + * @generated + */ + public uint64ArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this uint64 Array test case. + * + * + * @generated + */ + @Override + protected uint64Array getFixture() { + return (uint64Array)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createuint64Array()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //uint64ArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint64Test.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint64Test.java new file mode 100644 index 000000000..9fa6e6791 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint64Test.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.uint64; + +/** + * + * A test case for the model object 'uint64'. + * + * @generated + */ +public class uint64Test extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(uint64Test.class); + } + + /** + * Constructs a new uint64 test case with the given name. + * + * + * @generated + */ + public uint64Test(String name) { + super(name); + } + + /** + * Returns the fixture for this uint64 test case. + * + * + * @generated + */ + @Override + protected uint64 getFixture() { + return (uint64)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createuint64()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //uint64Test diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint8ArrayTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint8ArrayTest.java new file mode 100644 index 000000000..2bef586c7 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint8ArrayTest.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.uint8Array; + +/** + * + * A test case for the model object 'uint8 Array'. + * + * @generated + */ +public class uint8ArrayTest extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(uint8ArrayTest.class); + } + + /** + * Constructs a new uint8 Array test case with the given name. + * + * + * @generated + */ + public uint8ArrayTest(String name) { + super(name); + } + + /** + * Returns the fixture for this uint8 Array test case. + * + * + * @generated + */ + @Override + protected uint8Array getFixture() { + return (uint8Array)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createuint8Array()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //uint8ArrayTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint8Test.java b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint8Test.java new file mode 100644 index 000000000..630298adf --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/primitives/tests/uint8Test.java @@ -0,0 +1,70 @@ +/** + */ +package primitives.tests; + +import junit.textui.TestRunner; + +import primitives.PrimitivesFactory; +import primitives.uint8; + +/** + * + * A test case for the model object 'uint8'. + * + * @generated + */ +public class uint8Test extends AbstractTypeTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(uint8Test.class); + } + + /** + * Constructs a new uint8 test case with the given name. + * + * + * @generated + */ + public uint8Test(String name) { + super(name); + } + + /** + * Returns the fixture for this uint8 test case. + * + * + * @generated + */ + @Override + protected uint8 getFixture() { + return (uint8)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(PrimitivesFactory.eINSTANCE.createuint8()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //uint8Test diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ActionClientTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ActionClientTest.java index c16fc46b4..feb2a1709 100644 --- a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ActionClientTest.java +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ActionClientTest.java @@ -13,7 +13,7 @@ * * @generated */ -public class ActionClientTest extends NamespacedElementTest { +public class ActionClientTest extends InterfaceTypeTest { /** * diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ActionServerTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ActionServerTest.java index 399e4a75e..fa186c318 100644 --- a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ActionServerTest.java +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ActionServerTest.java @@ -13,7 +13,7 @@ * * @generated */ -public class ActionServerTest extends NamespacedElementTest { +public class ActionServerTest extends InterfaceTypeTest { /** * diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/AmentPackageTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/AmentPackageTest.java new file mode 100644 index 000000000..c27c817b3 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/AmentPackageTest.java @@ -0,0 +1,70 @@ +/** + */ +package ros.tests; + +import junit.textui.TestRunner; + +import ros.AmentPackage; +import ros.RosFactory; + +/** + * + * A test case for the model object 'Ament Package'. + * + * @generated + */ +public class AmentPackageTest extends PackageTest { + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(AmentPackageTest.class); + } + + /** + * Constructs a new Ament Package test case with the given name. + * + * + * @generated + */ + public AmentPackageTest(String name) { + super(name); + } + + /** + * Returns the fixture for this Ament Package test case. + * + * + * @generated + */ + @Override + protected AmentPackage getFixture() { + return (AmentPackage)fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(RosFactory.eINSTANCE.createAmentPackage()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //AmentPackageTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/InterfaceTypeTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/InterfaceTypeTest.java new file mode 100644 index 000000000..923654db2 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/InterfaceTypeTest.java @@ -0,0 +1,89 @@ +/** + */ +package ros.tests; + +import junit.framework.TestCase; + +import junit.textui.TestRunner; + +import ros.InterfaceType; +import ros.RosFactory; + +/** + * + * A test case for the model object 'Interface Type'. + * + * @generated + */ +public class InterfaceTypeTest extends TestCase { + + /** + * The fixture for this Interface Type test case. + * + * + * @generated + */ + protected InterfaceType fixture = null; + + /** + * + * + * @generated + */ + public static void main(String[] args) { + TestRunner.run(InterfaceTypeTest.class); + } + + /** + * Constructs a new Interface Type test case with the given name. + * + * + * @generated + */ + public InterfaceTypeTest(String name) { + super(name); + } + + /** + * Sets the fixture for this Interface Type test case. + * + * + * @generated + */ + protected void setFixture(InterfaceType fixture) { + this.fixture = fixture; + } + + /** + * Returns the fixture for this Interface Type test case. + * + * + * @generated + */ + protected InterfaceType getFixture() { + return fixture; + } + + /** + * + * + * @see junit.framework.TestCase#setUp() + * @generated + */ + @Override + protected void setUp() throws Exception { + setFixture(RosFactory.eINSTANCE.createInterfaceType()); + } + + /** + * + * + * @see junit.framework.TestCase#tearDown() + * @generated + */ + @Override + protected void tearDown() throws Exception { + setFixture(null); + } + +} //InterfaceTypeTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ParameterTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ParameterTest.java index 072b79cd6..925a09cc4 100644 --- a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ParameterTest.java +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ParameterTest.java @@ -13,7 +13,7 @@ * * @generated */ -public class ParameterTest extends NamespacedElementTest { +public class ParameterTest extends InterfaceTypeTest { /** * diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/PublisherTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/PublisherTest.java index 209819485..b570dec46 100644 --- a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/PublisherTest.java +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/PublisherTest.java @@ -13,7 +13,7 @@ * * @generated */ -public class PublisherTest extends NamespacedElementTest { +public class PublisherTest extends InterfaceTypeTest { /** * diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/NamespacedElementTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/QualityOfServiceTest.java similarity index 60% rename from plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/NamespacedElementTest.java rename to plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/QualityOfServiceTest.java index e133111c4..5655d447b 100644 --- a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/NamespacedElementTest.java +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/QualityOfServiceTest.java @@ -5,25 +5,24 @@ import junit.framework.TestCase; import junit.textui.TestRunner; - -import ros.NamespacedElement; +import ros.QualityOfService; import ros.RosFactory; /** * - * A test case for the model object 'Namespaced Element'. + * A test case for the model object 'Quality Of Service'. * * @generated */ -public class NamespacedElementTest extends TestCase { +public class QualityOfServiceTest extends TestCase { /** - * The fixture for this Namespaced Element test case. + * The fixture for this Quality Of Service test case. * * * @generated */ - protected NamespacedElement fixture = null; + protected QualityOfService fixture = null; /** * @@ -31,36 +30,36 @@ public class NamespacedElementTest extends TestCase { * @generated */ public static void main(String[] args) { - TestRunner.run(NamespacedElementTest.class); + TestRunner.run(QualityOfServiceTest.class); } /** - * Constructs a new Namespaced Element test case with the given name. + * Constructs a new Quality Of Service test case with the given name. * * * @generated */ - public NamespacedElementTest(String name) { + public QualityOfServiceTest(String name) { super(name); } /** - * Sets the fixture for this Namespaced Element test case. + * Sets the fixture for this Quality Of Service test case. * * * @generated */ - protected void setFixture(NamespacedElement fixture) { + protected void setFixture(QualityOfService fixture) { this.fixture = fixture; } /** - * Returns the fixture for this Namespaced Element test case. + * Returns the fixture for this Quality Of Service test case. * * * @generated */ - protected NamespacedElement getFixture() { + protected QualityOfService getFixture() { return fixture; } @@ -72,7 +71,7 @@ protected NamespacedElement getFixture() { */ @Override protected void setUp() throws Exception { - setFixture(RosFactory.eINSTANCE.createNamespacedElement()); + setFixture(RosFactory.eINSTANCE.createQualityOfService()); } /** @@ -86,4 +85,4 @@ protected void tearDown() throws Exception { setFixture(null); } -} //NamespacedElementTest +} //QualityOfServiceTest diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ServiceClientTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ServiceClientTest.java index 935277e9b..654c5aca5 100644 --- a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ServiceClientTest.java +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ServiceClientTest.java @@ -13,7 +13,7 @@ * * @generated */ -public class ServiceClientTest extends NamespacedElementTest { +public class ServiceClientTest extends InterfaceTypeTest { /** * diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ServiceServerTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ServiceServerTest.java index 4da0123b8..82bb47c9c 100644 --- a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ServiceServerTest.java +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/ServiceServerTest.java @@ -13,7 +13,7 @@ * * @generated */ -public class ServiceServerTest extends NamespacedElementTest { +public class ServiceServerTest extends InterfaceTypeTest { /** * diff --git a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/SubscriberTest.java b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/SubscriberTest.java index e40f1c753..dc6f3110e 100644 --- a/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/SubscriberTest.java +++ b/plugins/de.fraunhofer.ipa.ros.tests/src/ros/tests/SubscriberTest.java @@ -13,7 +13,7 @@ * * @generated */ -public class SubscriberTest extends NamespacedElementTest { +public class SubscriberTest extends InterfaceTypeTest { /** * diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.ros.xtext.ide/META-INF/MANIFEST.MF index dd6eba63f..f4084bee4 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ide/META-INF/MANIFEST.MF +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/META-INF/MANIFEST.MF @@ -12,4 +12,5 @@ Require-Bundle: de.fraunhofer.ipa.ros.xtext, org.antlr.runtime;bundle-version="[3.2.0,3.2.1)" Bundle-RequiredExecutionEnvironment: JavaSE-1.8 Export-Package: de.fraunhofer.ipa.ros.ide.contentassist.antlr.internal, - de.fraunhofer.ipa.ros.ide.contentassist.antlr + de.fraunhofer.ipa.ros.ide.contentassist.antlr, + de.fraunhofer.ipa.ros.ide.contentassist.antlr.lexer diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/AbstractRosIdeModule.java b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/AbstractRosIdeModule.java index 8be3d369e..b259fc88b 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/AbstractRosIdeModule.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/AbstractRosIdeModule.java @@ -6,12 +6,14 @@ import com.google.inject.Binder; import com.google.inject.name.Names; import de.fraunhofer.ipa.ros.ide.contentassist.antlr.RosParser; -import de.fraunhofer.ipa.ros.ide.contentassist.antlr.internal.InternalRosLexer; +import de.fraunhofer.ipa.ros.ide.contentassist.antlr.lexer.InternalRosLexer; 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; @@ -42,6 +44,11 @@ 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; diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/RosParser.java b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/RosParser.java index e0b03855d..96ea47ba7 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/RosParser.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/RosParser.java @@ -9,6 +9,8 @@ import de.fraunhofer.ipa.ros.ide.contentassist.antlr.internal.InternalRosParser; import de.fraunhofer.ipa.ros.services.RosGrammarAccess; 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; @@ -31,77 +33,60 @@ public String getRuleName(AbstractElement element) { } private static void init(ImmutableMap.Builder builder, RosGrammarAccess grammarAccess) { - builder.put(grammarAccess.getPackageAccess().getAlternatives(), "rule__Package__Alternatives"); + builder.put(grammarAccess.getEStringAccess().getAlternatives(), "rule__EString__Alternatives"); + builder.put(grammarAccess.getRosNamesAccess().getAlternatives(), "rule__RosNames__Alternatives"); + builder.put(grammarAccess.getNodeAccess().getAlternatives_3(), "rule__Node__Alternatives_3"); builder.put(grammarAccess.getSpecBaseAccess().getAlternatives(), "rule__SpecBase__Alternatives"); + builder.put(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0(), "rule__TopicSpec__NameAlternatives_2_0"); builder.put(grammarAccess.getDependencyAccess().getAlternatives(), "rule__Dependency__Alternatives"); builder.put(grammarAccess.getNamespaceAccess().getAlternatives(), "rule__Namespace__Alternatives"); - builder.put(grammarAccess.getEStringAccess().getAlternatives(), "rule__EString__Alternatives"); - builder.put(grammarAccess.getRosNamesAccess().getAlternatives(), "rule__RosNames__Alternatives"); builder.put(grammarAccess.getRosParamNamesAccess().getAlternatives(), "rule__RosParamNames__Alternatives"); - builder.put(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0(), "rule__TopicSpec__NameAlternatives_2_0"); builder.put(grammarAccess.getParameterTypeAccess().getAlternatives(), "rule__ParameterType__Alternatives"); builder.put(grammarAccess.getParameterValueAccess().getAlternatives(), "rule__ParameterValue__Alternatives"); builder.put(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0(), "rule__MessagePart__DataAlternatives_1_0"); builder.put(grammarAccess.getAbstractTypeAccess().getAlternatives(), "rule__AbstractType__Alternatives"); builder.put(grammarAccess.getKEYWORDAccess().getAlternatives(), "rule__KEYWORD__Alternatives"); builder.put(grammarAccess.getPackageSetAccess().getGroup(), "rule__PackageSet__Group__0"); - builder.put(grammarAccess.getPackageSetAccess().getGroup_3(), "rule__PackageSet__Group_3__0"); - builder.put(grammarAccess.getPackageSetAccess().getGroup_3_1(), "rule__PackageSet__Group_3_1__0"); builder.put(grammarAccess.getPackage_ImplAccess().getGroup(), "rule__Package_Impl__Group__0"); builder.put(grammarAccess.getPackage_ImplAccess().getGroup_4(), "rule__Package_Impl__Group_4__0"); builder.put(grammarAccess.getPackage_ImplAccess().getGroup_5(), "rule__Package_Impl__Group_5__0"); - builder.put(grammarAccess.getPackage_ImplAccess().getGroup_5_3(), "rule__Package_Impl__Group_5_3__0"); builder.put(grammarAccess.getPackage_ImplAccess().getGroup_6(), "rule__Package_Impl__Group_6__0"); - builder.put(grammarAccess.getPackage_ImplAccess().getGroup_6_1(), "rule__Package_Impl__Group_6_1__0"); - builder.put(grammarAccess.getArtifactAccess().getGroup(), "rule__Artifact__Group__0"); + builder.put(grammarAccess.getPackage_ImplAccess().getGroup_6_3(), "rule__Package_Impl__Group_6_3__0"); 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_5_3(), "rule__CatkinPackage__Group_5_3__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.getCatkinPackageAccess().getGroup_7(), "rule__CatkinPackage__Group_7__0"); - builder.put(grammarAccess.getCatkinPackageAccess().getGroup_7_1(), "rule__CatkinPackage__Group_7_1__0"); builder.put(grammarAccess.getAmentPackageAccess().getGroup(), "rule__AmentPackage__Group__0"); - builder.put(grammarAccess.getAmentPackageAccess().getGroup_4(), "rule__AmentPackage__Group_4__0"); builder.put(grammarAccess.getAmentPackageAccess().getGroup_5(), "rule__AmentPackage__Group_5__0"); - builder.put(grammarAccess.getAmentPackageAccess().getGroup_5_3(), "rule__AmentPackage__Group_5_3__0"); builder.put(grammarAccess.getAmentPackageAccess().getGroup_6(), "rule__AmentPackage__Group_6__0"); - builder.put(grammarAccess.getAmentPackageAccess().getGroup_6_3(), "rule__AmentPackage__Group_6_3__0"); builder.put(grammarAccess.getAmentPackageAccess().getGroup_7(), "rule__AmentPackage__Group_7__0"); - builder.put(grammarAccess.getAmentPackageAccess().getGroup_7_1(), "rule__AmentPackage__Group_7_1__0"); + builder.put(grammarAccess.getAmentPackageAccess().getGroup_7_3(), "rule__AmentPackage__Group_7_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_0(), "rule__Node__Group_3_0__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_1(), "rule__Node__Group_3_1__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_2(), "rule__Node__Group_3_2__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_3(), "rule__Node__Group_3_3__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_4(), "rule__Node__Group_3_4__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_5(), "rule__Node__Group_3_5__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_6(), "rule__Node__Group_3_6__0"); + builder.put(grammarAccess.getTopicSpecAccess().getGroup(), "rule__TopicSpec__Group__0"); + builder.put(grammarAccess.getTopicSpecAccess().getGroup_5(), "rule__TopicSpec__Group_5__0"); builder.put(grammarAccess.getServiceSpecAccess().getGroup(), "rule__ServiceSpec__Group__0"); - builder.put(grammarAccess.getServiceSpecAccess().getGroup_4(), "rule__ServiceSpec__Group_4__0"); builder.put(grammarAccess.getServiceSpecAccess().getGroup_5(), "rule__ServiceSpec__Group_5__0"); - builder.put(grammarAccess.getTopicSpecAccess().getGroup(), "rule__TopicSpec__Group__0"); - builder.put(grammarAccess.getTopicSpecAccess().getGroup_4(), "rule__TopicSpec__Group_4__0"); + builder.put(grammarAccess.getServiceSpecAccess().getGroup_7(), "rule__ServiceSpec__Group_7__0"); builder.put(grammarAccess.getActionSpecAccess().getGroup(), "rule__ActionSpec__Group__0"); - builder.put(grammarAccess.getActionSpecAccess().getGroup_4(), "rule__ActionSpec__Group_4__0"); builder.put(grammarAccess.getActionSpecAccess().getGroup_5(), "rule__ActionSpec__Group_5__0"); - builder.put(grammarAccess.getActionSpecAccess().getGroup_6(), "rule__ActionSpec__Group_6__0"); + builder.put(grammarAccess.getActionSpecAccess().getGroup_7(), "rule__ActionSpec__Group_7__0"); + builder.put(grammarAccess.getActionSpecAccess().getGroup_9(), "rule__ActionSpec__Group_9__0"); builder.put(grammarAccess.getMessageDefinitionAccess().getGroup(), "rule__MessageDefinition__Group__0"); - builder.put(grammarAccess.getMessageDefinitionAccess().getGroup_2(), "rule__MessageDefinition__Group_2__0"); - builder.put(grammarAccess.getNodeAccess().getGroup(), "rule__Node__Group__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_4(), "rule__Node__Group_4__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_4_3(), "rule__Node__Group_4_3__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_5(), "rule__Node__Group_5__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_5_3(), "rule__Node__Group_5_3__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_6(), "rule__Node__Group_6__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_6_3(), "rule__Node__Group_6_3__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_7(), "rule__Node__Group_7__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_7_3(), "rule__Node__Group_7_3__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_8(), "rule__Node__Group_8__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_8_3(), "rule__Node__Group_8_3__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_9(), "rule__Node__Group_9__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_9_3(), "rule__Node__Group_9_3__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_10(), "rule__Node__Group_10__0"); - builder.put(grammarAccess.getNodeAccess().getGroup_10_3(), "rule__Node__Group_10_3__0"); - builder.put(grammarAccess.getServiceServerAccess().getGroup(), "rule__ServiceServer__Group__0"); - builder.put(grammarAccess.getServiceServerAccess().getGroup_6(), "rule__ServiceServer__Group_6__0"); builder.put(grammarAccess.getPublisherAccess().getGroup(), "rule__Publisher__Group__0"); builder.put(grammarAccess.getPublisherAccess().getGroup_6(), "rule__Publisher__Group_6__0"); builder.put(grammarAccess.getSubscriberAccess().getGroup(), "rule__Subscriber__Group__0"); builder.put(grammarAccess.getSubscriberAccess().getGroup_6(), "rule__Subscriber__Group_6__0"); + builder.put(grammarAccess.getServiceServerAccess().getGroup(), "rule__ServiceServer__Group__0"); + builder.put(grammarAccess.getServiceServerAccess().getGroup_6(), "rule__ServiceServer__Group_6__0"); builder.put(grammarAccess.getServiceClientAccess().getGroup(), "rule__ServiceClient__Group__0"); builder.put(grammarAccess.getServiceClientAccess().getGroup_6(), "rule__ServiceClient__Group_6__0"); builder.put(grammarAccess.getActionServerAccess().getGroup(), "rule__ActionServer__Group__0"); @@ -110,16 +95,16 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getActionClientAccess().getGroup_6(), "rule__ActionClient__Group_6__0"); builder.put(grammarAccess.getExternalDependencyAccess().getGroup(), "rule__ExternalDependency__Group__0"); builder.put(grammarAccess.getGlobalNamespaceAccess().getGroup(), "rule__GlobalNamespace__Group__0"); - builder.put(grammarAccess.getGlobalNamespaceAccess().getGroup_3(), "rule__GlobalNamespace__Group_3__0"); - builder.put(grammarAccess.getGlobalNamespaceAccess().getGroup_3_3(), "rule__GlobalNamespace__Group_3_3__0"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getGroup_2(), "rule__GlobalNamespace__Group_2__0"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2(), "rule__GlobalNamespace__Group_2_2__0"); builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getGroup(), "rule__RelativeNamespace_Impl__Group__0"); - builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_3(), "rule__RelativeNamespace_Impl__Group_3__0"); - builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_3_3(), "rule__RelativeNamespace_Impl__Group_3_3__0"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2(), "rule__RelativeNamespace_Impl__Group_2__0"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2(), "rule__RelativeNamespace_Impl__Group_2_2__0"); builder.put(grammarAccess.getPrivateNamespaceAccess().getGroup(), "rule__PrivateNamespace__Group__0"); - builder.put(grammarAccess.getPrivateNamespaceAccess().getGroup_3(), "rule__PrivateNamespace__Group_3__0"); - builder.put(grammarAccess.getPrivateNamespaceAccess().getGroup_3_3(), "rule__PrivateNamespace__Group_3_3__0"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getGroup_2(), "rule__PrivateNamespace__Group_2__0"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2(), "rule__PrivateNamespace__Group_2_2__0"); builder.put(grammarAccess.getParameterAccess().getGroup(), "rule__Parameter__Group__0"); - builder.put(grammarAccess.getParameterAccess().getGroup_4(), "rule__Parameter__Group_4__0"); + builder.put(grammarAccess.getParameterAccess().getGroup_6(), "rule__Parameter__Group_6__0"); builder.put(grammarAccess.getParameterListTypeAccess().getGroup(), "rule__ParameterListType__Group__0"); builder.put(grammarAccess.getParameterListTypeAccess().getGroup_4(), "rule__ParameterListType__Group_4__0"); builder.put(grammarAccess.getParameterStructTypeAccess().getGroup(), "rule__ParameterStructType__Group__0"); @@ -143,7 +128,7 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getParameterListAccess().getGroup(), "rule__ParameterList__Group__0"); builder.put(grammarAccess.getParameterListAccess().getGroup_3(), "rule__ParameterList__Group_3__0"); builder.put(grammarAccess.getParameterAnyAccess().getGroup(), "rule__ParameterAny__Group__0"); - builder.put(grammarAccess.getParameterAnyAccess().getGroup_3(), "rule__ParameterAny__Group_3__0"); + builder.put(grammarAccess.getParameterAnyAccess().getGroup_2(), "rule__ParameterAny__Group_2__0"); builder.put(grammarAccess.getParameterStructAccess().getGroup(), "rule__ParameterStruct__Group__0"); builder.put(grammarAccess.getParameterStructAccess().getGroup_1(), "rule__ParameterStruct__Group_1__0"); builder.put(grammarAccess.getParameterStructAccess().getGroup_1_2(), "rule__ParameterStruct__Group_1_2__0"); @@ -180,87 +165,71 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getByteArrayAccess().getGroup(), "rule__ByteArray__Group__0"); builder.put(grammarAccess.getHeaderAccess().getGroup(), "rule__Header__Group__0"); builder.put(grammarAccess.getArrayTopicSpecRefAccess().getGroup(), "rule__ArrayTopicSpecRef__Group__0"); - builder.put(grammarAccess.getPackageSetAccess().getPackageAssignment_3_0(), "rule__PackageSet__PackageAssignment_3_0"); - builder.put(grammarAccess.getPackageSetAccess().getPackageAssignment_3_1_1(), "rule__PackageSet__PackageAssignment_3_1_1"); - builder.put(grammarAccess.getPackage_ImplAccess().getNameAssignment_2(), "rule__Package_Impl__NameAssignment_2"); + builder.put(grammarAccess.getPackageSetAccess().getPackageAssignment_1(), "rule__PackageSet__PackageAssignment_1"); + builder.put(grammarAccess.getPackage_ImplAccess().getNameAssignment_1(), "rule__Package_Impl__NameAssignment_1"); builder.put(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1(), "rule__Package_Impl__FromGitRepoAssignment_4_1"); builder.put(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2(), "rule__Package_Impl__SpecAssignment_5_2"); - builder.put(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_3_1(), "rule__Package_Impl__SpecAssignment_5_3_1"); - builder.put(grammarAccess.getPackage_ImplAccess().getArtifactAssignment_6_0(), "rule__Package_Impl__ArtifactAssignment_6_0"); - builder.put(grammarAccess.getPackage_ImplAccess().getArtifactAssignment_6_1_1(), "rule__Package_Impl__ArtifactAssignment_6_1_1"); - builder.put(grammarAccess.getArtifactAccess().getNameAssignment_2(), "rule__Artifact__NameAssignment_2"); - builder.put(grammarAccess.getArtifactAccess().getNodeAssignment_4(), "rule__Artifact__NodeAssignment_4"); - builder.put(grammarAccess.getCatkinPackageAccess().getNameAssignment_2(), "rule__CatkinPackage__NameAssignment_2"); + builder.put(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2(), "rule__Package_Impl__DependencyAssignment_6_2"); + builder.put(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1(), "rule__Package_Impl__DependencyAssignment_6_3_1"); + 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().getDependencyAssignment_5_2(), "rule__CatkinPackage__DependencyAssignment_5_2"); - builder.put(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_5_3_1(), "rule__CatkinPackage__DependencyAssignment_5_3_1"); - builder.put(grammarAccess.getCatkinPackageAccess().getSpecAssignment_6_2(), "rule__CatkinPackage__SpecAssignment_6_2"); - builder.put(grammarAccess.getCatkinPackageAccess().getSpecAssignment_6_3_1(), "rule__CatkinPackage__SpecAssignment_6_3_1"); - builder.put(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_7_0(), "rule__CatkinPackage__ArtifactAssignment_7_0"); - builder.put(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_7_1_1(), "rule__CatkinPackage__ArtifactAssignment_7_1_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.getAmentPackageAccess().getNameAssignment_2(), "rule__AmentPackage__NameAssignment_2"); - builder.put(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_4_1(), "rule__AmentPackage__FromGitRepoAssignment_4_1"); - builder.put(grammarAccess.getAmentPackageAccess().getDependencyAssignment_5_2(), "rule__AmentPackage__DependencyAssignment_5_2"); - builder.put(grammarAccess.getAmentPackageAccess().getDependencyAssignment_5_3_1(), "rule__AmentPackage__DependencyAssignment_5_3_1"); - builder.put(grammarAccess.getAmentPackageAccess().getSpecAssignment_6_2(), "rule__AmentPackage__SpecAssignment_6_2"); - builder.put(grammarAccess.getAmentPackageAccess().getSpecAssignment_6_3_1(), "rule__AmentPackage__SpecAssignment_6_3_1"); - builder.put(grammarAccess.getAmentPackageAccess().getArtifactAssignment_7_0(), "rule__AmentPackage__ArtifactAssignment_7_0"); - builder.put(grammarAccess.getAmentPackageAccess().getArtifactAssignment_7_1_1(), "rule__AmentPackage__ArtifactAssignment_7_1_1"); - builder.put(grammarAccess.getServiceSpecAccess().getNameAssignment_2(), "rule__ServiceSpec__NameAssignment_2"); - builder.put(grammarAccess.getServiceSpecAccess().getRequestAssignment_4_1(), "rule__ServiceSpec__RequestAssignment_4_1"); - builder.put(grammarAccess.getServiceSpecAccess().getResponseAssignment_5_1(), "rule__ServiceSpec__ResponseAssignment_5_1"); + builder.put(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_5_1(), "rule__AmentPackage__FromGitRepoAssignment_5_1"); + builder.put(grammarAccess.getAmentPackageAccess().getArtifactAssignment_6_2(), "rule__AmentPackage__ArtifactAssignment_6_2"); + builder.put(grammarAccess.getAmentPackageAccess().getDependencyAssignment_7_2(), "rule__AmentPackage__DependencyAssignment_7_2"); + builder.put(grammarAccess.getAmentPackageAccess().getDependencyAssignment_7_3_1(), "rule__AmentPackage__DependencyAssignment_7_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_0_2(), "rule__Node__PublisherAssignment_3_0_2"); + builder.put(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2(), "rule__Node__SubscriberAssignment_3_1_2"); + builder.put(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2(), "rule__Node__ServiceserverAssignment_3_2_2"); + builder.put(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2(), "rule__Node__ServiceclientAssignment_3_3_2"); + builder.put(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2(), "rule__Node__ActionserverAssignment_3_4_2"); + builder.put(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2(), "rule__Node__ActionclientAssignment_3_5_2"); + builder.put(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2(), "rule__Node__ParameterAssignment_3_6_2"); builder.put(grammarAccess.getTopicSpecAccess().getNameAssignment_2(), "rule__TopicSpec__NameAssignment_2"); - builder.put(grammarAccess.getTopicSpecAccess().getMessageAssignment_4_1(), "rule__TopicSpec__MessageAssignment_4_1"); + builder.put(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1(), "rule__TopicSpec__MessageAssignment_5_1"); + builder.put(grammarAccess.getServiceSpecAccess().getNameAssignment_2(), "rule__ServiceSpec__NameAssignment_2"); + builder.put(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1(), "rule__ServiceSpec__RequestAssignment_5_1"); + builder.put(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1(), "rule__ServiceSpec__ResponseAssignment_7_1"); builder.put(grammarAccess.getActionSpecAccess().getNameAssignment_2(), "rule__ActionSpec__NameAssignment_2"); - builder.put(grammarAccess.getActionSpecAccess().getGoalAssignment_4_1(), "rule__ActionSpec__GoalAssignment_4_1"); - builder.put(grammarAccess.getActionSpecAccess().getResultAssignment_5_1(), "rule__ActionSpec__ResultAssignment_5_1"); - builder.put(grammarAccess.getActionSpecAccess().getFeedbackAssignment_6_1(), "rule__ActionSpec__FeedbackAssignment_6_1"); - builder.put(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_2_0(), "rule__MessageDefinition__MessagePartAssignment_2_0"); - builder.put(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_2_1(), "rule__MessageDefinition__MessagePartAssignment_2_1"); - builder.put(grammarAccess.getNodeAccess().getNameAssignment_3(), "rule__Node__NameAssignment_3"); - builder.put(grammarAccess.getNodeAccess().getServiceserverAssignment_4_2(), "rule__Node__ServiceserverAssignment_4_2"); - builder.put(grammarAccess.getNodeAccess().getServiceserverAssignment_4_3_1(), "rule__Node__ServiceserverAssignment_4_3_1"); - builder.put(grammarAccess.getNodeAccess().getPublisherAssignment_5_2(), "rule__Node__PublisherAssignment_5_2"); - builder.put(grammarAccess.getNodeAccess().getPublisherAssignment_5_3_1(), "rule__Node__PublisherAssignment_5_3_1"); - builder.put(grammarAccess.getNodeAccess().getSubscriberAssignment_6_2(), "rule__Node__SubscriberAssignment_6_2"); - builder.put(grammarAccess.getNodeAccess().getSubscriberAssignment_6_3_1(), "rule__Node__SubscriberAssignment_6_3_1"); - builder.put(grammarAccess.getNodeAccess().getServiceclientAssignment_7_2(), "rule__Node__ServiceclientAssignment_7_2"); - builder.put(grammarAccess.getNodeAccess().getServiceclientAssignment_7_3_1(), "rule__Node__ServiceclientAssignment_7_3_1"); - builder.put(grammarAccess.getNodeAccess().getActionserverAssignment_8_2(), "rule__Node__ActionserverAssignment_8_2"); - builder.put(grammarAccess.getNodeAccess().getActionserverAssignment_8_3_1(), "rule__Node__ActionserverAssignment_8_3_1"); - builder.put(grammarAccess.getNodeAccess().getActionclientAssignment_9_2(), "rule__Node__ActionclientAssignment_9_2"); - builder.put(grammarAccess.getNodeAccess().getActionclientAssignment_9_3_1(), "rule__Node__ActionclientAssignment_9_3_1"); - builder.put(grammarAccess.getNodeAccess().getParameterAssignment_10_2(), "rule__Node__ParameterAssignment_10_2"); - builder.put(grammarAccess.getNodeAccess().getParameterAssignment_10_3_1(), "rule__Node__ParameterAssignment_10_3_1"); - builder.put(grammarAccess.getServiceServerAccess().getNameAssignment_3(), "rule__ServiceServer__NameAssignment_3"); - builder.put(grammarAccess.getServiceServerAccess().getServiceAssignment_5(), "rule__ServiceServer__ServiceAssignment_5"); - builder.put(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1(), "rule__ServiceServer__NamespaceAssignment_6_1"); - builder.put(grammarAccess.getPublisherAccess().getNameAssignment_3(), "rule__Publisher__NameAssignment_3"); + builder.put(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1(), "rule__ActionSpec__GoalAssignment_5_1"); + builder.put(grammarAccess.getActionSpecAccess().getResultAssignment_7_1(), "rule__ActionSpec__ResultAssignment_7_1"); + builder.put(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1(), "rule__ActionSpec__FeedbackAssignment_9_1"); + builder.put(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1(), "rule__MessageDefinition__MessagePartAssignment_1"); + builder.put(grammarAccess.getPublisherAccess().getNameAssignment_1(), "rule__Publisher__NameAssignment_1"); builder.put(grammarAccess.getPublisherAccess().getMessageAssignment_5(), "rule__Publisher__MessageAssignment_5"); builder.put(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1(), "rule__Publisher__NamespaceAssignment_6_1"); - builder.put(grammarAccess.getSubscriberAccess().getNameAssignment_3(), "rule__Subscriber__NameAssignment_3"); + builder.put(grammarAccess.getSubscriberAccess().getNameAssignment_1(), "rule__Subscriber__NameAssignment_1"); builder.put(grammarAccess.getSubscriberAccess().getMessageAssignment_5(), "rule__Subscriber__MessageAssignment_5"); builder.put(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1(), "rule__Subscriber__NamespaceAssignment_6_1"); - builder.put(grammarAccess.getServiceClientAccess().getNameAssignment_3(), "rule__ServiceClient__NameAssignment_3"); + builder.put(grammarAccess.getServiceServerAccess().getNameAssignment_1(), "rule__ServiceServer__NameAssignment_1"); + builder.put(grammarAccess.getServiceServerAccess().getServiceAssignment_5(), "rule__ServiceServer__ServiceAssignment_5"); + builder.put(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1(), "rule__ServiceServer__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getServiceClientAccess().getNameAssignment_1(), "rule__ServiceClient__NameAssignment_1"); builder.put(grammarAccess.getServiceClientAccess().getServiceAssignment_5(), "rule__ServiceClient__ServiceAssignment_5"); builder.put(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1(), "rule__ServiceClient__NamespaceAssignment_6_1"); - builder.put(grammarAccess.getActionServerAccess().getNameAssignment_3(), "rule__ActionServer__NameAssignment_3"); + builder.put(grammarAccess.getActionServerAccess().getNameAssignment_1(), "rule__ActionServer__NameAssignment_1"); builder.put(grammarAccess.getActionServerAccess().getActionAssignment_5(), "rule__ActionServer__ActionAssignment_5"); builder.put(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1(), "rule__ActionServer__NamespaceAssignment_6_1"); - builder.put(grammarAccess.getActionClientAccess().getNameAssignment_3(), "rule__ActionClient__NameAssignment_3"); + builder.put(grammarAccess.getActionClientAccess().getNameAssignment_1(), "rule__ActionClient__NameAssignment_1"); builder.put(grammarAccess.getActionClientAccess().getActionAssignment_5(), "rule__ActionClient__ActionAssignment_5"); builder.put(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1(), "rule__ActionClient__NamespaceAssignment_6_1"); builder.put(grammarAccess.getPackageDependencyAccess().getPackageAssignment(), "rule__PackageDependency__PackageAssignment"); builder.put(grammarAccess.getExternalDependencyAccess().getNameAssignment_2(), "rule__ExternalDependency__NameAssignment_2"); - builder.put(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_3_2(), "rule__GlobalNamespace__PartsAssignment_3_2"); - builder.put(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_3_3_1(), "rule__GlobalNamespace__PartsAssignment_3_3_1"); - builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_3_2(), "rule__RelativeNamespace_Impl__PartsAssignment_3_2"); - builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_3_3_1(), "rule__RelativeNamespace_Impl__PartsAssignment_3_3_1"); - builder.put(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_3_2(), "rule__PrivateNamespace__PartsAssignment_3_2"); - builder.put(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_3_3_1(), "rule__PrivateNamespace__PartsAssignment_3_3_1"); - builder.put(grammarAccess.getParameterAccess().getNameAssignment_3(), "rule__Parameter__NameAssignment_3"); - builder.put(grammarAccess.getParameterAccess().getNamespaceAssignment_4_1(), "rule__Parameter__NamespaceAssignment_4_1"); - builder.put(grammarAccess.getParameterAccess().getTypeAssignment_6(), "rule__Parameter__TypeAssignment_6"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1(), "rule__GlobalNamespace__PartsAssignment_2_1"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1(), "rule__GlobalNamespace__PartsAssignment_2_2_1"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1(), "rule__RelativeNamespace_Impl__PartsAssignment_2_1"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1(), "rule__RelativeNamespace_Impl__PartsAssignment_2_2_1"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1(), "rule__PrivateNamespace__PartsAssignment_2_1"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1(), "rule__PrivateNamespace__PartsAssignment_2_2_1"); + builder.put(grammarAccess.getParameterAccess().getNameAssignment_1(), "rule__Parameter__NameAssignment_1"); + builder.put(grammarAccess.getParameterAccess().getTypeAssignment_5(), "rule__Parameter__TypeAssignment_5"); + builder.put(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1(), "rule__Parameter__NamespaceAssignment_6_1"); builder.put(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3(), "rule__ParameterListType__SequenceAssignment_3"); builder.put(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1(), "rule__ParameterListType__SequenceAssignment_4_1"); builder.put(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3(), "rule__ParameterStructType__ParameterstructypetmemberAssignment_3"); @@ -276,7 +245,7 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1(), "rule__ParameterArrayType__DefaultAssignment_4_1"); builder.put(grammarAccess.getParameterListAccess().getValueAssignment_2(), "rule__ParameterList__ValueAssignment_2"); builder.put(grammarAccess.getParameterListAccess().getValueAssignment_3_1(), "rule__ParameterList__ValueAssignment_3_1"); - builder.put(grammarAccess.getParameterAnyAccess().getValueAssignment_3_1(), "rule__ParameterAny__ValueAssignment_3_1"); + builder.put(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1(), "rule__ParameterAny__ValueAssignment_2_1"); builder.put(grammarAccess.getParameterStringAccess().getValueAssignment(), "rule__ParameterString__ValueAssignment"); builder.put(grammarAccess.getParameterBase64Access().getValueAssignment(), "rule__ParameterBase64__ValueAssignment"); builder.put(grammarAccess.getParameterIntegerAccess().getValueAssignment(), "rule__ParameterInteger__ValueAssignment"); @@ -309,6 +278,11 @@ protected InternalRosParser createParser() { return result; } + @Override + protected TokenSource createLexer(CharStream stream) { + return new RosTokenSource(super.createLexer(stream)); + } + @Override protected String getRuleName(AbstractElement element) { return nameMappings.getRuleName(element); diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRos.tokens b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRos.tokens deleted file mode 100644 index bae92f67f..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRos.tokens +++ /dev/null @@ -1,199 +0,0 @@ -','=43 -'ActionClient'=70 -'ActionClients'=62 -'ActionServer'=69 -'ActionServers'=61 -'ActionSpec'=55 -'AmentPackage'=50 -'Array'=84 -'Artifact'=47 -'Base64'=83 -'Boolean'=82 -'CatkinPackage'=48 -'Dependencies'=49 -'Double'=81 -'ExternalDependency'=71 -'FromGitRepo'=45 -'GlobalNamespace'=72 -'GraphName'=25 -'Header'=27 -'Integer'=79 -'List'=77 -'Node'=56 -'Package'=44 -'PackageSet'=40 -'Parameter'=76 -'ParameterAny'=85 -'ParameterStructMember'=86 -'Parameters'=63 -'PrivateNamespace'=75 -'Publisher'=66 -'Publishers'=58 -'RelativeNamespace'=74 -'ServiceClient'=68 -'ServiceClients'=60 -'ServiceServer'=64 -'ServiceServers'=57 -'ServiceSpec'=51 -'Specs'=46 -'String'=28 -'Struct'=78 -'Subscriber'=67 -'Subscribers'=59 -'TopicSpec'=54 -'[]'=113 -'action'=37 -'bool'=87 -'bool[]'=100 -'byte'=99 -'byte[]'=112 -'default'=80 -'duration'=38 -'feedback'=32 -'float32'=96 -'float32[]'=109 -'float64'=97 -'float64[]'=110 -'goal'=29 -'int16'=90 -'int16[]'=103 -'int32'=92 -'int32[]'=105 -'int64'=94 -'int64[]'=107 -'int8'=88 -'int8[]'=101 -'message'=30 -'name'=33 -'namespace'=65 -'node'=26 -'parts'=73 -'request'=52 -'response'=53 -'result'=31 -'service'=35 -'string'=98 -'string[]'=111 -'time'=39 -'type'=36 -'uint16'=91 -'uint16[]'=104 -'uint32'=93 -'uint32[]'=106 -'uint64'=95 -'uint64[]'=108 -'uint8'=89 -'uint8[]'=102 -'value'=34 -'{'=41 -'}'=42 -RULE_ANY_OTHER=24 -RULE_BINARY=4 -RULE_BOOLEAN=5 -RULE_DATE_TIME=8 -RULE_DAY=15 -RULE_DECINT=7 -RULE_DIGIT=14 -RULE_DOUBLE=6 -RULE_HOUR=18 -RULE_ID=10 -RULE_INT=20 -RULE_MESSAGE_ASIGMENT=12 -RULE_MIN_SEC=19 -RULE_ML_COMMENT=21 -RULE_MONTH=16 -RULE_ROS_CONVENTION_A=11 -RULE_ROS_CONVENTION_PARAM=13 -RULE_SL_COMMENT=22 -RULE_STRING=9 -RULE_WS=23 -RULE_YEAR=17 -T__100=100 -T__101=101 -T__102=102 -T__103=103 -T__104=104 -T__105=105 -T__106=106 -T__107=107 -T__108=108 -T__109=109 -T__110=110 -T__111=111 -T__112=112 -T__113=113 -T__25=25 -T__26=26 -T__27=27 -T__28=28 -T__29=29 -T__30=30 -T__31=31 -T__32=32 -T__33=33 -T__34=34 -T__35=35 -T__36=36 -T__37=37 -T__38=38 -T__39=39 -T__40=40 -T__41=41 -T__42=42 -T__43=43 -T__44=44 -T__45=45 -T__46=46 -T__47=47 -T__48=48 -T__49=49 -T__50=50 -T__51=51 -T__52=52 -T__53=53 -T__54=54 -T__55=55 -T__56=56 -T__57=57 -T__58=58 -T__59=59 -T__60=60 -T__61=61 -T__62=62 -T__63=63 -T__64=64 -T__65=65 -T__66=66 -T__67=67 -T__68=68 -T__69=69 -T__70=70 -T__71=71 -T__72=72 -T__73=73 -T__74=74 -T__75=75 -T__76=76 -T__77=77 -T__78=78 -T__79=79 -T__80=80 -T__81=81 -T__82=82 -T__83=83 -T__84=84 -T__85=85 -T__86=86 -T__87=87 -T__88=88 -T__89=89 -T__90=90 -T__91=91 -T__92=92 -T__93=93 -T__94=94 -T__95=95 -T__96=96 -T__97=97 -T__98=98 -T__99=99 diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosLexer.java b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosLexer.java deleted file mode 100644 index 93f9dfa1d..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosLexer.java +++ /dev/null @@ -1,5094 +0,0 @@ -package de.fraunhofer.ipa.ros.ide.contentassist.antlr.internal; - -// Hack: Use our own Lexer superclass by means of import. -// Currently there is no other way to specify the superclass for the lexer. -import org.eclipse.xtext.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 InternalRosLexer extends Lexer { - public static final int T__50=50; - public static final int RULE_DATE_TIME=8; - public static final int T__59=59; - public static final int T__55=55; - public static final int T__56=56; - public static final int T__57=57; - public static final int T__58=58; - public static final int T__51=51; - public static final int T__52=52; - public static final int T__53=53; - public static final int T__54=54; - public static final int T__60=60; - public static final int T__61=61; - public static final int RULE_ID=10; - public static final int RULE_DIGIT=14; - public static final int RULE_INT=20; - public static final int T__66=66; - public static final int RULE_ML_COMMENT=21; - public static final int T__67=67; - public static final int T__68=68; - public static final int T__69=69; - public static final int T__62=62; - public static final int T__63=63; - public static final int T__64=64; - public static final int T__65=65; - public static final int RULE_MESSAGE_ASIGMENT=12; - public static final int T__37=37; - public static final int T__38=38; - public static final int T__39=39; - public static final int T__33=33; - public static final int T__34=34; - public static final int T__35=35; - public static final int T__36=36; - public static final int RULE_DECINT=7; - public static final int T__30=30; - public static final int T__31=31; - public static final int T__32=32; - public static final int RULE_HOUR=18; - public static final int T__48=48; - public static final int T__49=49; - public static final int T__44=44; - public static final int T__45=45; - public static final int T__46=46; - public static final int RULE_BINARY=4; - public static final int T__47=47; - public static final int T__40=40; - public static final int T__41=41; - public static final int T__42=42; - public static final int T__43=43; - public static final int T__91=91; - public static final int T__100=100; - public static final int T__92=92; - public static final int T__93=93; - public static final int T__102=102; - public static final int T__94=94; - public static final int T__101=101; - public static final int RULE_DAY=15; - public static final int T__90=90; - public static final int RULE_BOOLEAN=5; - public static final int RULE_YEAR=17; - public static final int RULE_MIN_SEC=19; - public static final int T__99=99; - public static final int T__95=95; - public static final int T__96=96; - public static final int T__97=97; - public static final int T__98=98; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; - public static final int T__29=29; - public static final int T__25=25; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=9; - public static final int RULE_SL_COMMENT=22; - public static final int RULE_DOUBLE=6; - public static final int RULE_ROS_CONVENTION_A=11; - public static final int T__77=77; - public static final int T__78=78; - public static final int RULE_ROS_CONVENTION_PARAM=13; - public static final int T__79=79; - public static final int T__73=73; - public static final int EOF=-1; - public static final int T__74=74; - public static final int T__75=75; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__111=111; - public static final int T__81=81; - public static final int T__110=110; - public static final int T__82=82; - public static final int T__113=113; - public static final int T__83=83; - public static final int T__112=112; - public static final int RULE_WS=23; - public static final int RULE_ANY_OTHER=24; - public static final int T__88=88; - public static final int T__108=108; - public static final int T__89=89; - public static final int T__107=107; - public static final int RULE_MONTH=16; - public static final int T__109=109; - public static final int T__84=84; - public static final int T__104=104; - public static final int T__85=85; - public static final int T__103=103; - public static final int T__86=86; - public static final int T__106=106; - public static final int T__87=87; - public static final int T__105=105; - - // delegates - // delegators - - public InternalRosLexer() {;} - public InternalRosLexer(CharStream input) { - this(input, new RecognizerSharedState()); - } - public InternalRosLexer(CharStream input, RecognizerSharedState state) { - super(input,state); - - } - public String getGrammarFileName() { return "InternalRos.g"; } - - // $ANTLR start "T__25" - public final void mT__25() throws RecognitionException { - try { - int _type = T__25; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:11:7: ( 'GraphName' ) - // InternalRos.g:11:9: 'GraphName' - { - match("GraphName"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__25" - - // $ANTLR start "T__26" - public final void mT__26() throws RecognitionException { - try { - int _type = T__26; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:12:7: ( 'node' ) - // InternalRos.g:12:9: 'node' - { - match("node"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__26" - - // $ANTLR start "T__27" - public final void mT__27() throws RecognitionException { - try { - int _type = T__27; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:13:7: ( 'Header' ) - // InternalRos.g:13:9: 'Header' - { - match("Header"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__27" - - // $ANTLR start "T__28" - public final void mT__28() throws RecognitionException { - try { - int _type = T__28; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:14:7: ( 'String' ) - // InternalRos.g:14:9: 'String' - { - match("String"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__28" - - // $ANTLR start "T__29" - public final void mT__29() throws RecognitionException { - try { - int _type = T__29; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:15:7: ( 'goal' ) - // InternalRos.g:15:9: 'goal' - { - match("goal"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__29" - - // $ANTLR start "T__30" - public final void mT__30() throws RecognitionException { - try { - int _type = T__30; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:16:7: ( 'message' ) - // InternalRos.g:16:9: 'message' - { - match("message"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__30" - - // $ANTLR start "T__31" - public final void mT__31() throws RecognitionException { - try { - int _type = T__31; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:17:7: ( 'result' ) - // InternalRos.g:17:9: 'result' - { - match("result"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__31" - - // $ANTLR start "T__32" - public final void mT__32() throws RecognitionException { - try { - int _type = T__32; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:18:7: ( 'feedback' ) - // InternalRos.g:18:9: 'feedback' - { - match("feedback"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__32" - - // $ANTLR start "T__33" - public final void mT__33() throws RecognitionException { - try { - int _type = T__33; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:19:7: ( 'name' ) - // InternalRos.g:19:9: 'name' - { - match("name"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__33" - - // $ANTLR start "T__34" - public final void mT__34() throws RecognitionException { - try { - int _type = T__34; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:20:7: ( 'value' ) - // InternalRos.g:20:9: 'value' - { - match("value"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__34" - - // $ANTLR start "T__35" - public final void mT__35() throws RecognitionException { - try { - int _type = T__35; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:21:7: ( 'service' ) - // InternalRos.g:21:9: 'service' - { - match("service"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__35" - - // $ANTLR start "T__36" - public final void mT__36() throws RecognitionException { - try { - int _type = T__36; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:22:7: ( 'type' ) - // InternalRos.g:22:9: 'type' - { - match("type"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__36" - - // $ANTLR start "T__37" - public final void mT__37() throws RecognitionException { - try { - int _type = T__37; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:23:7: ( 'action' ) - // InternalRos.g:23:9: 'action' - { - match("action"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__37" - - // $ANTLR start "T__38" - public final void mT__38() throws RecognitionException { - try { - int _type = T__38; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:24:7: ( 'duration' ) - // InternalRos.g:24:9: 'duration' - { - match("duration"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__38" - - // $ANTLR start "T__39" - public final void mT__39() throws RecognitionException { - try { - int _type = T__39; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:25:7: ( 'time' ) - // InternalRos.g:25:9: 'time' - { - match("time"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__39" - - // $ANTLR start "T__40" - public final void mT__40() throws RecognitionException { - try { - int _type = T__40; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:26:7: ( 'PackageSet' ) - // InternalRos.g:26:9: 'PackageSet' - { - match("PackageSet"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__40" - - // $ANTLR start "T__41" - public final void mT__41() throws RecognitionException { - try { - int _type = T__41; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:27:7: ( '{' ) - // InternalRos.g:27:9: '{' - { - match('{'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__41" - - // $ANTLR start "T__42" - public final void mT__42() throws RecognitionException { - try { - int _type = T__42; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:28:7: ( '}' ) - // InternalRos.g:28:9: '}' - { - match('}'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__42" - - // $ANTLR start "T__43" - public final void mT__43() throws RecognitionException { - try { - int _type = T__43; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:29:7: ( ',' ) - // InternalRos.g:29:9: ',' - { - match(','); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__43" - - // $ANTLR start "T__44" - public final void mT__44() throws RecognitionException { - try { - int _type = T__44; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:30:7: ( 'Package' ) - // InternalRos.g:30:9: 'Package' - { - match("Package"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__44" - - // $ANTLR start "T__45" - public final void mT__45() throws RecognitionException { - try { - int _type = T__45; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:31:7: ( 'FromGitRepo' ) - // InternalRos.g:31:9: 'FromGitRepo' - { - match("FromGitRepo"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__45" - - // $ANTLR start "T__46" - public final void mT__46() throws RecognitionException { - try { - int _type = T__46; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:32:7: ( 'Specs' ) - // InternalRos.g:32:9: 'Specs' - { - match("Specs"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__46" - - // $ANTLR start "T__47" - public final void mT__47() throws RecognitionException { - try { - int _type = T__47; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:33:7: ( 'Artifact' ) - // InternalRos.g:33:9: 'Artifact' - { - match("Artifact"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__47" - - // $ANTLR start "T__48" - public final void mT__48() throws RecognitionException { - try { - int _type = T__48; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:34:7: ( 'CatkinPackage' ) - // InternalRos.g:34:9: 'CatkinPackage' - { - match("CatkinPackage"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__48" - - // $ANTLR start "T__49" - public final void mT__49() throws RecognitionException { - try { - int _type = T__49; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:35:7: ( 'Dependencies' ) - // InternalRos.g:35:9: 'Dependencies' - { - match("Dependencies"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__49" - - // $ANTLR start "T__50" - public final void mT__50() throws RecognitionException { - try { - int _type = T__50; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:36:7: ( 'AmentPackage' ) - // InternalRos.g:36:9: 'AmentPackage' - { - match("AmentPackage"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__50" - - // $ANTLR start "T__51" - public final void mT__51() throws RecognitionException { - try { - int _type = T__51; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:37:7: ( 'ServiceSpec' ) - // InternalRos.g:37:9: 'ServiceSpec' - { - match("ServiceSpec"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__51" - - // $ANTLR start "T__52" - public final void mT__52() throws RecognitionException { - try { - int _type = T__52; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:38:7: ( 'request' ) - // InternalRos.g:38:9: 'request' - { - match("request"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__52" - - // $ANTLR start "T__53" - public final void mT__53() throws RecognitionException { - try { - int _type = T__53; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:39:7: ( 'response' ) - // InternalRos.g:39:9: 'response' - { - match("response"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__53" - - // $ANTLR start "T__54" - public final void mT__54() throws RecognitionException { - try { - int _type = T__54; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:40:7: ( 'TopicSpec' ) - // InternalRos.g:40:9: 'TopicSpec' - { - match("TopicSpec"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__54" - - // $ANTLR start "T__55" - public final void mT__55() throws RecognitionException { - try { - int _type = T__55; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:41:7: ( 'ActionSpec' ) - // InternalRos.g:41:9: 'ActionSpec' - { - match("ActionSpec"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__55" - - // $ANTLR start "T__56" - public final void mT__56() throws RecognitionException { - try { - int _type = T__56; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:42:7: ( 'Node' ) - // InternalRos.g:42:9: 'Node' - { - match("Node"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__56" - - // $ANTLR start "T__57" - public final void mT__57() throws RecognitionException { - try { - int _type = T__57; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:43:7: ( 'ServiceServers' ) - // InternalRos.g:43:9: 'ServiceServers' - { - match("ServiceServers"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__57" - - // $ANTLR start "T__58" - public final void mT__58() throws RecognitionException { - try { - int _type = T__58; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:44:7: ( 'Publishers' ) - // InternalRos.g:44:9: 'Publishers' - { - match("Publishers"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__58" - - // $ANTLR start "T__59" - public final void mT__59() throws RecognitionException { - try { - int _type = T__59; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:45:7: ( 'Subscribers' ) - // InternalRos.g:45:9: 'Subscribers' - { - match("Subscribers"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__59" - - // $ANTLR start "T__60" - public final void mT__60() throws RecognitionException { - try { - int _type = T__60; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:46:7: ( 'ServiceClients' ) - // InternalRos.g:46:9: 'ServiceClients' - { - match("ServiceClients"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__60" - - // $ANTLR start "T__61" - public final void mT__61() throws RecognitionException { - try { - int _type = T__61; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:47:7: ( 'ActionServers' ) - // InternalRos.g:47:9: 'ActionServers' - { - match("ActionServers"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__61" - - // $ANTLR start "T__62" - public final void mT__62() throws RecognitionException { - try { - int _type = T__62; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:48:7: ( 'ActionClients' ) - // InternalRos.g:48:9: 'ActionClients' - { - match("ActionClients"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__62" - - // $ANTLR start "T__63" - public final void mT__63() throws RecognitionException { - try { - int _type = T__63; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:49:7: ( 'Parameters' ) - // InternalRos.g:49:9: 'Parameters' - { - match("Parameters"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__63" - - // $ANTLR start "T__64" - public final void mT__64() throws RecognitionException { - try { - int _type = T__64; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:50:7: ( 'ServiceServer' ) - // InternalRos.g:50:9: 'ServiceServer' - { - match("ServiceServer"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__64" - - // $ANTLR start "T__65" - public final void mT__65() throws RecognitionException { - try { - int _type = T__65; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:51:7: ( 'namespace' ) - // InternalRos.g:51:9: 'namespace' - { - match("namespace"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__65" - - // $ANTLR start "T__66" - public final void mT__66() throws RecognitionException { - try { - int _type = T__66; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:52:7: ( 'Publisher' ) - // InternalRos.g:52:9: 'Publisher' - { - match("Publisher"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__66" - - // $ANTLR start "T__67" - public final void mT__67() throws RecognitionException { - try { - int _type = T__67; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:53:7: ( 'Subscriber' ) - // InternalRos.g:53:9: 'Subscriber' - { - match("Subscriber"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__67" - - // $ANTLR start "T__68" - public final void mT__68() throws RecognitionException { - try { - int _type = T__68; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:54:7: ( 'ServiceClient' ) - // InternalRos.g:54:9: 'ServiceClient' - { - match("ServiceClient"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__68" - - // $ANTLR start "T__69" - public final void mT__69() throws RecognitionException { - try { - int _type = T__69; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:55:7: ( 'ActionServer' ) - // InternalRos.g:55:9: 'ActionServer' - { - match("ActionServer"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__69" - - // $ANTLR start "T__70" - public final void mT__70() throws RecognitionException { - try { - int _type = T__70; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:56:7: ( 'ActionClient' ) - // InternalRos.g:56:9: 'ActionClient' - { - match("ActionClient"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__70" - - // $ANTLR start "T__71" - public final void mT__71() throws RecognitionException { - try { - int _type = T__71; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:57:7: ( 'ExternalDependency' ) - // InternalRos.g:57:9: 'ExternalDependency' - { - match("ExternalDependency"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__71" - - // $ANTLR start "T__72" - public final void mT__72() throws RecognitionException { - try { - int _type = T__72; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:58:7: ( 'GlobalNamespace' ) - // InternalRos.g:58:9: 'GlobalNamespace' - { - match("GlobalNamespace"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__72" - - // $ANTLR start "T__73" - public final void mT__73() throws RecognitionException { - try { - int _type = T__73; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:59:7: ( 'parts' ) - // InternalRos.g:59:9: 'parts' - { - match("parts"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__73" - - // $ANTLR start "T__74" - public final void mT__74() throws RecognitionException { - try { - int _type = T__74; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:60:7: ( 'RelativeNamespace' ) - // InternalRos.g:60:9: 'RelativeNamespace' - { - match("RelativeNamespace"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__74" - - // $ANTLR start "T__75" - public final void mT__75() throws RecognitionException { - try { - int _type = T__75; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:61:7: ( 'PrivateNamespace' ) - // InternalRos.g:61:9: 'PrivateNamespace' - { - match("PrivateNamespace"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__75" - - // $ANTLR start "T__76" - public final void mT__76() throws RecognitionException { - try { - int _type = T__76; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:62:7: ( 'Parameter' ) - // InternalRos.g:62:9: 'Parameter' - { - match("Parameter"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__76" - - // $ANTLR start "T__77" - public final void mT__77() throws RecognitionException { - try { - int _type = T__77; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:63:7: ( 'List' ) - // InternalRos.g:63:9: 'List' - { - match("List"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__77" - - // $ANTLR start "T__78" - public final void mT__78() throws RecognitionException { - try { - int _type = T__78; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:64:7: ( 'Struct' ) - // InternalRos.g:64:9: 'Struct' - { - match("Struct"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__78" - - // $ANTLR start "T__79" - public final void mT__79() throws RecognitionException { - try { - int _type = T__79; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:65:7: ( 'Integer' ) - // InternalRos.g:65:9: 'Integer' - { - match("Integer"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__79" - - // $ANTLR start "T__80" - public final void mT__80() throws RecognitionException { - try { - int _type = T__80; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:66:7: ( 'default' ) - // InternalRos.g:66:9: 'default' - { - match("default"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__80" - - // $ANTLR start "T__81" - public final void mT__81() throws RecognitionException { - try { - int _type = T__81; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:67:7: ( 'Double' ) - // InternalRos.g:67:9: 'Double' - { - match("Double"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__81" - - // $ANTLR start "T__82" - public final void mT__82() throws RecognitionException { - try { - int _type = T__82; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:68:7: ( 'Boolean' ) - // InternalRos.g:68:9: 'Boolean' - { - match("Boolean"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__82" - - // $ANTLR start "T__83" - public final void mT__83() throws RecognitionException { - try { - int _type = T__83; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:69:7: ( 'Base64' ) - // InternalRos.g:69:9: 'Base64' - { - match("Base64"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__83" - - // $ANTLR start "T__84" - public final void mT__84() throws RecognitionException { - try { - int _type = T__84; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:70:7: ( 'Array' ) - // InternalRos.g:70:9: 'Array' - { - match("Array"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__84" - - // $ANTLR start "T__85" - public final void mT__85() throws RecognitionException { - try { - int _type = T__85; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:71:7: ( 'ParameterAny' ) - // InternalRos.g:71:9: 'ParameterAny' - { - match("ParameterAny"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__85" - - // $ANTLR start "T__86" - public final void mT__86() throws RecognitionException { - try { - int _type = T__86; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:72:7: ( 'ParameterStructMember' ) - // InternalRos.g:72:9: 'ParameterStructMember' - { - match("ParameterStructMember"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__86" - - // $ANTLR start "T__87" - public final void mT__87() throws RecognitionException { - try { - int _type = T__87; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:73:7: ( 'bool' ) - // InternalRos.g:73:9: 'bool' - { - match("bool"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__87" - - // $ANTLR start "T__88" - public final void mT__88() throws RecognitionException { - try { - int _type = T__88; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:74:7: ( 'int8' ) - // InternalRos.g:74:9: 'int8' - { - match("int8"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__88" - - // $ANTLR start "T__89" - public final void mT__89() throws RecognitionException { - try { - int _type = T__89; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:75:7: ( 'uint8' ) - // InternalRos.g:75:9: 'uint8' - { - match("uint8"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__89" - - // $ANTLR start "T__90" - public final void mT__90() throws RecognitionException { - try { - int _type = T__90; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:76:7: ( 'int16' ) - // InternalRos.g:76:9: 'int16' - { - match("int16"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__90" - - // $ANTLR start "T__91" - public final void mT__91() throws RecognitionException { - try { - int _type = T__91; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:77:7: ( 'uint16' ) - // InternalRos.g:77:9: 'uint16' - { - match("uint16"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__91" - - // $ANTLR start "T__92" - public final void mT__92() throws RecognitionException { - try { - int _type = T__92; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:78:7: ( 'int32' ) - // InternalRos.g:78:9: 'int32' - { - match("int32"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__92" - - // $ANTLR start "T__93" - public final void mT__93() throws RecognitionException { - try { - int _type = T__93; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:79:7: ( 'uint32' ) - // InternalRos.g:79:9: 'uint32' - { - match("uint32"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__93" - - // $ANTLR start "T__94" - public final void mT__94() throws RecognitionException { - try { - int _type = T__94; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:80:7: ( 'int64' ) - // InternalRos.g:80:9: 'int64' - { - match("int64"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__94" - - // $ANTLR start "T__95" - public final void mT__95() throws RecognitionException { - try { - int _type = T__95; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:81:7: ( 'uint64' ) - // InternalRos.g:81:9: 'uint64' - { - match("uint64"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__95" - - // $ANTLR start "T__96" - public final void mT__96() throws RecognitionException { - try { - int _type = T__96; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:82:7: ( 'float32' ) - // InternalRos.g:82:9: 'float32' - { - match("float32"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__96" - - // $ANTLR start "T__97" - public final void mT__97() throws RecognitionException { - try { - int _type = T__97; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:83:7: ( 'float64' ) - // InternalRos.g:83:9: 'float64' - { - match("float64"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__97" - - // $ANTLR start "T__98" - public final void mT__98() throws RecognitionException { - try { - int _type = T__98; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:84:7: ( 'string' ) - // InternalRos.g:84:9: 'string' - { - match("string"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__98" - - // $ANTLR start "T__99" - public final void mT__99() throws RecognitionException { - try { - int _type = T__99; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:85:7: ( 'byte' ) - // InternalRos.g:85:9: 'byte' - { - match("byte"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__99" - - // $ANTLR start "T__100" - public final void mT__100() throws RecognitionException { - try { - int _type = T__100; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:86:8: ( 'bool[]' ) - // InternalRos.g:86:10: 'bool[]' - { - match("bool[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__100" - - // $ANTLR start "T__101" - public final void mT__101() throws RecognitionException { - try { - int _type = T__101; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:87:8: ( 'int8[]' ) - // InternalRos.g:87:10: 'int8[]' - { - match("int8[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__101" - - // $ANTLR start "T__102" - public final void mT__102() throws RecognitionException { - try { - int _type = T__102; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:88:8: ( 'uint8[]' ) - // InternalRos.g:88:10: 'uint8[]' - { - match("uint8[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__102" - - // $ANTLR start "T__103" - public final void mT__103() throws RecognitionException { - try { - int _type = T__103; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:89:8: ( 'int16[]' ) - // InternalRos.g:89:10: 'int16[]' - { - match("int16[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__103" - - // $ANTLR start "T__104" - public final void mT__104() throws RecognitionException { - try { - int _type = T__104; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:90:8: ( 'uint16[]' ) - // InternalRos.g:90:10: 'uint16[]' - { - match("uint16[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__104" - - // $ANTLR start "T__105" - public final void mT__105() throws RecognitionException { - try { - int _type = T__105; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:91:8: ( 'int32[]' ) - // InternalRos.g:91:10: 'int32[]' - { - match("int32[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__105" - - // $ANTLR start "T__106" - public final void mT__106() throws RecognitionException { - try { - int _type = T__106; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:92:8: ( 'uint32[]' ) - // InternalRos.g:92:10: 'uint32[]' - { - match("uint32[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__106" - - // $ANTLR start "T__107" - public final void mT__107() throws RecognitionException { - try { - int _type = T__107; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:93:8: ( 'int64[]' ) - // InternalRos.g:93:10: 'int64[]' - { - match("int64[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__107" - - // $ANTLR start "T__108" - public final void mT__108() throws RecognitionException { - try { - int _type = T__108; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:94:8: ( 'uint64[]' ) - // InternalRos.g:94:10: 'uint64[]' - { - match("uint64[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__108" - - // $ANTLR start "T__109" - public final void mT__109() throws RecognitionException { - try { - int _type = T__109; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:95:8: ( 'float32[]' ) - // InternalRos.g:95:10: 'float32[]' - { - match("float32[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__109" - - // $ANTLR start "T__110" - public final void mT__110() throws RecognitionException { - try { - int _type = T__110; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:96:8: ( 'float64[]' ) - // InternalRos.g:96:10: 'float64[]' - { - match("float64[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__110" - - // $ANTLR start "T__111" - public final void mT__111() throws RecognitionException { - try { - int _type = T__111; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:97:8: ( 'string[]' ) - // InternalRos.g:97:10: 'string[]' - { - match("string[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__111" - - // $ANTLR start "T__112" - public final void mT__112() throws RecognitionException { - try { - int _type = T__112; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:98:8: ( 'byte[]' ) - // InternalRos.g:98:10: 'byte[]' - { - match("byte[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__112" - - // $ANTLR start "T__113" - public final void mT__113() throws RecognitionException { - try { - int _type = T__113; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:99:8: ( '[]' ) - // InternalRos.g:99:10: '[]' - { - match("[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__113" - - // $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; - // InternalRos.g:16602:23: ( ( '/' RULE_ID | RULE_ID '/' )* ) - // InternalRos.g:16602:25: ( '/' RULE_ID | RULE_ID '/' )* - { - // InternalRos.g:16602:25: ( '/' RULE_ID | RULE_ID '/' )* - loop1: - do { - int alt1=3; - int LA1_0 = input.LA(1); - - if ( (LA1_0=='/') ) { - alt1=1; - } - else if ( ((LA1_0>='A' && LA1_0<='Z')||(LA1_0>='^' && LA1_0<='_')||(LA1_0>='a' && LA1_0<='z')) ) { - alt1=2; - } - - - switch (alt1) { - case 1 : - // InternalRos.g:16602:26: '/' RULE_ID - { - match('/'); - mRULE_ID(); - - } - break; - case 2 : - // InternalRos.g:16602:38: RULE_ID '/' - { - mRULE_ID(); - match('/'); - - } - break; - - default : - break loop1; - } - } 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; - // InternalRos.g:16604:27: ( ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* ) - // InternalRos.g:16604:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* - { - // InternalRos.g:16604:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* - loop2: - do { - int alt2=4; - switch ( input.LA(1) ) { - case '/': - { - alt2=1; - } - break; - case '\"': - case '\'': - { - alt2=2; - } - break; - case '~': - { - alt2=3; - } - break; - - } - - switch (alt2) { - case 1 : - // InternalRos.g:16604:30: '/' RULE_STRING - { - match('/'); - mRULE_STRING(); - - } - break; - case 2 : - // InternalRos.g:16604:46: RULE_STRING '/' - { - mRULE_STRING(); - match('/'); - - } - break; - case 3 : - // InternalRos.g:16604:62: '~' RULE_STRING - { - match('~'); - mRULE_STRING(); - - } - break; - - default : - break loop2; - } - } while (true); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_ROS_CONVENTION_PARAM" - - // $ANTLR start "RULE_DIGIT" - public final void mRULE_DIGIT() throws RecognitionException { - try { - // InternalRos.g:16606:21: ( '0' .. '9' ) - // InternalRos.g:16606:23: '0' .. '9' - { - matchRange('0','9'); - - } - - } - finally { - } - } - // $ANTLR end "RULE_DIGIT" - - // $ANTLR start "RULE_BINARY" - public final void mRULE_BINARY() throws RecognitionException { - try { - int _type = RULE_BINARY; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:16608:13: ( ( '0b' | '0B' ) ( '0' | '1' )+ ) - // InternalRos.g:16608:15: ( '0b' | '0B' ) ( '0' | '1' )+ - { - // InternalRos.g:16608:15: ( '0b' | '0B' ) - int alt3=2; - int LA3_0 = input.LA(1); - - if ( (LA3_0=='0') ) { - int LA3_1 = input.LA(2); - - if ( (LA3_1=='b') ) { - alt3=1; - } - else if ( (LA3_1=='B') ) { - alt3=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 3, 1, input); - - throw nvae; - } - } - else { - NoViableAltException nvae = - new NoViableAltException("", 3, 0, input); - - throw nvae; - } - switch (alt3) { - case 1 : - // InternalRos.g:16608:16: '0b' - { - match("0b"); - - - } - break; - case 2 : - // InternalRos.g:16608:21: '0B' - { - match("0B"); - - - } - break; - - } - - // InternalRos.g:16608:27: ( '0' | '1' )+ - int cnt4=0; - loop4: - do { - int alt4=2; - int LA4_0 = input.LA(1); - - if ( ((LA4_0>='0' && LA4_0<='1')) ) { - alt4=1; - } - - - switch (alt4) { - case 1 : - // InternalRos.g: - { - if ( (input.LA(1)>='0' && input.LA(1)<='1') ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - default : - if ( cnt4 >= 1 ) break loop4; - EarlyExitException eee = - new EarlyExitException(4, input); - throw eee; - } - cnt4++; - } while (true); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_BINARY" - - // $ANTLR start "RULE_BOOLEAN" - public final void mRULE_BOOLEAN() throws RecognitionException { - try { - int _type = RULE_BOOLEAN; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:16610:14: ( ( 'true' | 'false' ) ) - // InternalRos.g:16610:16: ( 'true' | 'false' ) - { - // InternalRos.g:16610:16: ( 'true' | 'false' ) - int alt5=2; - int LA5_0 = input.LA(1); - - if ( (LA5_0=='t') ) { - alt5=1; - } - else if ( (LA5_0=='f') ) { - alt5=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 5, 0, input); - - throw nvae; - } - switch (alt5) { - case 1 : - // InternalRos.g:16610:17: 'true' - { - match("true"); - - - } - break; - case 2 : - // InternalRos.g:16610:24: 'false' - { - match("false"); - - - } - break; - - } - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_BOOLEAN" - - // $ANTLR start "RULE_DOUBLE" - public final void mRULE_DOUBLE() throws RecognitionException { - try { - int _type = RULE_DOUBLE; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:16612:13: ( RULE_DECINT ( '.' ( RULE_DIGIT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DECINT ) ) - // InternalRos.g:16612:15: RULE_DECINT ( '.' ( RULE_DIGIT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DECINT ) - { - mRULE_DECINT(); - // InternalRos.g:16612:27: ( '.' ( RULE_DIGIT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DECINT ) - int alt10=2; - alt10 = dfa10.predict(input); - switch (alt10) { - case 1 : - // InternalRos.g:16612:28: '.' ( RULE_DIGIT )* - { - match('.'); - // InternalRos.g:16612:32: ( RULE_DIGIT )* - loop6: - do { - int alt6=2; - int LA6_0 = input.LA(1); - - if ( ((LA6_0>='0' && LA6_0<='9')) ) { - alt6=1; - } - - - switch (alt6) { - case 1 : - // InternalRos.g:16612:32: RULE_DIGIT - { - mRULE_DIGIT(); - - } - break; - - default : - break loop6; - } - } while (true); - - - } - break; - case 2 : - // InternalRos.g:16612:44: ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DECINT - { - // InternalRos.g:16612:44: ( '.' ( RULE_DIGIT )* )? - int alt8=2; - int LA8_0 = input.LA(1); - - if ( (LA8_0=='.') ) { - alt8=1; - } - switch (alt8) { - case 1 : - // InternalRos.g:16612:45: '.' ( RULE_DIGIT )* - { - match('.'); - // InternalRos.g:16612:49: ( RULE_DIGIT )* - loop7: - do { - int alt7=2; - int LA7_0 = input.LA(1); - - if ( ((LA7_0>='0' && LA7_0<='9')) ) { - alt7=1; - } - - - switch (alt7) { - case 1 : - // InternalRos.g:16612:49: RULE_DIGIT - { - mRULE_DIGIT(); - - } - break; - - default : - break loop7; - } - } while (true); - - - } - break; - - } - - if ( input.LA(1)=='E'||input.LA(1)=='e' ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - // InternalRos.g:16612:73: ( '-' | '+' )? - int alt9=2; - int LA9_0 = input.LA(1); - - if ( (LA9_0=='-') ) { - int LA9_1 = input.LA(2); - - if ( (LA9_1=='0') ) { - alt9=1; - } - else if ( (LA9_1=='-'||(LA9_1>='1' && LA9_1<='9')) ) { - alt9=1; - } - } - else if ( (LA9_0=='+') ) { - alt9=1; - } - switch (alt9) { - case 1 : - // InternalRos.g: - { - if ( input.LA(1)=='+'||input.LA(1)=='-' ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - } - - mRULE_DECINT(); - - } - break; - - } - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_DOUBLE" - - // $ANTLR start "RULE_DECINT" - public final void mRULE_DECINT() throws RecognitionException { - try { - int _type = RULE_DECINT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:16614:13: ( ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) ) - // InternalRos.g:16614:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) - { - // InternalRos.g:16614:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) - int alt13=3; - switch ( input.LA(1) ) { - case '0': - { - alt13=1; - } - break; - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - { - alt13=2; - } - break; - case '-': - { - alt13=3; - } - break; - default: - NoViableAltException nvae = - new NoViableAltException("", 13, 0, input); - - throw nvae; - } - - switch (alt13) { - case 1 : - // InternalRos.g:16614:16: '0' - { - match('0'); - - } - break; - case 2 : - // InternalRos.g:16614:20: '1' .. '9' ( RULE_DIGIT )* - { - matchRange('1','9'); - // InternalRos.g:16614:29: ( RULE_DIGIT )* - loop11: - do { - int alt11=2; - int LA11_0 = input.LA(1); - - if ( ((LA11_0>='0' && LA11_0<='9')) ) { - alt11=1; - } - - - switch (alt11) { - case 1 : - // InternalRos.g:16614:29: RULE_DIGIT - { - mRULE_DIGIT(); - - } - break; - - default : - break loop11; - } - } while (true); - - - } - break; - case 3 : - // InternalRos.g:16614:41: '-' '0' .. '9' ( RULE_DIGIT )* - { - match('-'); - matchRange('0','9'); - // InternalRos.g:16614:54: ( RULE_DIGIT )* - loop12: - do { - int alt12=2; - int LA12_0 = input.LA(1); - - if ( ((LA12_0>='0' && LA12_0<='9')) ) { - alt12=1; - } - - - switch (alt12) { - case 1 : - // InternalRos.g:16614:54: RULE_DIGIT - { - mRULE_DIGIT(); - - } - break; - - default : - break loop12; - } - } while (true); - - - } - break; - - } - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_DECINT" - - // $ANTLR start "RULE_DAY" - public final void mRULE_DAY() throws RecognitionException { - try { - // InternalRos.g:16616:19: ( ( '1' .. '9' | '1' .. '3' '0' .. '9' ) ) - // InternalRos.g:16616:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) - { - // InternalRos.g:16616:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) - int alt14=2; - int LA14_0 = input.LA(1); - - if ( ((LA14_0>='1' && LA14_0<='3')) ) { - int LA14_1 = input.LA(2); - - if ( ((LA14_1>='0' && LA14_1<='9')) ) { - alt14=2; - } - else { - alt14=1;} - } - else if ( ((LA14_0>='4' && LA14_0<='9')) ) { - alt14=1; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 14, 0, input); - - throw nvae; - } - switch (alt14) { - case 1 : - // InternalRos.g:16616:22: '1' .. '9' - { - matchRange('1','9'); - - } - break; - case 2 : - // InternalRos.g:16616:31: '1' .. '3' '0' .. '9' - { - matchRange('1','3'); - matchRange('0','9'); - - } - break; - - } - - - } - - } - finally { - } - } - // $ANTLR end "RULE_DAY" - - // $ANTLR start "RULE_MONTH" - public final void mRULE_MONTH() throws RecognitionException { - try { - // InternalRos.g:16618:21: ( ( '1' .. '9' | '1' '0' .. '2' ) ) - // InternalRos.g:16618:23: ( '1' .. '9' | '1' '0' .. '2' ) - { - // InternalRos.g:16618:23: ( '1' .. '9' | '1' '0' .. '2' ) - int alt15=2; - int LA15_0 = input.LA(1); - - if ( (LA15_0=='1') ) { - int LA15_1 = input.LA(2); - - if ( ((LA15_1>='0' && LA15_1<='2')) ) { - alt15=2; - } - else { - alt15=1;} - } - else if ( ((LA15_0>='2' && LA15_0<='9')) ) { - alt15=1; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 15, 0, input); - - throw nvae; - } - switch (alt15) { - case 1 : - // InternalRos.g:16618:24: '1' .. '9' - { - matchRange('1','9'); - - } - break; - case 2 : - // InternalRos.g:16618:33: '1' '0' .. '2' - { - match('1'); - matchRange('0','2'); - - } - break; - - } - - - } - - } - finally { - } - } - // $ANTLR end "RULE_MONTH" - - // $ANTLR start "RULE_YEAR" - public final void mRULE_YEAR() throws RecognitionException { - try { - // InternalRos.g:16620:20: ( '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' ) - // InternalRos.g:16620:22: '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' - { - matchRange('0','2'); - matchRange('0','9'); - matchRange('0','9'); - matchRange('0','9'); - - } - - } - finally { - } - } - // $ANTLR end "RULE_YEAR" - - // $ANTLR start "RULE_HOUR" - public final void mRULE_HOUR() throws RecognitionException { - try { - // InternalRos.g:16622:20: ( ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) ) - // InternalRos.g:16622:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) - { - // InternalRos.g:16622:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) - int alt16=2; - int LA16_0 = input.LA(1); - - if ( ((LA16_0>='0' && LA16_0<='1')) ) { - alt16=1; - } - else if ( (LA16_0=='2') ) { - alt16=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 16, 0, input); - - throw nvae; - } - switch (alt16) { - case 1 : - // InternalRos.g:16622:23: '0' .. '1' '0' .. '9' - { - matchRange('0','1'); - matchRange('0','9'); - - } - break; - case 2 : - // InternalRos.g:16622:41: '2' '0' .. '3' - { - match('2'); - matchRange('0','3'); - - } - break; - - } - - - } - - } - finally { - } - } - // $ANTLR end "RULE_HOUR" - - // $ANTLR start "RULE_MIN_SEC" - public final void mRULE_MIN_SEC() throws RecognitionException { - try { - // InternalRos.g:16624:23: ( '0' .. '5' '0' .. '9' ) - // InternalRos.g:16624:25: '0' .. '5' '0' .. '9' - { - matchRange('0','5'); - matchRange('0','9'); - - } - - } - finally { - } - } - // $ANTLR end "RULE_MIN_SEC" - - // $ANTLR start "RULE_DATE_TIME" - public final void mRULE_DATE_TIME() throws RecognitionException { - try { - int _type = RULE_DATE_TIME; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:16626:16: ( RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC ) - // InternalRos.g:16626:18: RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC - { - mRULE_YEAR(); - match('-'); - mRULE_MONTH(); - match('-'); - mRULE_DAY(); - match('T'); - mRULE_HOUR(); - match(':'); - mRULE_MIN_SEC(); - match(':'); - mRULE_MIN_SEC(); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_DATE_TIME" - - // $ANTLR start "RULE_MESSAGE_ASIGMENT" - public final void mRULE_MESSAGE_ASIGMENT() throws RecognitionException { - try { - int _type = RULE_MESSAGE_ASIGMENT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:16628:23: ( ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) ) - // InternalRos.g:16628:25: ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) - { - // InternalRos.g:16628:25: ( RULE_ID | RULE_STRING ) - int alt17=2; - int LA17_0 = input.LA(1); - - if ( ((LA17_0>='A' && LA17_0<='Z')||(LA17_0>='^' && LA17_0<='_')||(LA17_0>='a' && LA17_0<='z')) ) { - alt17=1; - } - else if ( (LA17_0=='\"'||LA17_0=='\'') ) { - alt17=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 17, 0, input); - - throw nvae; - } - switch (alt17) { - case 1 : - // InternalRos.g:16628:26: RULE_ID - { - mRULE_ID(); - - } - break; - case 2 : - // InternalRos.g:16628:34: RULE_STRING - { - mRULE_STRING(); - - } - break; - - } - - match('='); - // InternalRos.g:16628:51: ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) - int alt18=4; - switch ( input.LA(1) ) { - case 'A': - case 'B': - case 'C': - case 'D': - case 'E': - case 'F': - case 'G': - case 'H': - case 'I': - case 'J': - case 'K': - case 'L': - case 'M': - case 'N': - case 'O': - case 'P': - case 'Q': - case 'R': - case 'S': - case 'T': - case 'U': - case 'V': - case 'W': - case 'X': - case 'Y': - case 'Z': - case '^': - case '_': - case 'a': - case 'b': - case 'c': - case 'd': - case 'e': - case 'f': - case 'g': - case 'h': - case 'i': - case 'j': - case 'k': - case 'l': - case 'm': - case 'n': - case 'o': - case 'p': - case 'q': - case 'r': - case 's': - case 't': - case 'u': - case 'v': - case 'w': - case 'x': - case 'y': - case 'z': - { - alt18=1; - } - break; - case '\"': - case '\'': - { - alt18=2; - } - break; - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - { - alt18=3; - } - break; - case '-': - { - alt18=4; - } - break; - default: - NoViableAltException nvae = - new NoViableAltException("", 18, 0, input); - - throw nvae; - } - - switch (alt18) { - case 1 : - // InternalRos.g:16628:52: RULE_ID - { - mRULE_ID(); - - } - break; - case 2 : - // InternalRos.g:16628:60: RULE_STRING - { - mRULE_STRING(); - - } - break; - case 3 : - // InternalRos.g:16628:72: RULE_INT - { - mRULE_INT(); - - } - break; - case 4 : - // InternalRos.g:16628:81: '-' RULE_INT - { - match('-'); - mRULE_INT(); - - } - break; - - } - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_MESSAGE_ASIGMENT" - - // $ANTLR start "RULE_ID" - public final void mRULE_ID() throws RecognitionException { - try { - int _type = RULE_ID; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:16630:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) - // InternalRos.g:16630:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* - { - // InternalRos.g:16630:11: ( '^' )? - int alt19=2; - int LA19_0 = input.LA(1); - - if ( (LA19_0=='^') ) { - alt19=1; - } - switch (alt19) { - case 1 : - // InternalRos.g:16630: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;} - - // InternalRos.g:16630:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* - loop20: - do { - int alt20=2; - int LA20_0 = input.LA(1); - - if ( ((LA20_0>='0' && LA20_0<='9')||(LA20_0>='A' && LA20_0<='Z')||LA20_0=='_'||(LA20_0>='a' && LA20_0<='z')) ) { - alt20=1; - } - - - switch (alt20) { - case 1 : - // InternalRos.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 loop20; - } - } 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 { - // InternalRos.g:16632:19: ( ( '0' .. '9' )+ ) - // InternalRos.g:16632:21: ( '0' .. '9' )+ - { - // InternalRos.g:16632:21: ( '0' .. '9' )+ - int cnt21=0; - loop21: - do { - int alt21=2; - int LA21_0 = input.LA(1); - - if ( ((LA21_0>='0' && LA21_0<='9')) ) { - alt21=1; - } - - - switch (alt21) { - case 1 : - // InternalRos.g:16632:22: '0' .. '9' - { - matchRange('0','9'); - - } - break; - - default : - if ( cnt21 >= 1 ) break loop21; - EarlyExitException eee = - new EarlyExitException(21, input); - throw eee; - } - cnt21++; - } while (true); - - - } - - } - 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; - // InternalRos.g:16634:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) - // InternalRos.g:16634:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) - { - // InternalRos.g:16634:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) - int alt24=2; - int LA24_0 = input.LA(1); - - if ( (LA24_0=='\"') ) { - alt24=1; - } - else if ( (LA24_0=='\'') ) { - alt24=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 24, 0, input); - - throw nvae; - } - switch (alt24) { - case 1 : - // InternalRos.g:16634:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' - { - match('\"'); - // InternalRos.g:16634:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* - loop22: - do { - int alt22=3; - int LA22_0 = input.LA(1); - - if ( (LA22_0=='\\') ) { - alt22=1; - } - else if ( ((LA22_0>='\u0000' && LA22_0<='!')||(LA22_0>='#' && LA22_0<='[')||(LA22_0>=']' && LA22_0<='\uFFFF')) ) { - alt22=2; - } - - - switch (alt22) { - case 1 : - // InternalRos.g:16634:21: '\\\\' . - { - match('\\'); - matchAny(); - - } - break; - case 2 : - // InternalRos.g:16634: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 loop22; - } - } while (true); - - match('\"'); - - } - break; - case 2 : - // InternalRos.g:16634:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' - { - match('\''); - // InternalRos.g:16634:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* - loop23: - do { - int alt23=3; - int LA23_0 = input.LA(1); - - if ( (LA23_0=='\\') ) { - alt23=1; - } - else if ( ((LA23_0>='\u0000' && LA23_0<='&')||(LA23_0>='(' && LA23_0<='[')||(LA23_0>=']' && LA23_0<='\uFFFF')) ) { - alt23=2; - } - - - switch (alt23) { - case 1 : - // InternalRos.g:16634:54: '\\\\' . - { - match('\\'); - matchAny(); - - } - break; - case 2 : - // InternalRos.g:16634: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 loop23; - } - } 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; - // InternalRos.g:16636:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) - // InternalRos.g:16636:19: '/*' ( options {greedy=false; } : . )* '*/' - { - match("/*"); - - // InternalRos.g:16636:24: ( options {greedy=false; } : . )* - loop25: - do { - int alt25=2; - int LA25_0 = input.LA(1); - - if ( (LA25_0=='*') ) { - int LA25_1 = input.LA(2); - - if ( (LA25_1=='/') ) { - alt25=2; - } - else if ( ((LA25_1>='\u0000' && LA25_1<='.')||(LA25_1>='0' && LA25_1<='\uFFFF')) ) { - alt25=1; - } - - - } - else if ( ((LA25_0>='\u0000' && LA25_0<=')')||(LA25_0>='+' && LA25_0<='\uFFFF')) ) { - alt25=1; - } - - - switch (alt25) { - case 1 : - // InternalRos.g:16636:52: . - { - matchAny(); - - } - break; - - default : - break loop25; - } - } while (true); - - match("*/"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_ML_COMMENT" - - // $ANTLR start "RULE_SL_COMMENT" - public final void mRULE_SL_COMMENT() throws RecognitionException { - try { - int _type = RULE_SL_COMMENT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:16638:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) - // InternalRos.g:16638:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? - { - match("//"); - - // InternalRos.g:16638:24: (~ ( ( '\\n' | '\\r' ) ) )* - loop26: - do { - int alt26=2; - int LA26_0 = input.LA(1); - - if ( ((LA26_0>='\u0000' && LA26_0<='\t')||(LA26_0>='\u000B' && LA26_0<='\f')||(LA26_0>='\u000E' && LA26_0<='\uFFFF')) ) { - alt26=1; - } - - - switch (alt26) { - case 1 : - // InternalRos.g:16638:24: ~ ( ( '\\n' | '\\r' ) ) - { - if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - default : - break loop26; - } - } while (true); - - // InternalRos.g:16638:40: ( ( '\\r' )? '\\n' )? - int alt28=2; - int LA28_0 = input.LA(1); - - if ( (LA28_0=='\n'||LA28_0=='\r') ) { - alt28=1; - } - switch (alt28) { - case 1 : - // InternalRos.g:16638:41: ( '\\r' )? '\\n' - { - // InternalRos.g:16638:41: ( '\\r' )? - int alt27=2; - int LA27_0 = input.LA(1); - - if ( (LA27_0=='\r') ) { - alt27=1; - } - switch (alt27) { - case 1 : - // InternalRos.g:16638:41: '\\r' - { - match('\r'); - - } - break; - - } - - match('\n'); - - } - break; - - } - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_SL_COMMENT" - - // $ANTLR start "RULE_WS" - public final void mRULE_WS() throws RecognitionException { - try { - int _type = RULE_WS; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:16640:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) - // InternalRos.g:16640:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - { - // InternalRos.g:16640:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - int cnt29=0; - loop29: - do { - int alt29=2; - int LA29_0 = input.LA(1); - - if ( ((LA29_0>='\t' && LA29_0<='\n')||LA29_0=='\r'||LA29_0==' ') ) { - alt29=1; - } - - - switch (alt29) { - case 1 : - // InternalRos.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 ( cnt29 >= 1 ) break loop29; - EarlyExitException eee = - new EarlyExitException(29, input); - throw eee; - } - cnt29++; - } 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; - // InternalRos.g:16642:16: ( . ) - // InternalRos.g:16642:18: . - { - matchAny(); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_ANY_OTHER" - - public void mTokens() throws RecognitionException { - // InternalRos.g:1:8: ( T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | RULE_ROS_CONVENTION_A | RULE_ROS_CONVENTION_PARAM | RULE_BINARY | RULE_BOOLEAN | RULE_DOUBLE | RULE_DECINT | RULE_DATE_TIME | RULE_MESSAGE_ASIGMENT | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) - int alt30=103; - alt30 = dfa30.predict(input); - switch (alt30) { - case 1 : - // InternalRos.g:1:10: T__25 - { - mT__25(); - - } - break; - case 2 : - // InternalRos.g:1:16: T__26 - { - mT__26(); - - } - break; - case 3 : - // InternalRos.g:1:22: T__27 - { - mT__27(); - - } - break; - case 4 : - // InternalRos.g:1:28: T__28 - { - mT__28(); - - } - break; - case 5 : - // InternalRos.g:1:34: T__29 - { - mT__29(); - - } - break; - case 6 : - // InternalRos.g:1:40: T__30 - { - mT__30(); - - } - break; - case 7 : - // InternalRos.g:1:46: T__31 - { - mT__31(); - - } - break; - case 8 : - // InternalRos.g:1:52: T__32 - { - mT__32(); - - } - break; - case 9 : - // InternalRos.g:1:58: T__33 - { - mT__33(); - - } - break; - case 10 : - // InternalRos.g:1:64: T__34 - { - mT__34(); - - } - break; - case 11 : - // InternalRos.g:1:70: T__35 - { - mT__35(); - - } - break; - case 12 : - // InternalRos.g:1:76: T__36 - { - mT__36(); - - } - break; - case 13 : - // InternalRos.g:1:82: T__37 - { - mT__37(); - - } - break; - case 14 : - // InternalRos.g:1:88: T__38 - { - mT__38(); - - } - break; - case 15 : - // InternalRos.g:1:94: T__39 - { - mT__39(); - - } - break; - case 16 : - // InternalRos.g:1:100: T__40 - { - mT__40(); - - } - break; - case 17 : - // InternalRos.g:1:106: T__41 - { - mT__41(); - - } - break; - case 18 : - // InternalRos.g:1:112: T__42 - { - mT__42(); - - } - break; - case 19 : - // InternalRos.g:1:118: T__43 - { - mT__43(); - - } - break; - case 20 : - // InternalRos.g:1:124: T__44 - { - mT__44(); - - } - break; - case 21 : - // InternalRos.g:1:130: T__45 - { - mT__45(); - - } - break; - case 22 : - // InternalRos.g:1:136: T__46 - { - mT__46(); - - } - break; - case 23 : - // InternalRos.g:1:142: T__47 - { - mT__47(); - - } - break; - case 24 : - // InternalRos.g:1:148: T__48 - { - mT__48(); - - } - break; - case 25 : - // InternalRos.g:1:154: T__49 - { - mT__49(); - - } - break; - case 26 : - // InternalRos.g:1:160: T__50 - { - mT__50(); - - } - break; - case 27 : - // InternalRos.g:1:166: T__51 - { - mT__51(); - - } - break; - case 28 : - // InternalRos.g:1:172: T__52 - { - mT__52(); - - } - break; - case 29 : - // InternalRos.g:1:178: T__53 - { - mT__53(); - - } - break; - case 30 : - // InternalRos.g:1:184: T__54 - { - mT__54(); - - } - break; - case 31 : - // InternalRos.g:1:190: T__55 - { - mT__55(); - - } - break; - case 32 : - // InternalRos.g:1:196: T__56 - { - mT__56(); - - } - break; - case 33 : - // InternalRos.g:1:202: T__57 - { - mT__57(); - - } - break; - case 34 : - // InternalRos.g:1:208: T__58 - { - mT__58(); - - } - break; - case 35 : - // InternalRos.g:1:214: T__59 - { - mT__59(); - - } - break; - case 36 : - // InternalRos.g:1:220: T__60 - { - mT__60(); - - } - break; - case 37 : - // InternalRos.g:1:226: T__61 - { - mT__61(); - - } - break; - case 38 : - // InternalRos.g:1:232: T__62 - { - mT__62(); - - } - break; - case 39 : - // InternalRos.g:1:238: T__63 - { - mT__63(); - - } - break; - case 40 : - // InternalRos.g:1:244: T__64 - { - mT__64(); - - } - break; - case 41 : - // InternalRos.g:1:250: T__65 - { - mT__65(); - - } - break; - case 42 : - // InternalRos.g:1:256: T__66 - { - mT__66(); - - } - break; - case 43 : - // InternalRos.g:1:262: T__67 - { - mT__67(); - - } - break; - case 44 : - // InternalRos.g:1:268: T__68 - { - mT__68(); - - } - break; - case 45 : - // InternalRos.g:1:274: T__69 - { - mT__69(); - - } - break; - case 46 : - // InternalRos.g:1:280: T__70 - { - mT__70(); - - } - break; - case 47 : - // InternalRos.g:1:286: T__71 - { - mT__71(); - - } - break; - case 48 : - // InternalRos.g:1:292: T__72 - { - mT__72(); - - } - break; - case 49 : - // InternalRos.g:1:298: T__73 - { - mT__73(); - - } - break; - case 50 : - // InternalRos.g:1:304: T__74 - { - mT__74(); - - } - break; - case 51 : - // InternalRos.g:1:310: T__75 - { - mT__75(); - - } - break; - case 52 : - // InternalRos.g:1:316: T__76 - { - mT__76(); - - } - break; - case 53 : - // InternalRos.g:1:322: T__77 - { - mT__77(); - - } - break; - case 54 : - // InternalRos.g:1:328: T__78 - { - mT__78(); - - } - break; - case 55 : - // InternalRos.g:1:334: T__79 - { - mT__79(); - - } - break; - case 56 : - // InternalRos.g:1:340: T__80 - { - mT__80(); - - } - break; - case 57 : - // InternalRos.g:1:346: T__81 - { - mT__81(); - - } - break; - case 58 : - // InternalRos.g:1:352: T__82 - { - mT__82(); - - } - break; - case 59 : - // InternalRos.g:1:358: T__83 - { - mT__83(); - - } - break; - case 60 : - // InternalRos.g:1:364: T__84 - { - mT__84(); - - } - break; - case 61 : - // InternalRos.g:1:370: T__85 - { - mT__85(); - - } - break; - case 62 : - // InternalRos.g:1:376: T__86 - { - mT__86(); - - } - break; - case 63 : - // InternalRos.g:1:382: T__87 - { - mT__87(); - - } - break; - case 64 : - // InternalRos.g:1:388: T__88 - { - mT__88(); - - } - break; - case 65 : - // InternalRos.g:1:394: T__89 - { - mT__89(); - - } - break; - case 66 : - // InternalRos.g:1:400: T__90 - { - mT__90(); - - } - break; - case 67 : - // InternalRos.g:1:406: T__91 - { - mT__91(); - - } - break; - case 68 : - // InternalRos.g:1:412: T__92 - { - mT__92(); - - } - break; - case 69 : - // InternalRos.g:1:418: T__93 - { - mT__93(); - - } - break; - case 70 : - // InternalRos.g:1:424: T__94 - { - mT__94(); - - } - break; - case 71 : - // InternalRos.g:1:430: T__95 - { - mT__95(); - - } - break; - case 72 : - // InternalRos.g:1:436: T__96 - { - mT__96(); - - } - break; - case 73 : - // InternalRos.g:1:442: T__97 - { - mT__97(); - - } - break; - case 74 : - // InternalRos.g:1:448: T__98 - { - mT__98(); - - } - break; - case 75 : - // InternalRos.g:1:454: T__99 - { - mT__99(); - - } - break; - case 76 : - // InternalRos.g:1:460: T__100 - { - mT__100(); - - } - break; - case 77 : - // InternalRos.g:1:467: T__101 - { - mT__101(); - - } - break; - case 78 : - // InternalRos.g:1:474: T__102 - { - mT__102(); - - } - break; - case 79 : - // InternalRos.g:1:481: T__103 - { - mT__103(); - - } - break; - case 80 : - // InternalRos.g:1:488: T__104 - { - mT__104(); - - } - break; - case 81 : - // InternalRos.g:1:495: T__105 - { - mT__105(); - - } - break; - case 82 : - // InternalRos.g:1:502: T__106 - { - mT__106(); - - } - break; - case 83 : - // InternalRos.g:1:509: T__107 - { - mT__107(); - - } - break; - case 84 : - // InternalRos.g:1:516: T__108 - { - mT__108(); - - } - break; - case 85 : - // InternalRos.g:1:523: T__109 - { - mT__109(); - - } - break; - case 86 : - // InternalRos.g:1:530: T__110 - { - mT__110(); - - } - break; - case 87 : - // InternalRos.g:1:537: T__111 - { - mT__111(); - - } - break; - case 88 : - // InternalRos.g:1:544: T__112 - { - mT__112(); - - } - break; - case 89 : - // InternalRos.g:1:551: T__113 - { - mT__113(); - - } - break; - case 90 : - // InternalRos.g:1:558: RULE_ROS_CONVENTION_A - { - mRULE_ROS_CONVENTION_A(); - - } - break; - case 91 : - // InternalRos.g:1:580: RULE_ROS_CONVENTION_PARAM - { - mRULE_ROS_CONVENTION_PARAM(); - - } - break; - case 92 : - // InternalRos.g:1:606: RULE_BINARY - { - mRULE_BINARY(); - - } - break; - case 93 : - // InternalRos.g:1:618: RULE_BOOLEAN - { - mRULE_BOOLEAN(); - - } - break; - case 94 : - // InternalRos.g:1:631: RULE_DOUBLE - { - mRULE_DOUBLE(); - - } - break; - case 95 : - // InternalRos.g:1:643: RULE_DECINT - { - mRULE_DECINT(); - - } - break; - case 96 : - // InternalRos.g:1:655: RULE_DATE_TIME - { - mRULE_DATE_TIME(); - - } - break; - case 97 : - // InternalRos.g:1:670: RULE_MESSAGE_ASIGMENT - { - mRULE_MESSAGE_ASIGMENT(); - - } - break; - case 98 : - // InternalRos.g:1:692: RULE_ID - { - mRULE_ID(); - - } - break; - case 99 : - // InternalRos.g:1:700: RULE_STRING - { - mRULE_STRING(); - - } - break; - case 100 : - // InternalRos.g:1:712: RULE_ML_COMMENT - { - mRULE_ML_COMMENT(); - - } - break; - case 101 : - // InternalRos.g:1:728: RULE_SL_COMMENT - { - mRULE_SL_COMMENT(); - - } - break; - case 102 : - // InternalRos.g:1:744: RULE_WS - { - mRULE_WS(); - - } - break; - case 103 : - // InternalRos.g:1:752: RULE_ANY_OTHER - { - mRULE_ANY_OTHER(); - - } - break; - - } - - } - - - protected DFA10 dfa10 = new DFA10(this); - protected DFA30 dfa30 = new DFA30(this); - static final String DFA10_eotS = - "\1\uffff\1\4\1\uffff\1\4\1\uffff"; - static final String DFA10_eofS = - "\5\uffff"; - static final String DFA10_minS = - "\1\56\1\60\1\uffff\1\60\1\uffff"; - static final String DFA10_maxS = - "\2\145\1\uffff\1\145\1\uffff"; - static final String DFA10_acceptS = - "\2\uffff\1\2\1\uffff\1\1"; - static final String DFA10_specialS = - "\5\uffff}>"; - static final String[] DFA10_transitionS = { - "\1\1\26\uffff\1\2\37\uffff\1\2", - "\12\3\13\uffff\1\2\37\uffff\1\2", - "", - "\12\3\13\uffff\1\2\37\uffff\1\2", - "" - }; - - static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS); - static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS); - static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS); - static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS); - static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS); - static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS); - static final short[][] DFA10_transition; - - static { - int numStates = DFA10_transitionS.length; - DFA10_transition = new short[numStates][]; - for (int i=0; i"; - static final String[] DFA30_transitionS = { - "\11\56\2\55\2\56\1\55\22\56\1\55\1\56\1\46\4\56\1\47\4\56\1\21\1\53\1\56\1\42\1\51\2\52\7\54\7\56\1\23\1\35\1\24\1\25\1\30\1\22\1\1\1\3\1\34\2\44\1\33\1\44\1\27\1\44\1\16\1\44\1\32\1\4\1\26\6\44\1\41\2\56\1\43\1\44\1\56\1\14\1\36\1\44\1\15\1\44\1\10\1\5\1\44\1\37\3\44\1\6\1\2\1\44\1\31\1\44\1\7\1\12\1\13\1\40\1\11\4\44\1\17\1\56\1\20\1\50\uff81\56", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\60\5\61\1\57\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\65\15\61\1\64\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\66\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\71\12\61\1\70\3\61\1\67\1\72\5\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\73\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\74\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\75\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\100\3\61\1\76\6\61\1\77\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\101\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\102\16\61\1\103\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\105\10\61\1\106\6\61\1\104\1\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\107\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\111\17\61\1\110\5\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\112\20\61\1\114\2\61\1\113\5\61", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\120\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\123\11\61\1\122\4\61\1\121\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\124\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\125\11\61\1\126\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\127\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\130\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\27\61\1\131\2\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\132\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\133\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\134\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\135\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\137\15\61\1\136\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\140\11\61\1\141\1\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\142\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\143\21\61", - "\1\144", - "\1\147\4\uffff\1\147\2\uffff\1\145\4\uffff\1\146\21\uffff\32\45\3\uffff\2\45\1\uffff\32\45", - "\32\150\4\uffff\1\150\1\uffff\32\150", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\42\152\1\153\71\152\1\151\uffa3\152", - "\47\155\1\156\64\155\1\154\uffa3\155", - "\1\147\4\uffff\1\147", - "\1\162\1\uffff\12\160\10\uffff\1\157\2\uffff\1\162\34\uffff\1\157\2\uffff\1\162", - "\1\162\1\uffff\12\163\13\uffff\1\162\37\uffff\1\162", - "\12\164", - "\1\162\1\uffff\12\165\13\uffff\1\162\37\uffff\1\162", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\167\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\170\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\3\61\1\171\26\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\14\61\1\172\15\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\173\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\174\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\175\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\176\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\61\1\177\30\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u0080\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u0081\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\20\61\1\u0083\1\61\1\u0082\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0084\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\u0085\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u0086\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u0087\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u0088\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u0089\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u008a\12\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\14\61\1\u008b\15\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\24\61\1\u008c\5\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u008d\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u008e\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\5\61\1\u008f\24\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u0090\16\61\1\u0091\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\61\1\u0092\30\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u0093\21\61", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\u0094\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u0096\1\61\1\u0095\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0097\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u0098\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u0099\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u009a\12\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\24\61\1\u009b\5\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u009c\12\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\3\61\1\u009d\26\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u009e\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u009f\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u00a0\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u00a1\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u00a2\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\u00a3\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u00a4\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\u00a5\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u00a6\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u00a7\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u00a8\14\61", - "", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\0\u00a9", - "\42\152\1\153\71\152\1\151\uffa3\152", - "\1\147\15\uffff\1\63", - "\0\u00ab", - "\47\155\1\156\64\155\1\154\uffa3\155", - "\1\147\15\uffff\1\63", - "", - "", - "", - "", - "\1\162\1\uffff\12\u00ac\13\uffff\1\162\37\uffff\1\162", - "\1\162\1\uffff\12\u00ad\13\uffff\1\162\37\uffff\1\162", - "\1\162\1\uffff\12\165\13\uffff\1\162\37\uffff\1\162", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u00ae\12\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\61\1\u00af\30\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00b0\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00b1\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\3\61\1\u00b2\26\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u00b3\13\61\1\u00b4\5\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u00b5\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\25\61\1\u00b6\4\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u00b7\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u00b8\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u00b9\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u00bb\4\61\1\u00ba\5\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\24\61\1\u00bc\5\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\3\61\1\u00bd\26\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u00be\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u00bf\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\24\61\1\u00c0\5\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\25\61\1\u00c1\4\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u00c2\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00c3\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00c4\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00c5\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u00c6\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u00c7\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u00c8\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\12\61\1\u00c9\17\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u00ca\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u00cb\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\25\61\1\u00cc\4\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\14\61\1\u00cd\15\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u00ce\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u00cf\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u00d0\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u00d1\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\12\61\1\u00d2\17\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00d3\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\61\1\u00d4\30\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u00d5\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00d6\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00d7\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u00d8\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u00d9\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u00da\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00db\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u00dc\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00dd\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u00de\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00df\25\61", - "\1\45\1\61\1\u00e1\1\61\1\u00e2\2\61\1\u00e3\1\61\1\u00e0\1\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u00e4\6\61", - "\42\152\1\153\71\152\1\151\uffa3\152", - "", - "\47\155\1\156\64\155\1\154\uffa3\155", - "\1\162\1\uffff\12\u00e5\13\uffff\1\162\37\uffff\1\162", - "\1\162\1\uffff\12\u00ad\13\uffff\1\162\37\uffff\1\162", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\7\61\1\u00e6\22\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u00e7\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u00e9\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00eb\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u00ec\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u00ed\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u00ee\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u00ef\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u00f0\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u00f2\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u00f3\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\u00f4\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00f5\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\61\1\u00f6\30\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u00f7\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00f8\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u00f9\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u00fa\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u00fb\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\u00ff\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u0100\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\24\61\1\u0101\5\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u0102\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\14\61\1\u0103\15\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u0104\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u0105\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\6\61\1\u0106\23\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\5\61\1\u0107\24\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\30\61\1\u0108\1\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u0109\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\u010a\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u010b\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u010c\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u010d\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u010e\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u0110\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u0111\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u0112\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\6\61\1\u0114\23\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0115\25\61", - "\1\45\6\61\1\u0116\3\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u0117\3\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u0119\3\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u011b\3\uffff\1\61\1\uffff\32\61", - "\1\45\6\61\1\u011d\3\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\2\61\1\u011e\7\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\4\61\1\u011f\5\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\1\61\1\u0121\1\61\1\u0122\2\61\1\u0123\1\61\1\u0120\1\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\160\1\162\1\uffff\12\165\13\uffff\1\162\37\uffff\1\162", - "\1\45\12\61\3\uffff\1\63\3\uffff\15\61\1\u0124\14\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u0125\16\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u0126\12\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u0127\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\6\61\1\u0128\23\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u0129\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u012b\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u012c\10\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\6\61\1\u012d\23\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u012e\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u012f\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u0130\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u0131\31\61", - "\1\45\3\61\1\u0132\2\61\1\u0133\3\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u0135\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\6\61\1\u0136\23\61", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u0137\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u0138\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u0139\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\6\61\1\u013a\23\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u013b\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u013c\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u013d\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u013e\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u013f\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\17\61\1\u0141\12\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u0142\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u0143\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\3\61\1\u0144\26\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0145\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\22\61\1\u0146\7\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u0147\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u0149\21\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u014a\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u014b\31\61", - "\1\45\4\61\1\u014c\5\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "", - "", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u014d\3\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u014f\3\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u0151\3\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u0153\3\uffff\1\61\1\uffff\32\61", - "\1\45\6\61\1\u0155\3\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\2\61\1\u0156\7\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\4\61\1\u0157\5\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u0158\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\15\61\1\u0159\14\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u015a\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u015e\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u015f\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0160\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u0162\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u0163\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u0164\27\61", - "\1\45\2\61\1\u0165\7\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\4\61\1\u0166\5\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0167\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u0168\3\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\u016b\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u016c\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u016d\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u016e\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\7\61\1\u016f\22\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0170\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u0171\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u0172\27\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u0173\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\2\61\1\u0175\17\61\1\u0174\7\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\17\61\1\u0176\12\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0177\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u0179\12\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u017a\31\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\25\61\1\u017b\4\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u017c\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u017d\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "", - "", - "", - "", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u017f\3\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u0181\3\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u0183\3\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\14\61\1\u0185\15\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u0186\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u0187\27\61", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\2\61\1\u0189\17\61\1\u0188\7\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\61\1\u018a\30\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u018c\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\12\61\1\u018e\17\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u018f\3\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\1\u0191\3\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u0194\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\22\61\1\u0196\7\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0198\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0199\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\15\61\1\u019a\14\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\21\61\1\u019b\10\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u019c\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u019d\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u019f\12\61\1\u019e\12\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u01a0\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u01a1\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u01a2\14\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01a3\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u01a4\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01a5\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "", - "", - "", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01a8\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\14\61\1\u01a9\15\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01aa\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01ac\12\61\1\u01ab\12\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\13\61\1\u01ad\16\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01ae\25\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01b2\25\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u01b3\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u01b4\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u01b5\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01b6\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\12\61\1\u01b8\17\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01b9\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u01ba\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u01bb\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u01bc\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u01bd\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u01be\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\3\61\1\u01bf\26\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\15\61\1\u01c0\14\61\4\uffff\1\61\1\uffff\32\61", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01c2\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01c4\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u01c5\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u01c6\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u01c7\10\61", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u01c8\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\1\u01ca\21\61\1\u01cb\7\61\4\uffff\1\61\1\uffff\22\61\1\u01c9\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u01cd\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\14\61\1\u01cf\15\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u01d0\12\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u01d1\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u01d2\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\25\61\1\u01d3\4\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01d4\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\12\61\1\u01d5\17\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\10\61\1\u01d6\21\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01d8\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u01d9\31\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u01da\7\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u01db\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\25\61\1\u01dc\4\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01dd\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u01de\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u01e2\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u01e3\6\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01e5\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\16\61\1\u01e6\13\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\6\61\1\u01e7\23\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01e9\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u01ea\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u01eb\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01ec\25\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u01ed\12\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\14\61\1\u01ee\15\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u01ef\12\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01f1\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u01f2\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\30\61\1\u01f4\1\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u01f5\10\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u01f6\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01f8\25\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u01f9\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u01fa\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\6\61\1\u01fb\23\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u01fc\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01fd\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u01fe\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u01ff\31\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u0200\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u0201\6\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\24\61\1\u0203\5\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u0204\12\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u0206\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u0208\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u020a\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u020c\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u020d\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u020e\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u020f\7\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\22\61\1\u0211\7\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u0213\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u0214\31\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\3\61\1\u0218\26\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\17\61\1\u0219\12\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u021a\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\23\61\1\u021d\6\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u021e\27\61", - "", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u021f\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\u0220\31\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\14\61\1\u0222\15\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0223\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\15\61\1\u0224\14\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u0225\27\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0226\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\2\61\1\u0228\27\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u0229\25\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\14\61\1\u022a\15\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\30\61\1\u022b\1\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\1\61\1\u022d\30\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\4\61\1\u022f\25\61", - "", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\21\61\1\u0230\10\61", - "\1\45\12\61\3\uffff\1\63\3\uffff\32\61\4\uffff\1\61\1\uffff\32\61", - "" - }; - - static final short[] DFA30_eot = DFA.unpackEncodedString(DFA30_eotS); - static final short[] DFA30_eof = DFA.unpackEncodedString(DFA30_eofS); - static final char[] DFA30_min = DFA.unpackEncodedStringToUnsignedChars(DFA30_minS); - static final char[] DFA30_max = DFA.unpackEncodedStringToUnsignedChars(DFA30_maxS); - static final short[] DFA30_accept = DFA.unpackEncodedString(DFA30_acceptS); - static final short[] DFA30_special = DFA.unpackEncodedString(DFA30_specialS); - static final short[][] DFA30_transition; - - static { - int numStates = DFA30_transitionS.length; - DFA30_transition = new short[numStates][]; - for (int i=0; i='J' && LA30_0<='K')||LA30_0=='M'||LA30_0=='O'||LA30_0=='Q'||(LA30_0>='U' && LA30_0<='Z')||LA30_0=='_'||LA30_0=='c'||LA30_0=='e'||LA30_0=='h'||(LA30_0>='j' && LA30_0<='l')||LA30_0=='o'||LA30_0=='q'||(LA30_0>='w' && LA30_0<='z')) ) {s = 36;} - - else if ( (LA30_0=='\"') ) {s = 38;} - - else if ( (LA30_0=='\'') ) {s = 39;} - - else if ( (LA30_0=='~') ) {s = 40;} - - else if ( (LA30_0=='0') ) {s = 41;} - - else if ( ((LA30_0>='1' && LA30_0<='2')) ) {s = 42;} - - else if ( (LA30_0=='-') ) {s = 43;} - - else if ( ((LA30_0>='3' && LA30_0<='9')) ) {s = 44;} - - else if ( ((LA30_0>='\t' && LA30_0<='\n')||LA30_0=='\r'||LA30_0==' ') ) {s = 45;} - - else if ( ((LA30_0>='\u0000' && LA30_0<='\b')||(LA30_0>='\u000B' && LA30_0<='\f')||(LA30_0>='\u000E' && LA30_0<='\u001F')||LA30_0=='!'||(LA30_0>='#' && LA30_0<='&')||(LA30_0>='(' && LA30_0<='+')||LA30_0=='.'||(LA30_0>=':' && LA30_0<='@')||(LA30_0>='\\' && LA30_0<=']')||LA30_0=='`'||LA30_0=='|'||(LA30_0>='\u007F' && LA30_0<='\uFFFF')) ) {s = 46;} - - else s = 37; - - if ( s>=0 ) return s; - break; - case 1 : - int LA30_39 = input.LA(1); - - s = -1; - if ( (LA30_39=='\\') ) {s = 108;} - - else if ( ((LA30_39>='\u0000' && LA30_39<='&')||(LA30_39>='(' && LA30_39<='[')||(LA30_39>=']' && LA30_39<='\uFFFF')) ) {s = 109;} - - else if ( (LA30_39=='\'') ) {s = 110;} - - else s = 46; - - if ( s>=0 ) return s; - break; - case 2 : - int LA30_105 = input.LA(1); - - s = -1; - if ( ((LA30_105>='\u0000' && LA30_105<='\uFFFF')) ) {s = 169;} - - if ( s>=0 ) return s; - break; - case 3 : - int LA30_171 = input.LA(1); - - s = -1; - if ( (LA30_171=='\'') ) {s = 110;} - - else if ( (LA30_171=='\\') ) {s = 108;} - - else if ( ((LA30_171>='\u0000' && LA30_171<='&')||(LA30_171>='(' && LA30_171<='[')||(LA30_171>=']' && LA30_171<='\uFFFF')) ) {s = 109;} - - if ( s>=0 ) return s; - break; - case 4 : - int LA30_108 = input.LA(1); - - s = -1; - if ( ((LA30_108>='\u0000' && LA30_108<='\uFFFF')) ) {s = 171;} - - if ( s>=0 ) return s; - break; - case 5 : - int LA30_109 = input.LA(1); - - s = -1; - if ( (LA30_109=='\'') ) {s = 110;} - - else if ( (LA30_109=='\\') ) {s = 108;} - - else if ( ((LA30_109>='\u0000' && LA30_109<='&')||(LA30_109>='(' && LA30_109<='[')||(LA30_109>=']' && LA30_109<='\uFFFF')) ) {s = 109;} - - if ( s>=0 ) return s; - break; - case 6 : - int LA30_38 = input.LA(1); - - s = -1; - if ( (LA30_38=='\\') ) {s = 105;} - - else if ( ((LA30_38>='\u0000' && LA30_38<='!')||(LA30_38>='#' && LA30_38<='[')||(LA30_38>=']' && LA30_38<='\uFFFF')) ) {s = 106;} - - else if ( (LA30_38=='\"') ) {s = 107;} - - else s = 46; - - if ( s>=0 ) return s; - break; - case 7 : - int LA30_169 = input.LA(1); - - s = -1; - if ( (LA30_169=='\"') ) {s = 107;} - - else if ( (LA30_169=='\\') ) {s = 105;} - - else if ( ((LA30_169>='\u0000' && LA30_169<='!')||(LA30_169>='#' && LA30_169<='[')||(LA30_169>=']' && LA30_169<='\uFFFF')) ) {s = 106;} - - if ( s>=0 ) return s; - break; - case 8 : - int LA30_106 = input.LA(1); - - s = -1; - if ( (LA30_106=='\"') ) {s = 107;} - - else if ( (LA30_106=='\\') ) {s = 105;} - - else if ( ((LA30_106>='\u0000' && LA30_106<='!')||(LA30_106>='#' && LA30_106<='[')||(LA30_106>=']' && LA30_106<='\uFFFF')) ) {s = 106;} - - if ( s>=0 ) return s; - break; - } - NoViableAltException nvae = - new NoViableAltException(getDescription(), 30, _s, input); - error(nvae); - throw nvae; - } - } - - -} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosParser.g b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosParser.g new file mode 100644 index 000000000..52b57a8a8 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosParser.g @@ -0,0 +1,13683 @@ +/* + * generated by Xtext 2.25.0 + */ +parser grammar InternalRosParser; + +options { + tokenVocab=InternalRosLexer; + superClass=AbstractInternalContentAssistParser; +} + +@header { +package de.fraunhofer.ipa.ros.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.ros.services.RosGrammarAccess; + +} +@members { + private RosGrammarAccess grammarAccess; + private final Map tokenNameToValue = new HashMap(); + + { + tokenNameToValue.put("Comma", "','"); + tokenNameToValue.put("Colon", "':'"); + tokenNameToValue.put("LeftSquareBracket", "'['"); + tokenNameToValue.put("RightSquareBracket", "']'"); + tokenNameToValue.put("RightCurlyBracket", "'}'"); + tokenNameToValue.put("LeftSquareBracketRightSquareBracket", "'[]'"); + tokenNameToValue.put("Any", "'Any'"); + tokenNameToValue.put("Ns", "'ns:'"); + tokenNameToValue.put("Date", "'Date'"); + tokenNameToValue.put("List", "'List'"); + tokenNameToValue.put("Bool", "'bool'"); + tokenNameToValue.put("Byte", "'byte'"); + tokenNameToValue.put("Goal", "'goal'"); + tokenNameToValue.put("Int8", "'int8'"); + tokenNameToValue.put("Msg", "'msg:'"); + tokenNameToValue.put("Name", "'name'"); + tokenNameToValue.put("Node", "'node'"); + tokenNameToValue.put("Srv", "'srv:'"); + tokenNameToValue.put("Time", "'time'"); + tokenNameToValue.put("Type", "'type'"); + tokenNameToValue.put("Goal_1", "'goal:'"); + tokenNameToValue.put("Int16", "'int16'"); + tokenNameToValue.put("Int32", "'int32'"); + tokenNameToValue.put("Int64", "'int64'"); + tokenNameToValue.put("Node_1", "'node:'"); + tokenNameToValue.put("Type_1", "'type:'"); + tokenNameToValue.put("Uint8", "'uint8'"); + tokenNameToValue.put("Value", "'value'"); + tokenNameToValue.put("Array", "'Array:'"); + tokenNameToValue.put("Base64", "'Base64'"); + tokenNameToValue.put("Double", "'Double'"); + tokenNameToValue.put("Header", "'Header'"); + tokenNameToValue.put("String", "'String'"); + tokenNameToValue.put("Struct", "'Struct'"); + tokenNameToValue.put("Action", "'action'"); + tokenNameToValue.put("Bool_1", "'bool[]'"); + tokenNameToValue.put("Byte_1", "'byte[]'"); + tokenNameToValue.put("Int8_1", "'int8[]'"); + tokenNameToValue.put("Result", "'result'"); + tokenNameToValue.put("Specs", "'specs:'"); + tokenNameToValue.put("String_1", "'string'"); + tokenNameToValue.put("Uint16", "'uint16'"); + tokenNameToValue.put("Uint32", "'uint32'"); + tokenNameToValue.put("Uint64", "'uint64'"); + tokenNameToValue.put("Boolean", "'Boolean'"); + tokenNameToValue.put("Integer", "'Integer'"); + tokenNameToValue.put("Action_1", "'action:'"); + tokenNameToValue.put("Default", "'default'"); + tokenNameToValue.put("Float32", "'float32'"); + tokenNameToValue.put("Float64", "'float64'"); + tokenNameToValue.put("Int16_1", "'int16[]'"); + tokenNameToValue.put("Int32_1", "'int32[]'"); + tokenNameToValue.put("Int64_1", "'int64[]'"); + tokenNameToValue.put("Message", "'message'"); + tokenNameToValue.put("Result_1", "'result:'"); + tokenNameToValue.put("Service", "'service'"); + tokenNameToValue.put("Uint8_1", "'uint8[]'"); + tokenNameToValue.put("Duration", "'duration'"); + tokenNameToValue.put("Feedback", "'feedback'"); + tokenNameToValue.put("Message_1", "'message:'"); + tokenNameToValue.put("Request", "'request:'"); + tokenNameToValue.put("String_2", "'string[]'"); + tokenNameToValue.put("Uint16_1", "'uint16[]'"); + tokenNameToValue.put("Uint32_1", "'uint32[]'"); + tokenNameToValue.put("Uint64_1", "'uint64[]'"); + tokenNameToValue.put("GraphName", "'GraphName'"); + tokenNameToValue.put("Feedback_1", "'feedback:'"); + tokenNameToValue.put("Float32_1", "'float32[]'"); + tokenNameToValue.put("Float64_1", "'float64[]'"); + tokenNameToValue.put("Response", "'response:'"); + tokenNameToValue.put("Artifacts", "'artifacts:'"); + tokenNameToValue.put("Parameters", "'parameters:'"); + tokenNameToValue.put("Publishers", "'publishers:'"); + tokenNameToValue.put("AmentPackage", "'AmentPackage'"); + tokenNameToValue.put("ParameterAny", "'ParameterAny'"); + tokenNameToValue.put("FromGitRepo", "'fromGitRepo:'"); + tokenNameToValue.put("Subscribers", "'subscribers:'"); + tokenNameToValue.put("Actionclient", "'actionclient:'"); + tokenNameToValue.put("Actionserver", "'actionserver:'"); + tokenNameToValue.put("Dependencies", "'dependencies:'"); + tokenNameToValue.put("Serviceclient", "'serviceclient:'"); + tokenNameToValue.put("Serviceserver", "'serviceserver:'"); + tokenNameToValue.put("GlobalNamespace", "'GlobalNamespace'"); + tokenNameToValue.put("PrivateNamespace", "'PrivateNamespace'"); + tokenNameToValue.put("RelativeNamespace", "'RelativeNamespace'"); + tokenNameToValue.put("ExternalDependency", "'ExternalDependency'"); + tokenNameToValue.put("ParameterStructMember", "'ParameterStructMember'"); + } + + public void setGrammarAccess(RosGrammarAccess 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 entryRulePackageSet +entryRulePackageSet +: +{ before(grammarAccess.getPackageSetRule()); } + rulePackageSet +{ after(grammarAccess.getPackageSetRule()); } + EOF +; + +// Rule PackageSet +rulePackageSet + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getPackageSetAccess().getGroup()); } + (rule__PackageSet__Group__0) + { after(grammarAccess.getPackageSetAccess().getGroup()); } + ) +; +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); +} + +// 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 entryRulePackage_Impl +entryRulePackage_Impl +: +{ before(grammarAccess.getPackage_ImplRule()); } + rulePackage_Impl +{ after(grammarAccess.getPackage_ImplRule()); } + EOF +; + +// Rule Package_Impl +rulePackage_Impl + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getPackage_ImplAccess().getGroup()); } + (rule__Package_Impl__Group__0) + { after(grammarAccess.getPackage_ImplAccess().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 entryRuleSpecBase +entryRuleSpecBase +: +{ before(grammarAccess.getSpecBaseRule()); } + ruleSpecBase +{ after(grammarAccess.getSpecBaseRule()); } + EOF +; + +// Rule SpecBase +ruleSpecBase + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getSpecBaseAccess().getAlternatives()); } + (rule__SpecBase__Alternatives) + { after(grammarAccess.getSpecBaseAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleTopicSpec +entryRuleTopicSpec +: +{ before(grammarAccess.getTopicSpecRule()); } + ruleTopicSpec +{ after(grammarAccess.getTopicSpecRule()); } + EOF +; + +// Rule TopicSpec +ruleTopicSpec + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getTopicSpecAccess().getGroup()); } + (rule__TopicSpec__Group__0) + { after(grammarAccess.getTopicSpecAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleServiceSpec +entryRuleServiceSpec +: +{ before(grammarAccess.getServiceSpecRule()); } + ruleServiceSpec +{ after(grammarAccess.getServiceSpecRule()); } + EOF +; + +// Rule ServiceSpec +ruleServiceSpec + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getServiceSpecAccess().getGroup()); } + (rule__ServiceSpec__Group__0) + { after(grammarAccess.getServiceSpecAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleActionSpec +entryRuleActionSpec +: +{ before(grammarAccess.getActionSpecRule()); } + ruleActionSpec +{ after(grammarAccess.getActionSpecRule()); } + EOF +; + +// Rule ActionSpec +ruleActionSpec + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getActionSpecAccess().getGroup()); } + (rule__ActionSpec__Group__0) + { after(grammarAccess.getActionSpecAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleMessageDefinition +entryRuleMessageDefinition +: +{ before(grammarAccess.getMessageDefinitionRule()); } + ruleMessageDefinition +{ after(grammarAccess.getMessageDefinitionRule()); } + EOF +; + +// Rule MessageDefinition +ruleMessageDefinition + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getMessageDefinitionAccess().getGroup()); } + (rule__MessageDefinition__Group__0) + { after(grammarAccess.getMessageDefinitionAccess().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 entryRuleServiceServer +entryRuleServiceServer +: +{ before(grammarAccess.getServiceServerRule()); } + ruleServiceServer +{ after(grammarAccess.getServiceServerRule()); } + EOF +; + +// Rule ServiceServer +ruleServiceServer + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getServiceServerAccess().getGroup()); } + (rule__ServiceServer__Group__0) + { after(grammarAccess.getServiceServerAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleServiceClient +entryRuleServiceClient +: +{ before(grammarAccess.getServiceClientRule()); } + ruleServiceClient +{ after(grammarAccess.getServiceClientRule()); } + EOF +; + +// Rule ServiceClient +ruleServiceClient + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getServiceClientAccess().getGroup()); } + (rule__ServiceClient__Group__0) + { after(grammarAccess.getServiceClientAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleActionServer +entryRuleActionServer +: +{ before(grammarAccess.getActionServerRule()); } + ruleActionServer +{ after(grammarAccess.getActionServerRule()); } + EOF +; + +// Rule ActionServer +ruleActionServer + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getActionServerAccess().getGroup()); } + (rule__ActionServer__Group__0) + { after(grammarAccess.getActionServerAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleActionClient +entryRuleActionClient +: +{ before(grammarAccess.getActionClientRule()); } + ruleActionClient +{ after(grammarAccess.getActionClientRule()); } + EOF +; + +// Rule ActionClient +ruleActionClient + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getActionClientAccess().getGroup()); } + (rule__ActionClient__Group__0) + { after(grammarAccess.getActionClientAccess().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 entryRuleNamespace +entryRuleNamespace +: +{ before(grammarAccess.getNamespaceRule()); } + ruleNamespace +{ after(grammarAccess.getNamespaceRule()); } + EOF +; + +// Rule Namespace +ruleNamespace + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getNamespaceAccess().getAlternatives()); } + (rule__Namespace__Alternatives) + { after(grammarAccess.getNamespaceAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleGraphName +entryRuleGraphName +: +{ before(grammarAccess.getGraphNameRule()); } + ruleGraphName +{ after(grammarAccess.getGraphNameRule()); } + EOF +; + +// Rule GraphName +ruleGraphName + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); } + GraphName + { after(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleGlobalNamespace +entryRuleGlobalNamespace +: +{ before(grammarAccess.getGlobalNamespaceRule()); } + ruleGlobalNamespace +{ after(grammarAccess.getGlobalNamespaceRule()); } + EOF +; + +// Rule GlobalNamespace +ruleGlobalNamespace + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getGlobalNamespaceAccess().getGroup()); } + (rule__GlobalNamespace__Group__0) + { after(grammarAccess.getGlobalNamespaceAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleRelativeNamespace_Impl +entryRuleRelativeNamespace_Impl +: +{ before(grammarAccess.getRelativeNamespace_ImplRule()); } + ruleRelativeNamespace_Impl +{ after(grammarAccess.getRelativeNamespace_ImplRule()); } + EOF +; + +// Rule RelativeNamespace_Impl +ruleRelativeNamespace_Impl + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup()); } + (rule__RelativeNamespace_Impl__Group__0) + { after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulePrivateNamespace +entryRulePrivateNamespace +: +{ before(grammarAccess.getPrivateNamespaceRule()); } + rulePrivateNamespace +{ after(grammarAccess.getPrivateNamespaceRule()); } + EOF +; + +// Rule PrivateNamespace +rulePrivateNamespace + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getPrivateNamespaceAccess().getGroup()); } + (rule__PrivateNamespace__Group__0) + { after(grammarAccess.getPrivateNamespaceAccess().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 entryRuleParameterType +entryRuleParameterType +: +{ before(grammarAccess.getParameterTypeRule()); } + ruleParameterType +{ after(grammarAccess.getParameterTypeRule()); } + EOF +; + +// Rule ParameterType +ruleParameterType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterTypeAccess().getAlternatives()); } + (rule__ParameterType__Alternatives) + { after(grammarAccess.getParameterTypeAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterValue +entryRuleParameterValue +: +{ before(grammarAccess.getParameterValueRule()); } + ruleParameterValue +{ after(grammarAccess.getParameterValueRule()); } + EOF +; + +// Rule ParameterValue +ruleParameterValue + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterValueAccess().getAlternatives()); } + (rule__ParameterValue__Alternatives) + { after(grammarAccess.getParameterValueAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterListType +entryRuleParameterListType +: +{ before(grammarAccess.getParameterListTypeRule()); } + ruleParameterListType +{ after(grammarAccess.getParameterListTypeRule()); } + EOF +; + +// Rule ParameterListType +ruleParameterListType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterListTypeAccess().getGroup()); } + (rule__ParameterListType__Group__0) + { after(grammarAccess.getParameterListTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterStructType +entryRuleParameterStructType +: +{ before(grammarAccess.getParameterStructTypeRule()); } + ruleParameterStructType +{ after(grammarAccess.getParameterStructTypeRule()); } + EOF +; + +// Rule ParameterStructType +ruleParameterStructType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStructTypeAccess().getGroup()); } + (rule__ParameterStructType__Group__0) + { after(grammarAccess.getParameterStructTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterIntegerType +entryRuleParameterIntegerType +: +{ before(grammarAccess.getParameterIntegerTypeRule()); } + ruleParameterIntegerType +{ after(grammarAccess.getParameterIntegerTypeRule()); } + EOF +; + +// Rule ParameterIntegerType +ruleParameterIntegerType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterIntegerTypeAccess().getGroup()); } + (rule__ParameterIntegerType__Group__0) + { after(grammarAccess.getParameterIntegerTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterStringType +entryRuleParameterStringType +: +{ before(grammarAccess.getParameterStringTypeRule()); } + ruleParameterStringType +{ after(grammarAccess.getParameterStringTypeRule()); } + EOF +; + +// Rule ParameterStringType +ruleParameterStringType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStringTypeAccess().getGroup()); } + (rule__ParameterStringType__Group__0) + { after(grammarAccess.getParameterStringTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterDoubleType +entryRuleParameterDoubleType +: +{ before(grammarAccess.getParameterDoubleTypeRule()); } + ruleParameterDoubleType +{ after(grammarAccess.getParameterDoubleTypeRule()); } + EOF +; + +// Rule ParameterDoubleType +ruleParameterDoubleType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterDoubleTypeAccess().getGroup()); } + (rule__ParameterDoubleType__Group__0) + { after(grammarAccess.getParameterDoubleTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterBooleanType +entryRuleParameterBooleanType +: +{ before(grammarAccess.getParameterBooleanTypeRule()); } + ruleParameterBooleanType +{ after(grammarAccess.getParameterBooleanTypeRule()); } + EOF +; + +// Rule ParameterBooleanType +ruleParameterBooleanType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterBooleanTypeAccess().getGroup()); } + (rule__ParameterBooleanType__Group__0) + { after(grammarAccess.getParameterBooleanTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterBase64Type +entryRuleParameterBase64Type +: +{ before(grammarAccess.getParameterBase64TypeRule()); } + ruleParameterBase64Type +{ after(grammarAccess.getParameterBase64TypeRule()); } + EOF +; + +// Rule ParameterBase64Type +ruleParameterBase64Type + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterBase64TypeAccess().getGroup()); } + (rule__ParameterBase64Type__Group__0) + { after(grammarAccess.getParameterBase64TypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterArrayType +entryRuleParameterArrayType +: +{ before(grammarAccess.getParameterArrayTypeRule()); } + ruleParameterArrayType +{ after(grammarAccess.getParameterArrayTypeRule()); } + EOF +; + +// Rule ParameterArrayType +ruleParameterArrayType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterArrayTypeAccess().getGroup()); } + (rule__ParameterArrayType__Group__0) + { after(grammarAccess.getParameterArrayTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterList +entryRuleParameterList +: +{ before(grammarAccess.getParameterListRule()); } + ruleParameterList +{ after(grammarAccess.getParameterListRule()); } + EOF +; + +// Rule ParameterList +ruleParameterList + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterListAccess().getGroup()); } + (rule__ParameterList__Group__0) + { after(grammarAccess.getParameterListAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterAny +entryRuleParameterAny +: +{ before(grammarAccess.getParameterAnyRule()); } + ruleParameterAny +{ after(grammarAccess.getParameterAnyRule()); } + EOF +; + +// Rule ParameterAny +ruleParameterAny + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterAnyAccess().getGroup()); } + (rule__ParameterAny__Group__0) + { after(grammarAccess.getParameterAnyAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterString +entryRuleParameterString +: +{ before(grammarAccess.getParameterStringRule()); } + ruleParameterString +{ after(grammarAccess.getParameterStringRule()); } + EOF +; + +// Rule ParameterString +ruleParameterString + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStringAccess().getValueAssignment()); } + (rule__ParameterString__ValueAssignment) + { after(grammarAccess.getParameterStringAccess().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterBase64 +entryRuleParameterBase64 +: +{ before(grammarAccess.getParameterBase64Rule()); } + ruleParameterBase64 +{ after(grammarAccess.getParameterBase64Rule()); } + EOF +; + +// Rule ParameterBase64 +ruleParameterBase64 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterBase64Access().getValueAssignment()); } + (rule__ParameterBase64__ValueAssignment) + { after(grammarAccess.getParameterBase64Access().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterInteger +entryRuleParameterInteger +: +{ before(grammarAccess.getParameterIntegerRule()); } + ruleParameterInteger +{ after(grammarAccess.getParameterIntegerRule()); } + EOF +; + +// Rule ParameterInteger +ruleParameterInteger + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterIntegerAccess().getValueAssignment()); } + (rule__ParameterInteger__ValueAssignment) + { after(grammarAccess.getParameterIntegerAccess().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterDouble +entryRuleParameterDouble +: +{ before(grammarAccess.getParameterDoubleRule()); } + ruleParameterDouble +{ after(grammarAccess.getParameterDoubleRule()); } + EOF +; + +// Rule ParameterDouble +ruleParameterDouble + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterDoubleAccess().getValueAssignment()); } + (rule__ParameterDouble__ValueAssignment) + { after(grammarAccess.getParameterDoubleAccess().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterBoolean +entryRuleParameterBoolean +: +{ before(grammarAccess.getParameterBooleanRule()); } + ruleParameterBoolean +{ after(grammarAccess.getParameterBooleanRule()); } + EOF +; + +// Rule ParameterBoolean +ruleParameterBoolean + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterBooleanAccess().getValueAssignment()); } + (rule__ParameterBoolean__ValueAssignment) + { after(grammarAccess.getParameterBooleanAccess().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterStruct +entryRuleParameterStruct +: +{ before(grammarAccess.getParameterStructRule()); } + ruleParameterStruct +{ after(grammarAccess.getParameterStructRule()); } + EOF +; + +// Rule ParameterStruct +ruleParameterStruct + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStructAccess().getGroup()); } + (rule__ParameterStruct__Group__0) + { after(grammarAccess.getParameterStructAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterDate +entryRuleParameterDate +: +{ before(grammarAccess.getParameterDateRule()); } + ruleParameterDate +{ after(grammarAccess.getParameterDateRule()); } + EOF +; + +// Rule ParameterDate +ruleParameterDate + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterDateAccess().getValueAssignment()); } + (rule__ParameterDate__ValueAssignment) + { after(grammarAccess.getParameterDateAccess().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterStructMember +entryRuleParameterStructMember +: +{ before(grammarAccess.getParameterStructMemberRule()); } + ruleParameterStructMember +{ after(grammarAccess.getParameterStructMemberRule()); } + EOF +; + +// Rule ParameterStructMember +ruleParameterStructMember + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStructMemberAccess().getGroup()); } + (rule__ParameterStructMember__Group__0) + { after(grammarAccess.getParameterStructMemberAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterStructTypeMember +entryRuleParameterStructTypeMember +: +{ before(grammarAccess.getParameterStructTypeMemberRule()); } + ruleParameterStructTypeMember +{ after(grammarAccess.getParameterStructTypeMemberRule()); } + EOF +; + +// Rule ParameterStructTypeMember +ruleParameterStructTypeMember + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStructTypeMemberAccess().getGroup()); } + (rule__ParameterStructTypeMember__Group__0) + { after(grammarAccess.getParameterStructTypeMemberAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleBase64Binary +entryRuleBase64Binary +: +{ before(grammarAccess.getBase64BinaryRule()); } + ruleBase64Binary +{ after(grammarAccess.getBase64BinaryRule()); } + EOF +; + +// Rule Base64Binary +ruleBase64Binary + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); } + RULE_BINARY + { after(grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleboolean0 +entryRuleboolean0 +: +{ before(grammarAccess.getBoolean0Rule()); } + ruleboolean0 +{ after(grammarAccess.getBoolean0Rule()); } + EOF +; + +// Rule boolean0 +ruleboolean0 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); } + RULE_BOOLEAN + { after(grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleDouble0 +entryRuleDouble0 +: +{ before(grammarAccess.getDouble0Rule()); } + ruleDouble0 +{ after(grammarAccess.getDouble0Rule()); } + EOF +; + +// Rule Double0 +ruleDouble0 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); } + RULE_DOUBLE + { after(grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleInteger0 +entryRuleInteger0 +: +{ before(grammarAccess.getInteger0Rule()); } + ruleInteger0 +{ after(grammarAccess.getInteger0Rule()); } + EOF +; + +// Rule Integer0 +ruleInteger0 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); } + RULE_DECINT + { after(grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleDateTime0 +entryRuleDateTime0 +: +{ before(grammarAccess.getDateTime0Rule()); } + ruleDateTime0 +{ after(grammarAccess.getDateTime0Rule()); } + EOF +; + +// Rule DateTime0 +ruleDateTime0 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); } + RULE_DATE_TIME + { after(grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleMessagePart +entryRuleMessagePart +: +{ before(grammarAccess.getMessagePartRule()); } + ruleMessagePart +{ after(grammarAccess.getMessagePartRule()); } + EOF +; + +// Rule MessagePart +ruleMessagePart + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getMessagePartAccess().getGroup()); } + (rule__MessagePart__Group__0) + { after(grammarAccess.getMessagePartAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleAbstractType +entryRuleAbstractType +: +{ before(grammarAccess.getAbstractTypeRule()); } + ruleAbstractType +{ after(grammarAccess.getAbstractTypeRule()); } + EOF +; + +// Rule AbstractType +ruleAbstractType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getAbstractTypeAccess().getAlternatives()); } + (rule__AbstractType__Alternatives) + { after(grammarAccess.getAbstractTypeAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulebool +entryRulebool +: +{ before(grammarAccess.getBoolRule()); } + rulebool +{ after(grammarAccess.getBoolRule()); } + EOF +; + +// Rule bool +rulebool + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getBoolAccess().getGroup()); } + (rule__Bool__Group__0) + { after(grammarAccess.getBoolAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint8 +entryRuleint8 +: +{ before(grammarAccess.getInt8Rule()); } + ruleint8 +{ after(grammarAccess.getInt8Rule()); } + EOF +; + +// Rule int8 +ruleint8 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt8Access().getGroup()); } + (rule__Int8__Group__0) + { after(grammarAccess.getInt8Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint8 +entryRuleuint8 +: +{ before(grammarAccess.getUint8Rule()); } + ruleuint8 +{ after(grammarAccess.getUint8Rule()); } + EOF +; + +// Rule uint8 +ruleuint8 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint8Access().getGroup()); } + (rule__Uint8__Group__0) + { after(grammarAccess.getUint8Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint16 +entryRuleint16 +: +{ before(grammarAccess.getInt16Rule()); } + ruleint16 +{ after(grammarAccess.getInt16Rule()); } + EOF +; + +// Rule int16 +ruleint16 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt16Access().getGroup()); } + (rule__Int16__Group__0) + { after(grammarAccess.getInt16Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint16 +entryRuleuint16 +: +{ before(grammarAccess.getUint16Rule()); } + ruleuint16 +{ after(grammarAccess.getUint16Rule()); } + EOF +; + +// Rule uint16 +ruleuint16 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint16Access().getGroup()); } + (rule__Uint16__Group__0) + { after(grammarAccess.getUint16Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint32 +entryRuleint32 +: +{ before(grammarAccess.getInt32Rule()); } + ruleint32 +{ after(grammarAccess.getInt32Rule()); } + EOF +; + +// Rule int32 +ruleint32 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt32Access().getGroup()); } + (rule__Int32__Group__0) + { after(grammarAccess.getInt32Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint32 +entryRuleuint32 +: +{ before(grammarAccess.getUint32Rule()); } + ruleuint32 +{ after(grammarAccess.getUint32Rule()); } + EOF +; + +// Rule uint32 +ruleuint32 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint32Access().getGroup()); } + (rule__Uint32__Group__0) + { after(grammarAccess.getUint32Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint64 +entryRuleint64 +: +{ before(grammarAccess.getInt64Rule()); } + ruleint64 +{ after(grammarAccess.getInt64Rule()); } + EOF +; + +// Rule int64 +ruleint64 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt64Access().getGroup()); } + (rule__Int64__Group__0) + { after(grammarAccess.getInt64Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint64 +entryRuleuint64 +: +{ before(grammarAccess.getUint64Rule()); } + ruleuint64 +{ after(grammarAccess.getUint64Rule()); } + EOF +; + +// Rule uint64 +ruleuint64 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint64Access().getGroup()); } + (rule__Uint64__Group__0) + { after(grammarAccess.getUint64Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulefloat32 +entryRulefloat32 +: +{ before(grammarAccess.getFloat32Rule()); } + rulefloat32 +{ after(grammarAccess.getFloat32Rule()); } + EOF +; + +// Rule float32 +rulefloat32 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFloat32Access().getGroup()); } + (rule__Float32__Group__0) + { after(grammarAccess.getFloat32Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulefloat64 +entryRulefloat64 +: +{ before(grammarAccess.getFloat64Rule()); } + rulefloat64 +{ after(grammarAccess.getFloat64Rule()); } + EOF +; + +// Rule float64 +rulefloat64 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFloat64Access().getGroup()); } + (rule__Float64__Group__0) + { after(grammarAccess.getFloat64Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulestring0 +entryRulestring0 +: +{ before(grammarAccess.getString0Rule()); } + rulestring0 +{ after(grammarAccess.getString0Rule()); } + EOF +; + +// Rule string0 +rulestring0 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getString0Access().getGroup()); } + (rule__String0__Group__0) + { after(grammarAccess.getString0Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulebyte +entryRulebyte +: +{ before(grammarAccess.getByteRule()); } + rulebyte +{ after(grammarAccess.getByteRule()); } + EOF +; + +// Rule byte +rulebyte + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getByteAccess().getGroup()); } + (rule__Byte__Group__0) + { after(grammarAccess.getByteAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuletime +entryRuletime +: +{ before(grammarAccess.getTimeRule()); } + ruletime +{ after(grammarAccess.getTimeRule()); } + EOF +; + +// Rule time +ruletime + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getTimeAccess().getGroup()); } + (rule__Time__Group__0) + { after(grammarAccess.getTimeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleduration +entryRuleduration +: +{ before(grammarAccess.getDurationRule()); } + ruleduration +{ after(grammarAccess.getDurationRule()); } + EOF +; + +// Rule duration +ruleduration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getDurationAccess().getGroup()); } + (rule__Duration__Group__0) + { after(grammarAccess.getDurationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleboolArray +entryRuleboolArray +: +{ before(grammarAccess.getBoolArrayRule()); } + ruleboolArray +{ after(grammarAccess.getBoolArrayRule()); } + EOF +; + +// Rule boolArray +ruleboolArray + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getBoolArrayAccess().getGroup()); } + (rule__BoolArray__Group__0) + { after(grammarAccess.getBoolArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint8Array +entryRuleint8Array +: +{ before(grammarAccess.getInt8ArrayRule()); } + ruleint8Array +{ after(grammarAccess.getInt8ArrayRule()); } + EOF +; + +// Rule int8Array +ruleint8Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt8ArrayAccess().getGroup()); } + (rule__Int8Array__Group__0) + { after(grammarAccess.getInt8ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint8Array +entryRuleuint8Array +: +{ before(grammarAccess.getUint8ArrayRule()); } + ruleuint8Array +{ after(grammarAccess.getUint8ArrayRule()); } + EOF +; + +// Rule uint8Array +ruleuint8Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint8ArrayAccess().getGroup()); } + (rule__Uint8Array__Group__0) + { after(grammarAccess.getUint8ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint16Array +entryRuleint16Array +: +{ before(grammarAccess.getInt16ArrayRule()); } + ruleint16Array +{ after(grammarAccess.getInt16ArrayRule()); } + EOF +; + +// Rule int16Array +ruleint16Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt16ArrayAccess().getGroup()); } + (rule__Int16Array__Group__0) + { after(grammarAccess.getInt16ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint16Array +entryRuleuint16Array +: +{ before(grammarAccess.getUint16ArrayRule()); } + ruleuint16Array +{ after(grammarAccess.getUint16ArrayRule()); } + EOF +; + +// Rule uint16Array +ruleuint16Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint16ArrayAccess().getGroup()); } + (rule__Uint16Array__Group__0) + { after(grammarAccess.getUint16ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint32Array +entryRuleint32Array +: +{ before(grammarAccess.getInt32ArrayRule()); } + ruleint32Array +{ after(grammarAccess.getInt32ArrayRule()); } + EOF +; + +// Rule int32Array +ruleint32Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt32ArrayAccess().getGroup()); } + (rule__Int32Array__Group__0) + { after(grammarAccess.getInt32ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint32Array +entryRuleuint32Array +: +{ before(grammarAccess.getUint32ArrayRule()); } + ruleuint32Array +{ after(grammarAccess.getUint32ArrayRule()); } + EOF +; + +// Rule uint32Array +ruleuint32Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint32ArrayAccess().getGroup()); } + (rule__Uint32Array__Group__0) + { after(grammarAccess.getUint32ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint64Array +entryRuleint64Array +: +{ before(grammarAccess.getInt64ArrayRule()); } + ruleint64Array +{ after(grammarAccess.getInt64ArrayRule()); } + EOF +; + +// Rule int64Array +ruleint64Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt64ArrayAccess().getGroup()); } + (rule__Int64Array__Group__0) + { after(grammarAccess.getInt64ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint64Array +entryRuleuint64Array +: +{ before(grammarAccess.getUint64ArrayRule()); } + ruleuint64Array +{ after(grammarAccess.getUint64ArrayRule()); } + EOF +; + +// Rule uint64Array +ruleuint64Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint64ArrayAccess().getGroup()); } + (rule__Uint64Array__Group__0) + { after(grammarAccess.getUint64ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulefloat32Array +entryRulefloat32Array +: +{ before(grammarAccess.getFloat32ArrayRule()); } + rulefloat32Array +{ after(grammarAccess.getFloat32ArrayRule()); } + EOF +; + +// Rule float32Array +rulefloat32Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFloat32ArrayAccess().getGroup()); } + (rule__Float32Array__Group__0) + { after(grammarAccess.getFloat32ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulefloat64Array +entryRulefloat64Array +: +{ before(grammarAccess.getFloat64ArrayRule()); } + rulefloat64Array +{ after(grammarAccess.getFloat64ArrayRule()); } + EOF +; + +// Rule float64Array +rulefloat64Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFloat64ArrayAccess().getGroup()); } + (rule__Float64Array__Group__0) + { after(grammarAccess.getFloat64ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulestring0Array +entryRulestring0Array +: +{ before(grammarAccess.getString0ArrayRule()); } + rulestring0Array +{ after(grammarAccess.getString0ArrayRule()); } + EOF +; + +// Rule string0Array +rulestring0Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getString0ArrayAccess().getGroup()); } + (rule__String0Array__Group__0) + { after(grammarAccess.getString0ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulebyteArray +entryRulebyteArray +: +{ before(grammarAccess.getByteArrayRule()); } + rulebyteArray +{ after(grammarAccess.getByteArrayRule()); } + EOF +; + +// Rule byteArray +rulebyteArray + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getByteArrayAccess().getGroup()); } + (rule__ByteArray__Group__0) + { after(grammarAccess.getByteArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleHeader +entryRuleHeader +: +{ before(grammarAccess.getHeaderRule()); } + ruleHeader +{ after(grammarAccess.getHeaderRule()); } + EOF +; + +// Rule Header +ruleHeader + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getHeaderAccess().getGroup()); } + (rule__Header__Group__0) + { after(grammarAccess.getHeaderAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleTopicSpecRef +entryRuleTopicSpecRef +: +{ before(grammarAccess.getTopicSpecRefRule()); } + ruleTopicSpecRef +{ after(grammarAccess.getTopicSpecRefRule()); } + EOF +; + +// Rule TopicSpecRef +ruleTopicSpecRef + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getTopicSpecRefAccess().getTopicSpecAssignment()); } + (rule__TopicSpecRef__TopicSpecAssignment) + { after(grammarAccess.getTopicSpecRefAccess().getTopicSpecAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleArrayTopicSpecRef +entryRuleArrayTopicSpecRef +: +{ before(grammarAccess.getArrayTopicSpecRefRule()); } + ruleArrayTopicSpecRef +{ after(grammarAccess.getArrayTopicSpecRefRule()); } + EOF +; + +// Rule ArrayTopicSpecRef +ruleArrayTopicSpecRef + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getArrayTopicSpecRefAccess().getGroup()); } + (rule__ArrayTopicSpecRef__Group__0) + { after(grammarAccess.getArrayTopicSpecRefAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleKEYWORD +entryRuleKEYWORD +: +{ before(grammarAccess.getKEYWORDRule()); } + ruleKEYWORD +{ after(grammarAccess.getKEYWORDRule()); } + EOF +; + +// Rule KEYWORD +ruleKEYWORD + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getKEYWORDAccess().getAlternatives()); } + (rule__KEYWORD__Alternatives) + { after(grammarAccess.getKEYWORDAccess().getAlternatives()); } + ) +; +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__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__Node__Alternatives_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getGroup_3_0()); } + (rule__Node__Group_3_0__0) + { after(grammarAccess.getNodeAccess().getGroup_3_0()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_1()); } + (rule__Node__Group_3_1__0) + { after(grammarAccess.getNodeAccess().getGroup_3_1()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_2()); } + (rule__Node__Group_3_2__0) + { after(grammarAccess.getNodeAccess().getGroup_3_2()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_3()); } + (rule__Node__Group_3_3__0) + { after(grammarAccess.getNodeAccess().getGroup_3_3()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_4()); } + (rule__Node__Group_3_4__0) + { after(grammarAccess.getNodeAccess().getGroup_3_4()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_5()); } + (rule__Node__Group_3_5__0) + { after(grammarAccess.getNodeAccess().getGroup_3_5()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_6()); } + (rule__Node__Group_3_6__0) + { after(grammarAccess.getNodeAccess().getGroup_3_6()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__SpecBase__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); } + ruleTopicSpec + { after(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); } + ruleServiceSpec + { after(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); } + ruleActionSpec + { after(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__NameAlternatives_2_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); } + ruleEString + { after(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); } + ) + | + ( + { before(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); } + Header + { after(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); } + ) + | + ( + { before(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); } + String + { after(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); } + ) +; +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__Namespace__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); } + ruleGlobalNamespace + { after(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); } + ruleRelativeNamespace_Impl + { after(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); } + rulePrivateNamespace + { after(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterType__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); } + ruleParameterListType + { after(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); } + ruleParameterStructType + { after(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); } + ruleParameterIntegerType + { after(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); } + ruleParameterStringType + { after(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); } + ruleParameterDoubleType + { after(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); } + ruleParameterBooleanType + { after(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); } + ruleParameterBase64Type + { after(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); } + ruleParameterArrayType + { after(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterValue__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); } + ruleParameterString + { after(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); } + ruleParameterBase64 + { after(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); } + ruleParameterInteger + { after(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); } + ruleParameterDouble + { after(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); } + ruleParameterBoolean + { after(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); } + ruleParameterList + { after(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); } + ruleParameterStruct + { after(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__DataAlternatives_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); } + ruleKEYWORD + { after(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); } + ) + | + ( + { before(grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); } + RULE_MESSAGE_ASIGMENT + { after(grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); } + ) + | + ( + { before(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); } + ruleEString + { after(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__AbstractType__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); } + rulebool + { after(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); } + ruleint8 + { after(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); } + ruleuint8 + { after(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); } + ruleint16 + { after(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); } + ruleuint16 + { after(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); } + ruleint32 + { after(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); } + ruleuint32 + { after(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); } + ruleint64 + { after(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); } + ruleuint64 + { after(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); } + rulefloat32 + { after(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); } + rulefloat64 + { after(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); } + rulestring0 + { after(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); } + rulebyte + { after(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); } + ruletime + { after(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); } + ruleduration + { after(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); } + ruleHeader + { after(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); } + ruleboolArray + { after(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); } + ruleint8Array + { after(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); } + ruleuint8Array + { after(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); } + ruleint16Array + { after(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); } + ruleuint16Array + { after(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); } + ruleint32Array + { after(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); } + ruleuint32Array + { after(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); } + ruleint64Array + { after(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); } + ruleuint64Array + { after(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); } + rulefloat32Array + { after(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); } + rulefloat64Array + { after(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); } + rulestring0Array + { after(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); } + rulebyteArray + { after(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); } + ruleTopicSpecRef + { after(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); } + ruleArrayTopicSpecRef + { after(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__KEYWORD__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); } + Goal + { after(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); } + Message + { after(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); } + Result + { after(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); } + Feedback + { after(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); } + Name + { after(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); } + Value + { after(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); } + Service + { after(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); } + Type + { after(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); } + Action + { after(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); } + Duration + { after(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); } + Time + { after(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PackageSet__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PackageSet__Group__0__Impl + rule__PackageSet__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PackageSet__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackageSetAccess().getPackageSetAction_0()); } + () + { after(grammarAccess.getPackageSetAccess().getPackageSetAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PackageSet__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PackageSet__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PackageSet__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackageSetAccess().getPackageAssignment_1()); } + (rule__PackageSet__PackageAssignment_1)* + { after(grammarAccess.getPackageSetAccess().getPackageAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Package_Impl__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__0__Impl + rule__Package_Impl__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); } + () + { after(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__1__Impl + rule__Package_Impl__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); } + (rule__Package_Impl__NameAssignment_1) + { after(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__2__Impl + rule__Package_Impl__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__3__Impl + rule__Package_Impl__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__4__Impl + rule__Package_Impl__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getGroup_4()); } + (rule__Package_Impl__Group_4__0)? + { after(grammarAccess.getPackage_ImplAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__5__Impl + rule__Package_Impl__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getGroup_5()); } + (rule__Package_Impl__Group_5__0)? + { after(grammarAccess.getPackage_ImplAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__6__Impl + rule__Package_Impl__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getGroup_6()); } + (rule__Package_Impl__Group_6__0)? + { after(grammarAccess.getPackage_ImplAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Package_Impl__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_4__0__Impl + rule__Package_Impl__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); } + FromGitRepo + { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); } + (rule__Package_Impl__FromGitRepoAssignment_4_1) + { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Package_Impl__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_5__0__Impl + rule__Package_Impl__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); } + Specs + { after(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_5__1__Impl + rule__Package_Impl__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); } + RULE_BEGIN + { after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_5__2__Impl + rule__Package_Impl__Group_5__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); } + (rule__Package_Impl__SpecAssignment_5_2)* + { after(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_5__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); } + RULE_END + { after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Package_Impl__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6__0__Impl + rule__Package_Impl__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); } + Dependencies + { after(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6__1__Impl + rule__Package_Impl__Group_6__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); } + LeftSquareBracket + { after(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6__2__Impl + rule__Package_Impl__Group_6__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); } + (rule__Package_Impl__DependencyAssignment_6_2) + { after(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6__3__Impl + rule__Package_Impl__Group_6__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); } + (rule__Package_Impl__Group_6_3__0)* + { after(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); } + RightSquareBracket + { after(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Package_Impl__Group_6_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6_3__0__Impl + rule__Package_Impl__Group_6_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); } + Comma + { after(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1()); } + (rule__Package_Impl__DependencyAssignment_6_3_1) + { after(grammarAccess.getPackage_ImplAccess().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().getAlternatives_3()); } + (rule__Node__Alternatives_3)* + { after(grammarAccess.getNodeAccess().getAlternatives_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_0__0__Impl + rule__Node__Group_3_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); } + Publishers + { after(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_0__1__Impl + rule__Node__Group_3_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_0__2__Impl + rule__Node__Group_3_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); } + (rule__Node__PublisherAssignment_3_0_2)* + { after(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_0__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_1__0__Impl + rule__Node__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); } + Subscribers + { after(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_1__1__Impl + rule__Node__Group_3_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_1__2__Impl + rule__Node__Group_3_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); } + (rule__Node__SubscriberAssignment_3_1_2)* + { after(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_1__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_2__0__Impl + rule__Node__Group_3_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); } + Serviceserver + { after(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_2__1__Impl + rule__Node__Group_3_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_2__2__Impl + rule__Node__Group_3_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); } + (rule__Node__ServiceserverAssignment_3_2_2)* + { after(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_2__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_3__0__Impl + rule__Node__Group_3_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); } + Serviceclient + { after(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_3__1__Impl + rule__Node__Group_3_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_3__2__Impl + rule__Node__Group_3_3__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); } + (rule__Node__ServiceclientAssignment_3_3_2)* + { after(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_3__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_4__0__Impl + rule__Node__Group_3_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); } + Actionserver + { after(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_4__1__Impl + rule__Node__Group_3_4__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_4__2__Impl + rule__Node__Group_3_4__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); } + (rule__Node__ActionserverAssignment_3_4_2)* + { after(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_4__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_5__0__Impl + rule__Node__Group_3_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); } + Actionclient + { after(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_5__1__Impl + rule__Node__Group_3_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_5__2__Impl + rule__Node__Group_3_5__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); } + (rule__Node__ActionclientAssignment_3_5_2)* + { after(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_5__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_6__0__Impl + rule__Node__Group_3_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); } + Parameters + { after(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_6__1__Impl + rule__Node__Group_3_6__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_6__2__Impl + rule__Node__Group_3_6__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); } + (rule__Node__ParameterAssignment_3_6_2)* + { after(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_6__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__TopicSpec__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__0__Impl + rule__TopicSpec__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); } + () + { after(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__1__Impl + rule__TopicSpec__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); } + Msg + { after(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__2__Impl + rule__TopicSpec__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); } + (rule__TopicSpec__NameAssignment_2) + { after(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__3__Impl + rule__TopicSpec__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__4__Impl + rule__TopicSpec__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); } + Message_1 + { after(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__5__Impl + rule__TopicSpec__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getGroup_5()); } + (rule__TopicSpec__Group_5__0)? + { after(grammarAccess.getTopicSpecAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); } + RULE_END + { after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__TopicSpec__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group_5__0__Impl + rule__TopicSpec__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); } + RULE_BEGIN + { after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group_5__1__Impl + rule__TopicSpec__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); } + (rule__TopicSpec__MessageAssignment_5_1) + { after(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); } + RULE_END + { after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceSpec__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__0__Impl + rule__ServiceSpec__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); } + () + { after(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__1__Impl + rule__ServiceSpec__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); } + Srv + { after(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__2__Impl + rule__ServiceSpec__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); } + (rule__ServiceSpec__NameAssignment_2) + { after(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__3__Impl + rule__ServiceSpec__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__4__Impl + rule__ServiceSpec__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); } + Request + { after(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__5__Impl + rule__ServiceSpec__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getGroup_5()); } + (rule__ServiceSpec__Group_5__0)? + { after(grammarAccess.getServiceSpecAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__6__Impl + rule__ServiceSpec__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); } + Response + { after(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__7__Impl + rule__ServiceSpec__Group__8 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getGroup_7()); } + (rule__ServiceSpec__Group_7__0)? + { after(grammarAccess.getServiceSpecAccess().getGroup_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__8 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__8__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__8__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); } + RULE_END + { after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceSpec__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_5__0__Impl + rule__ServiceSpec__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); } + RULE_BEGIN + { after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_5__1__Impl + rule__ServiceSpec__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); } + (rule__ServiceSpec__RequestAssignment_5_1) + { after(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); } + RULE_END + { after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceSpec__Group_7__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_7__0__Impl + rule__ServiceSpec__Group_7__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_7__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); } + RULE_BEGIN + { after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_7__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_7__1__Impl + rule__ServiceSpec__Group_7__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_7__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); } + (rule__ServiceSpec__ResponseAssignment_7_1) + { after(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_7__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_7__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_7__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); } + RULE_END + { after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionSpec__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__0__Impl + rule__ActionSpec__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); } + () + { after(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__1__Impl + rule__ActionSpec__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getActionKeyword_1()); } + Action_1 + { after(grammarAccess.getActionSpecAccess().getActionKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__2__Impl + rule__ActionSpec__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getNameAssignment_2()); } + (rule__ActionSpec__NameAssignment_2) + { after(grammarAccess.getActionSpecAccess().getNameAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__3__Impl + rule__ActionSpec__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__4__Impl + rule__ActionSpec__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); } + Goal_1 + { after(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__5__Impl + rule__ActionSpec__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getGroup_5()); } + (rule__ActionSpec__Group_5__0)? + { after(grammarAccess.getActionSpecAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__6__Impl + rule__ActionSpec__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getResultKeyword_6()); } + Result_1 + { after(grammarAccess.getActionSpecAccess().getResultKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__7__Impl + rule__ActionSpec__Group__8 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getGroup_7()); } + (rule__ActionSpec__Group_7__0)? + { after(grammarAccess.getActionSpecAccess().getGroup_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__8 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__8__Impl + rule__ActionSpec__Group__9 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__8__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); } + Feedback_1 + { after(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__9 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__9__Impl + rule__ActionSpec__Group__10 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__9__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getGroup_9()); } + (rule__ActionSpec__Group_9__0)? + { after(grammarAccess.getActionSpecAccess().getGroup_9()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__10 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__10__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__10__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionSpec__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_5__0__Impl + rule__ActionSpec__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_5__1__Impl + rule__ActionSpec__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); } + (rule__ActionSpec__GoalAssignment_5_1) + { after(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionSpec__Group_7__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_7__0__Impl + rule__ActionSpec__Group_7__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_7__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_7__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_7__1__Impl + rule__ActionSpec__Group_7__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_7__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); } + (rule__ActionSpec__ResultAssignment_7_1) + { after(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_7__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_7__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_7__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionSpec__Group_9__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_9__0__Impl + rule__ActionSpec__Group_9__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_9__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_9__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_9__1__Impl + rule__ActionSpec__Group_9__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_9__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); } + (rule__ActionSpec__FeedbackAssignment_9_1) + { after(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_9__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_9__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_9__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__MessageDefinition__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__MessageDefinition__Group__0__Impl + rule__MessageDefinition__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__MessageDefinition__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); } + () + { after(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessageDefinition__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__MessageDefinition__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__MessageDefinition__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); } + (rule__MessageDefinition__MessagePartAssignment_1)* + { after(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); } +) +; +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_1 + { 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 + rule__Publisher__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getGroup_6()); } + (rule__Publisher__Group_6__0)? + { after(grammarAccess.getPublisherAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Publisher__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group_6__0__Impl + rule__Publisher__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); } + (rule__Publisher__NamespaceAssignment_6_1) + { after(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); } +) +; +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_1 + { 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 + rule__Subscriber__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getGroup_6()); } + (rule__Subscriber__Group_6__0)? + { after(grammarAccess.getSubscriberAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Subscriber__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group_6__0__Impl + rule__Subscriber__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); } + (rule__Subscriber__NamespaceAssignment_6_1) + { after(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceServer__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__0__Impl + rule__ServiceServer__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); } + () + { after(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__1__Impl + rule__ServiceServer__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getNameAssignment_1()); } + (rule__ServiceServer__NameAssignment_1) + { after(grammarAccess.getServiceServerAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__2__Impl + rule__ServiceServer__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getServiceServerAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__3__Impl + rule__ServiceServer__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__4__Impl + rule__ServiceServer__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__5__Impl + rule__ServiceServer__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); } + (rule__ServiceServer__ServiceAssignment_5) + { after(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__6__Impl + rule__ServiceServer__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getGroup_6()); } + (rule__ServiceServer__Group_6__0)? + { after(grammarAccess.getServiceServerAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceServer__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group_6__0__Impl + rule__ServiceServer__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); } + (rule__ServiceServer__NamespaceAssignment_6_1) + { after(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceClient__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__0__Impl + rule__ServiceClient__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); } + () + { after(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__1__Impl + rule__ServiceClient__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getNameAssignment_1()); } + (rule__ServiceClient__NameAssignment_1) + { after(grammarAccess.getServiceClientAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__2__Impl + rule__ServiceClient__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getServiceClientAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__3__Impl + rule__ServiceClient__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__4__Impl + rule__ServiceClient__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__5__Impl + rule__ServiceClient__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); } + (rule__ServiceClient__ServiceAssignment_5) + { after(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__6__Impl + rule__ServiceClient__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getGroup_6()); } + (rule__ServiceClient__Group_6__0)? + { after(grammarAccess.getServiceClientAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceClient__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group_6__0__Impl + rule__ServiceClient__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); } + (rule__ServiceClient__NamespaceAssignment_6_1) + { after(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionServer__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__0__Impl + rule__ActionServer__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getActionServerAction_0()); } + () + { after(grammarAccess.getActionServerAccess().getActionServerAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__1__Impl + rule__ActionServer__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getNameAssignment_1()); } + (rule__ActionServer__NameAssignment_1) + { after(grammarAccess.getActionServerAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__2__Impl + rule__ActionServer__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getActionServerAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__3__Impl + rule__ActionServer__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__4__Impl + rule__ActionServer__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getActionServerAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__5__Impl + rule__ActionServer__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getActionAssignment_5()); } + (rule__ActionServer__ActionAssignment_5) + { after(grammarAccess.getActionServerAccess().getActionAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__6__Impl + rule__ActionServer__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getGroup_6()); } + (rule__ActionServer__Group_6__0)? + { after(grammarAccess.getActionServerAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionServer__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group_6__0__Impl + rule__ActionServer__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); } + (rule__ActionServer__NamespaceAssignment_6_1) + { after(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionClient__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__0__Impl + rule__ActionClient__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getActionClientAction_0()); } + () + { after(grammarAccess.getActionClientAccess().getActionClientAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__1__Impl + rule__ActionClient__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getNameAssignment_1()); } + (rule__ActionClient__NameAssignment_1) + { after(grammarAccess.getActionClientAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__2__Impl + rule__ActionClient__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getActionClientAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__3__Impl + rule__ActionClient__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__4__Impl + rule__ActionClient__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getActionClientAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__5__Impl + rule__ActionClient__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getActionAssignment_5()); } + (rule__ActionClient__ActionAssignment_5) + { after(grammarAccess.getActionClientAccess().getActionAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__6__Impl + rule__ActionClient__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getGroup_6()); } + (rule__ActionClient__Group_6__0)? + { after(grammarAccess.getActionClientAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionClient__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group_6__0__Impl + rule__ActionClient__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); } + (rule__ActionClient__NamespaceAssignment_6_1) + { after(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); } +) +; +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__GlobalNamespace__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group__0__Impl + rule__GlobalNamespace__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); } + () + { after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group__1__Impl + rule__GlobalNamespace__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); } + GlobalNamespace + { after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); } + (rule__GlobalNamespace__Group_2__0)? + { after(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalNamespace__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2__0__Impl + rule__GlobalNamespace__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } + LeftSquareBracket + { after(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2__1__Impl + rule__GlobalNamespace__Group_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); } + (rule__GlobalNamespace__PartsAssignment_2_1) + { after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2__2__Impl + rule__GlobalNamespace__Group_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); } + (rule__GlobalNamespace__Group_2_2__0)* + { after(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); } + RightSquareBracket + { after(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalNamespace__Group_2_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2_2__0__Impl + rule__GlobalNamespace__Group_2_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); } + Comma + { after(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); } + (rule__GlobalNamespace__PartsAssignment_2_2_1) + { after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelativeNamespace_Impl__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group__0__Impl + rule__RelativeNamespace_Impl__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); } + () + { after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group__1__Impl + rule__RelativeNamespace_Impl__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); } + RelativeNamespace + { after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); } + (rule__RelativeNamespace_Impl__Group_2__0)? + { after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelativeNamespace_Impl__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2__0__Impl + rule__RelativeNamespace_Impl__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); } + LeftSquareBracket + { after(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2__1__Impl + rule__RelativeNamespace_Impl__Group_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); } + (rule__RelativeNamespace_Impl__PartsAssignment_2_1) + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2__2__Impl + rule__RelativeNamespace_Impl__Group_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); } + (rule__RelativeNamespace_Impl__Group_2_2__0)* + { after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); } + RightSquareBracket + { after(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelativeNamespace_Impl__Group_2_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2_2__0__Impl + rule__RelativeNamespace_Impl__Group_2_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); } + Comma + { after(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); } + (rule__RelativeNamespace_Impl__PartsAssignment_2_2_1) + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PrivateNamespace__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group__0__Impl + rule__PrivateNamespace__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); } + () + { after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group__1__Impl + rule__PrivateNamespace__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); } + PrivateNamespace + { after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); } + (rule__PrivateNamespace__Group_2__0)? + { after(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PrivateNamespace__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2__0__Impl + rule__PrivateNamespace__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } + LeftSquareBracket + { after(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2__1__Impl + rule__PrivateNamespace__Group_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); } + (rule__PrivateNamespace__PartsAssignment_2_1) + { after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2__2__Impl + rule__PrivateNamespace__Group_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); } + (rule__PrivateNamespace__Group_2_2__0)* + { after(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); } + RightSquareBracket + { after(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PrivateNamespace__Group_2_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2_2__0__Impl + rule__PrivateNamespace__Group_2_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); } + Comma + { after(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); } + (rule__PrivateNamespace__PartsAssignment_2_2_1) + { after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); } +) +; +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().getTypeKeyword_4()); } + Type + { after(grammarAccess.getParameterAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__5__Impl + rule__Parameter__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getTypeAssignment_5()); } + (rule__Parameter__TypeAssignment_5) + { after(grammarAccess.getParameterAccess().getTypeAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__6__Impl + rule__Parameter__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getGroup_6()); } + (rule__Parameter__Group_6__0)? + { after(grammarAccess.getParameterAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__7__Impl + rule__Parameter__Group__8 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__8 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__8__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__8__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); } + RightCurlyBracket + { after(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Parameter__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group_6__0__Impl + rule__Parameter__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getParameterAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); } + (rule__Parameter__NamespaceAssignment_6_1) + { after(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterListType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__0__Impl + rule__ParameterListType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); } + () + { after(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__1__Impl + rule__ParameterListType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); } + List + { after(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__2__Impl + rule__ParameterListType__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); } + LeftSquareBracket + { after(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__3__Impl + rule__ParameterListType__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); } + (rule__ParameterListType__SequenceAssignment_3) + { after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__4__Impl + rule__ParameterListType__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getGroup_4()); } + (rule__ParameterListType__Group_4__0)* + { after(grammarAccess.getParameterListTypeAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); } + RightSquareBracket + { after(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterListType__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group_4__0__Impl + rule__ParameterListType__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); } + Comma + { after(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); } + (rule__ParameterListType__SequenceAssignment_4_1) + { after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStructType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__0__Impl + rule__ParameterStructType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); } + () + { after(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__1__Impl + rule__ParameterStructType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); } + Struct + { after(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__2__Impl + rule__ParameterStructType__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); } + LeftSquareBracket + { after(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__3__Impl + rule__ParameterStructType__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); } + (rule__ParameterStructType__ParameterstructypetmemberAssignment_3) + { after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__4__Impl + rule__ParameterStructType__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getGroup_4()); } + (rule__ParameterStructType__Group_4__0)* + { after(grammarAccess.getParameterStructTypeAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); } + RightSquareBracket + { after(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStructType__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group_4__0__Impl + rule__ParameterStructType__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); } + Comma + { after(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); } + (rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1) + { after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterIntegerType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterIntegerType__Group__0__Impl + rule__ParameterIntegerType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); } + () + { after(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterIntegerType__Group__1__Impl + rule__ParameterIntegerType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); } + Integer + { after(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterIntegerType__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); } + (rule__ParameterIntegerType__Group_2__0)? + { after(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterIntegerType__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterIntegerType__Group_2__0__Impl + rule__ParameterIntegerType__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); } + Default + { after(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterIntegerType__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); } + (rule__ParameterIntegerType__DefaultAssignment_2_1) + { after(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStringType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStringType__Group__0__Impl + rule__ParameterStringType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); } + () + { after(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStringType__Group__1__Impl + rule__ParameterStringType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); } + String + { after(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStringType__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStringTypeAccess().getGroup_2()); } + (rule__ParameterStringType__Group_2__0)? + { after(grammarAccess.getParameterStringTypeAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStringType__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStringType__Group_2__0__Impl + rule__ParameterStringType__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); } + Default + { after(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStringType__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); } + (rule__ParameterStringType__DefaultAssignment_2_1) + { after(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterDoubleType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterDoubleType__Group__0__Impl + rule__ParameterDoubleType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); } + () + { after(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterDoubleType__Group__1__Impl + rule__ParameterDoubleType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); } + Double + { after(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterDoubleType__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); } + (rule__ParameterDoubleType__Group_2__0)? + { after(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterDoubleType__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterDoubleType__Group_2__0__Impl + rule__ParameterDoubleType__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); } + Default + { after(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterDoubleType__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); } + (rule__ParameterDoubleType__DefaultAssignment_2_1) + { after(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterBooleanType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBooleanType__Group__0__Impl + rule__ParameterBooleanType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); } + () + { after(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBooleanType__Group__1__Impl + rule__ParameterBooleanType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); } + Boolean + { after(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBooleanType__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); } + (rule__ParameterBooleanType__Group_2__0)? + { after(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterBooleanType__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBooleanType__Group_2__0__Impl + rule__ParameterBooleanType__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); } + Default + { after(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBooleanType__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); } + (rule__ParameterBooleanType__DefaultAssignment_2_1) + { after(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterBase64Type__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBase64Type__Group__0__Impl + rule__ParameterBase64Type__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); } + () + { after(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBase64Type__Group__1__Impl + rule__ParameterBase64Type__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); } + Base64 + { after(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBase64Type__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); } + (rule__ParameterBase64Type__Group_2__0)? + { after(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterBase64Type__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBase64Type__Group_2__0__Impl + rule__ParameterBase64Type__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); } + Default + { after(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBase64Type__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); } + (rule__ParameterBase64Type__DefaultAssignment_2_1) + { after(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterArrayType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__0__Impl + rule__ParameterArrayType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); } + Array + { after(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__1__Impl + rule__ParameterArrayType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); } + RULE_BEGIN + { after(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__2__Impl + rule__ParameterArrayType__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); } + Type + { after(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__3__Impl + rule__ParameterArrayType__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); } + (rule__ParameterArrayType__TypeAssignment_3) + { after(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__4__Impl + rule__ParameterArrayType__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); } + (rule__ParameterArrayType__Group_4__0)? + { after(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); } + RULE_END + { after(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterArrayType__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group_4__0__Impl + rule__ParameterArrayType__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); } + Default + { after(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); } + (rule__ParameterArrayType__DefaultAssignment_4_1) + { after(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterList__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group__0__Impl + rule__ParameterList__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); } + () + { after(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group__1__Impl + rule__ParameterList__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); } + LeftSquareBracket + { after(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group__2__Impl + rule__ParameterList__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getValueAssignment_2()); } + (rule__ParameterList__ValueAssignment_2) + { after(grammarAccess.getParameterListAccess().getValueAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group__3__Impl + rule__ParameterList__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getGroup_3()); } + (rule__ParameterList__Group_3__0)* + { after(grammarAccess.getParameterListAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); } + RightSquareBracket + { after(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterList__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group_3__0__Impl + rule__ParameterList__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); } + Comma + { after(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); } + (rule__ParameterList__ValueAssignment_3_1) + { after(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterAny__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterAny__Group__0__Impl + rule__ParameterAny__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); } + () + { after(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterAny__Group__1__Impl + rule__ParameterAny__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); } + ParameterAny + { after(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterAny__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAnyAccess().getGroup_2()); } + (rule__ParameterAny__Group_2__0)? + { after(grammarAccess.getParameterAnyAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterAny__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterAny__Group_2__0__Impl + rule__ParameterAny__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); } + Value + { after(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterAny__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); } + (rule__ParameterAny__ValueAssignment_2_1) + { after(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStruct__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group__0__Impl + rule__ParameterStruct__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); } + () + { after(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getGroup_1()); } + (rule__ParameterStruct__Group_1__0)? + { after(grammarAccess.getParameterStructAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStruct__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1__0__Impl + rule__ParameterStruct__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); } + LeftSquareBracket + { after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1__1__Impl + rule__ParameterStruct__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); } + (rule__ParameterStruct__ValueAssignment_1_1) + { after(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1__2__Impl + rule__ParameterStruct__Group_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getGroup_1_2()); } + (rule__ParameterStruct__Group_1_2__0)* + { after(grammarAccess.getParameterStructAccess().getGroup_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); } + RightSquareBracket + { after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStruct__Group_1_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1_2__0__Impl + rule__ParameterStruct__Group_1_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); } + Comma + { after(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1_2__1__Impl + rule__ParameterStruct__Group_1_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); } + LeftSquareBracket + { after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1_2__2__Impl + rule__ParameterStruct__Group_1_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); } + (rule__ParameterStruct__ValueAssignment_1_2_2) + { after(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1_2__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); } + RightSquareBracket + { after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStructMember__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__0__Impl + rule__ParameterStructMember__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); } + ParameterStructMember + { after(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__1__Impl + rule__ParameterStructMember__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); } + (rule__ParameterStructMember__NameAssignment_1) + { after(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__2__Impl + rule__ParameterStructMember__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__3__Impl + rule__ParameterStructMember__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__4__Impl + rule__ParameterStructMember__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); } + (rule__ParameterStructMember__ValueAssignment_4) + { after(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); } + RULE_END + { after(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStructTypeMember__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructTypeMember__Group__0__Impl + rule__ParameterStructTypeMember__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructTypeMember__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); } + (rule__ParameterStructTypeMember__NameAssignment_0) + { after(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructTypeMember__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructTypeMember__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructTypeMember__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); } + (rule__ParameterStructTypeMember__TypeAssignment_1) + { after(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__MessagePart__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__MessagePart__Group__0__Impl + rule__MessagePart__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); } + (rule__MessagePart__TypeAssignment_0) + { after(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__MessagePart__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMessagePartAccess().getDataAssignment_1()); } + (rule__MessagePart__DataAssignment_1) + { after(grammarAccess.getMessagePartAccess().getDataAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Bool__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Bool__Group__0__Impl + rule__Bool__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Bool__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getBoolAccess().getBoolAction_0()); } + () + { after(grammarAccess.getBoolAccess().getBoolAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Bool__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Bool__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Bool__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getBoolAccess().getBoolKeyword_1()); } + Bool + { after(grammarAccess.getBoolAccess().getBoolKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int8__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int8__Group__0__Impl + rule__Int8__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt8Access().getInt8Action_0()); } + () + { after(grammarAccess.getInt8Access().getInt8Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int8__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt8Access().getInt8Keyword_1()); } + Int8 + { after(grammarAccess.getInt8Access().getInt8Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint8__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint8__Group__0__Impl + rule__Uint8__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint8Access().getUint8Action_0()); } + () + { after(grammarAccess.getUint8Access().getUint8Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint8__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint8Access().getUint8Keyword_1()); } + Uint8 + { after(grammarAccess.getUint8Access().getUint8Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int16__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int16__Group__0__Impl + rule__Int16__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt16Access().getInt16Action_0()); } + () + { after(grammarAccess.getInt16Access().getInt16Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int16__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt16Access().getInt16Keyword_1()); } + Int16 + { after(grammarAccess.getInt16Access().getInt16Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint16__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint16__Group__0__Impl + rule__Uint16__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint16Access().getUint16Action_0()); } + () + { after(grammarAccess.getUint16Access().getUint16Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint16__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint16Access().getUint16Keyword_1()); } + Uint16 + { after(grammarAccess.getUint16Access().getUint16Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int32__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int32__Group__0__Impl + rule__Int32__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt32Access().getInt32Action_0()); } + () + { after(grammarAccess.getInt32Access().getInt32Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int32__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt32Access().getInt32Keyword_1()); } + Int32 + { after(grammarAccess.getInt32Access().getInt32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint32__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint32__Group__0__Impl + rule__Uint32__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint32Access().getUint32Action_0()); } + () + { after(grammarAccess.getUint32Access().getUint32Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint32__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint32Access().getUint32Keyword_1()); } + Uint32 + { after(grammarAccess.getUint32Access().getUint32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int64__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int64__Group__0__Impl + rule__Int64__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt64Access().getInt64Action_0()); } + () + { after(grammarAccess.getInt64Access().getInt64Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int64__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt64Access().getInt64Keyword_1()); } + Int64 + { after(grammarAccess.getInt64Access().getInt64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint64__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint64__Group__0__Impl + rule__Uint64__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint64Access().getUint64Action_0()); } + () + { after(grammarAccess.getUint64Access().getUint64Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint64__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint64Access().getUint64Keyword_1()); } + Uint64 + { after(grammarAccess.getUint64Access().getUint64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Float32__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float32__Group__0__Impl + rule__Float32__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat32Access().getFloat32Action_0()); } + () + { after(grammarAccess.getFloat32Access().getFloat32Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float32__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat32Access().getFloat32Keyword_1()); } + Float32 + { after(grammarAccess.getFloat32Access().getFloat32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Float64__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float64__Group__0__Impl + rule__Float64__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat64Access().getFloat64Action_0()); } + () + { after(grammarAccess.getFloat64Access().getFloat64Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float64__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat64Access().getFloat64Keyword_1()); } + Float64 + { after(grammarAccess.getFloat64Access().getFloat64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__String0__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__String0__Group__0__Impl + rule__String0__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__String0__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getString0Access().getStringAction_0()); } + () + { after(grammarAccess.getString0Access().getStringAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__String0__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__String0__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__String0__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getString0Access().getStringKeyword_1()); } + String_1 + { after(grammarAccess.getString0Access().getStringKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Byte__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Byte__Group__0__Impl + rule__Byte__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Byte__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getByteAccess().getByteAction_0()); } + () + { after(grammarAccess.getByteAccess().getByteAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Byte__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Byte__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Byte__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getByteAccess().getByteKeyword_1()); } + Byte + { after(grammarAccess.getByteAccess().getByteKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Time__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Time__Group__0__Impl + rule__Time__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Time__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTimeAccess().getTimeAction_0()); } + () + { after(grammarAccess.getTimeAccess().getTimeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Time__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Time__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Time__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTimeAccess().getTimeKeyword_1()); } + Time + { after(grammarAccess.getTimeAccess().getTimeKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Duration__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Duration__Group__0__Impl + rule__Duration__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Duration__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getDurationAccess().getDurationAction_0()); } + () + { after(grammarAccess.getDurationAccess().getDurationAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Duration__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Duration__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Duration__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getDurationAccess().getDurationKeyword_1()); } + Duration + { after(grammarAccess.getDurationAccess().getDurationKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__BoolArray__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__BoolArray__Group__0__Impl + rule__BoolArray__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__BoolArray__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); } + () + { after(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__BoolArray__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__BoolArray__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__BoolArray__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); } + Bool_1 + { after(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int8Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int8Array__Group__0__Impl + rule__Int8Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); } + () + { after(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int8Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); } + Int8_1 + { after(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint8Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint8Array__Group__0__Impl + rule__Uint8Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); } + () + { after(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint8Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); } + Uint8_1 + { after(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int16Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int16Array__Group__0__Impl + rule__Int16Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); } + () + { after(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int16Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); } + Int16_1 + { after(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint16Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint16Array__Group__0__Impl + rule__Uint16Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); } + () + { after(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint16Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); } + Uint16_1 + { after(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int32Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int32Array__Group__0__Impl + rule__Int32Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); } + () + { after(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int32Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); } + Int32_1 + { after(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint32Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint32Array__Group__0__Impl + rule__Uint32Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); } + () + { after(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint32Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); } + Uint32_1 + { after(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int64Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int64Array__Group__0__Impl + rule__Int64Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); } + () + { after(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int64Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); } + Int64_1 + { after(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint64Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint64Array__Group__0__Impl + rule__Uint64Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); } + () + { after(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint64Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); } + Uint64_1 + { after(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Float32Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float32Array__Group__0__Impl + rule__Float32Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); } + () + { after(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float32Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); } + Float32_1 + { after(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Float64Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float64Array__Group__0__Impl + rule__Float64Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); } + () + { after(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float64Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); } + Float64_1 + { after(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__String0Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__String0Array__Group__0__Impl + rule__String0Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__String0Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); } + () + { after(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__String0Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__String0Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__String0Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); } + String_2 + { after(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ByteArray__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ByteArray__Group__0__Impl + rule__ByteArray__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ByteArray__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); } + () + { after(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ByteArray__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ByteArray__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ByteArray__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getByteArrayAccess().getByteKeyword_1()); } + Byte_1 + { after(grammarAccess.getByteArrayAccess().getByteKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Header__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Header__Group__0__Impl + rule__Header__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Header__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getHeaderAccess().getHeaderAction_0()); } + () + { after(grammarAccess.getHeaderAccess().getHeaderAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Header__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Header__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Header__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); } + Header + { after(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ArrayTopicSpecRef__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ArrayTopicSpecRef__Group__0__Impl + rule__ArrayTopicSpecRef__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ArrayTopicSpecRef__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); } + (rule__ArrayTopicSpecRef__TopicSpecAssignment_0) + { after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ArrayTopicSpecRef__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ArrayTopicSpecRef__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ArrayTopicSpecRef__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); } + LeftSquareBracketRightSquareBracket + { after(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PackageSet__PackageAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackageSetAccess().getPackagePackage_ImplParserRuleCall_1_0()); } + rulePackage_Impl + { after(grammarAccess.getPackageSetAccess().getPackagePackage_ImplParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); } + ruleRosNames + { after(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__FromGitRepoAssignment_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } + ruleEString + { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__SpecAssignment_5_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); } + ruleSpecBase + { after(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__DependencyAssignment_6_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); } + ruleDependency + { after(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__DependencyAssignment_6_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); } + ruleDependency + { after(grammarAccess.getPackage_ImplAccess().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_0_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); } + rulePublisher + { after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__SubscriberAssignment_3_1_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); } + ruleSubscriber + { after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__ServiceserverAssignment_3_2_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); } + ruleServiceServer + { after(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__ServiceclientAssignment_3_3_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); } + ruleServiceClient + { after(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__ActionserverAssignment_3_4_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); } + ruleActionServer + { after(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__ActionclientAssignment_3_5_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); } + ruleActionClient + { after(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__ParameterAssignment_3_6_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); } + ruleParameter + { after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__NameAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); } + (rule__TopicSpec__NameAlternatives_2_0) + { after(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__MessageAssignment_5_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__NameAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); } + ruleEString + { after(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__RequestAssignment_5_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__ResponseAssignment_7_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__NameAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); } + ruleEString + { after(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__GoalAssignment_5_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__ResultAssignment_7_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__FeedbackAssignment_9_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessageDefinition__MessagePartAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); } + ruleMessagePart + { after(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_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__Publisher__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_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__Subscriber__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__ServiceAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__ServiceAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__ActionAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__ActionAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_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); +} + +rule__GlobalNamespace__PartsAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ruleGraphName + { after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__PartsAssignment_2_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } + ruleGraphName + { after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__PartsAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ruleGraphName + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } + ruleGraphName + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__PartsAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ruleGraphName + { after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__PartsAssignment_2_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } + ruleGraphName + { after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_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__Parameter__TypeAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); } + ruleParameterType + { after(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__SequenceAssignment_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); } + ruleParameterType + { after(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__SequenceAssignment_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); } + ruleParameterType + { after(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__ParameterstructypetmemberAssignment_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); } + ruleParameterStructTypeMember + { after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); } + ruleParameterStructTypeMember + { after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__DefaultAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); } + ruleParameterInteger + { after(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__DefaultAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); } + ruleParameterString + { after(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__DefaultAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); } + ruleParameterDouble + { after(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__DefaultAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); } + ruleParameterBoolean + { after(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__DefaultAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); } + ruleParameterBase64 + { after(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__TypeAssignment_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); } + ruleParameterType + { after(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__DefaultAssignment_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); } + ruleParameterList + { after(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__ValueAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); } + ruleParameterValue + { after(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__ValueAssignment_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); } + ruleParameterValue + { after(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__ValueAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); } + ruleEString + { after(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterString__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); } + ruleEString + { after(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); } + ruleBase64Binary + { after(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterInteger__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); } + ruleInteger0 + { after(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDouble__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); } + ruleDouble0 + { after(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBoolean__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); } + ruleboolean0 + { after(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__ValueAssignment_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); } + ruleParameterStructMember + { after(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__ValueAssignment_1_2_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); } + ruleParameterStructMember + { after(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDate__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); } + ruleDateTime0 + { after(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__ValueAssignment_4 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); } + ruleParameterValue + { after(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructTypeMember__NameAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); } + ruleEString + { after(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructTypeMember__TypeAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); } + ruleParameterType + { after(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__TypeAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); } + ruleAbstractType + { after(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__DataAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0()); } + (rule__MessagePart__DataAlternatives_1_0) + { after(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpecRef__TopicSpecAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); } + ( + { before(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_1()); } + ruleEString + { after(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_1()); } + ) + { after(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ArrayTopicSpecRef__TopicSpecAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); } + ( + { before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_0_1()); } + ruleEString + { after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_0_1()); } + ) + { after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosParser.java b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosParser.java index 384fb4856..deb0bf218 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosParser.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosParser.java @@ -1,4 +1,6 @@ package de.fraunhofer.ipa.ros.ide.contentassist.antlr.internal; +import java.util.Map; +import java.util.HashMap; import java.io.InputStream; import org.eclipse.xtext.*; @@ -22,119 +24,119 @@ @SuppressWarnings("all") public class InternalRosParser extends AbstractInternalContentAssistParser { public static final String[] tokenNames = new String[] { - "", "", "", "", "RULE_BINARY", "RULE_BOOLEAN", "RULE_DOUBLE", "RULE_DECINT", "RULE_DATE_TIME", "RULE_STRING", "RULE_ID", "RULE_ROS_CONVENTION_A", "RULE_MESSAGE_ASIGMENT", "RULE_ROS_CONVENTION_PARAM", "RULE_DIGIT", "RULE_DAY", "RULE_MONTH", "RULE_YEAR", "RULE_HOUR", "RULE_MIN_SEC", "RULE_INT", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'GraphName'", "'node'", "'Header'", "'String'", "'goal'", "'message'", "'result'", "'feedback'", "'name'", "'value'", "'service'", "'type'", "'action'", "'duration'", "'time'", "'PackageSet'", "'{'", "'}'", "','", "'Package'", "'FromGitRepo'", "'Specs'", "'Artifact'", "'CatkinPackage'", "'Dependencies'", "'AmentPackage'", "'ServiceSpec'", "'request'", "'response'", "'TopicSpec'", "'ActionSpec'", "'Node'", "'ServiceServers'", "'Publishers'", "'Subscribers'", "'ServiceClients'", "'ActionServers'", "'ActionClients'", "'Parameters'", "'ServiceServer'", "'namespace'", "'Publisher'", "'Subscriber'", "'ServiceClient'", "'ActionServer'", "'ActionClient'", "'ExternalDependency'", "'GlobalNamespace'", "'parts'", "'RelativeNamespace'", "'PrivateNamespace'", "'Parameter'", "'List'", "'Struct'", "'Integer'", "'default'", "'Double'", "'Boolean'", "'Base64'", "'Array'", "'ParameterAny'", "'ParameterStructMember'", "'bool'", "'int8'", "'uint8'", "'int16'", "'uint16'", "'int32'", "'uint32'", "'int64'", "'uint64'", "'float32'", "'float64'", "'string'", "'byte'", "'bool[]'", "'int8[]'", "'uint8[]'", "'int16[]'", "'uint16[]'", "'int32[]'", "'uint32[]'", "'int64[]'", "'uint64[]'", "'float32[]'", "'float64[]'", "'string[]'", "'byte[]'", "'[]'" + "", "", "", "", "ParameterStructMember", "ExternalDependency", "RelativeNamespace", "PrivateNamespace", "GlobalNamespace", "Serviceclient", "Serviceserver", "Actionclient", "Actionserver", "Dependencies", "AmentPackage", "ParameterAny", "FromGitRepo", "Subscribers", "Parameters", "Publishers", "Artifacts", "GraphName", "Feedback_1", "Float32_1", "Float64_1", "Response", "Duration", "Feedback", "Message_1", "Request", "String_2", "Uint16_1", "Uint32_1", "Uint64_1", "Boolean", "Integer", "Action_1", "Default", "Float32", "Float64", "Int16_1", "Int32_1", "Int64_1", "Message", "Result_1", "Service", "Uint8_1", "Array", "Base64", "Double", "Header", "String", "Struct", "Action", "Bool_1", "Byte_1", "Int8_1", "Result", "Specs", "String_1", "Uint16", "Uint32", "Uint64", "Goal_1", "Int16", "Int32", "Int64", "Node_1", "Type_1", "Uint8", "Value", "Date", "List", "Bool", "Byte", "Goal", "Int8", "Msg", "Name", "Node", "Srv", "Time", "Type", "Any", "Ns", "LeftSquareBracketRightSquareBracket", "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_DIGIT", "RULE_BINARY", "RULE_BOOLEAN", "RULE_DECINT", "RULE_DOUBLE", "RULE_DAY", "RULE_MONTH", "RULE_YEAR", "RULE_HOUR", "RULE_MIN_SEC", "RULE_DATE_TIME", "RULE_INT", "RULE_MESSAGE_ASIGMENT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER" }; - public static final int T__50=50; - public static final int RULE_DATE_TIME=8; - public static final int T__59=59; - public static final int T__55=55; - public static final int T__56=56; - public static final int T__57=57; - public static final int T__58=58; - public static final int T__51=51; - public static final int T__52=52; - public static final int T__53=53; - public static final int T__54=54; - public static final int T__60=60; - public static final int T__61=61; - public static final int RULE_ID=10; - public static final int RULE_DIGIT=14; - public static final int RULE_INT=20; - public static final int T__66=66; - public static final int RULE_ML_COMMENT=21; - public static final int T__67=67; - public static final int T__68=68; - public static final int T__69=69; - public static final int T__62=62; - public static final int T__63=63; - public static final int T__64=64; - public static final int T__65=65; - public static final int RULE_MESSAGE_ASIGMENT=12; - public static final int T__37=37; - public static final int T__38=38; - public static final int T__39=39; - public static final int T__33=33; - public static final int T__34=34; - public static final int T__35=35; - public static final int T__36=36; - public static final int RULE_DECINT=7; - public static final int T__30=30; - public static final int T__31=31; - public static final int T__32=32; - public static final int RULE_HOUR=18; - public static final int T__48=48; - public static final int T__49=49; - public static final int T__44=44; - public static final int T__45=45; - public static final int T__46=46; - public static final int RULE_BINARY=4; - public static final int T__47=47; - public static final int T__40=40; - public static final int T__41=41; - public static final int T__42=42; - public static final int T__43=43; - public static final int T__91=91; - public static final int T__100=100; - public static final int T__92=92; - public static final int T__93=93; - public static final int T__102=102; - public static final int T__94=94; - public static final int T__101=101; - public static final int RULE_DAY=15; - public static final int T__90=90; - public static final int RULE_BOOLEAN=5; - public static final int RULE_YEAR=17; - public static final int RULE_MIN_SEC=19; - public static final int T__99=99; - public static final int T__95=95; - public static final int T__96=96; - public static final int T__97=97; - public static final int T__98=98; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; - public static final int T__29=29; - public static final int T__25=25; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=9; - public static final int RULE_SL_COMMENT=22; - public static final int RULE_DOUBLE=6; - public static final int RULE_ROS_CONVENTION_A=11; - public static final int T__77=77; - public static final int T__78=78; - public static final int RULE_ROS_CONVENTION_PARAM=13; - public static final int T__79=79; - public static final int T__73=73; + public static final int Float32_1=23; + public static final int Node=79; + public static final int RULE_DATE_TIME=108; + public static final int Uint64_1=33; + public static final int String=51; + public static final int Int16=64; + public static final int Float32=38; + public static final int Goal=75; + public static final int Bool=73; + public static final int Uint16=60; + public static final int Boolean=34; + public static final int ExternalDependency=5; + public static final int Uint8=69; + public static final int Parameters=18; + public static final int RULE_ID=94; + public static final int AmentPackage=14; + public static final int Actionclient=11; + public static final int RULE_DIGIT=98; + public static final int GlobalNamespace=8; + public static final int Artifacts=20; + public static final int Node_1=67; + public static final int Int16_1=40; + public static final int Header=50; + public static final int RULE_INT=109; + public static final int Byte=74; + public static final int RULE_ML_COMMENT=111; + public static final int LeftSquareBracket=88; + public static final int Specs=58; + public static final int Base64=48; + public static final int Message_1=28; + public static final int Comma=86; + public static final int RULE_MESSAGE_ASIGMENT=110; + public static final int Goal_1=63; + public static final int LeftSquareBracketRightSquareBracket=85; + public static final int Int32=65; + public static final int Publishers=19; + public static final int Serviceserver=10; + public static final int RightCurlyBracket=90; + public static final int RULE_DECINT=101; + public static final int Uint32=61; + public static final int FromGitRepo=16; + public static final int Msg=77; + public static final int RULE_HOUR=106; + public static final int Int8=76; + public static final int Default=37; + public static final int Actionserver=12; + public static final int Int8_1=56; + public static final int Uint16_1=31; + public static final int Type=82; + public static final int Float64=39; + public static final int Int32_1=41; + public static final int Result_1=44; + public static final int RULE_BINARY=99; + public static final int String_1=59; + public static final int Subscribers=17; + public static final int String_2=30; + public static final int RULE_BEGIN=91; + public static final int RULE_DAY=103; + public static final int RULE_BOOLEAN=100; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=105; + public static final int Feedback_1=22; + public static final int Result=57; + public static final int Name=78; + public static final int RULE_MIN_SEC=107; + public static final int ParameterAny=15; + public static final int List=72; + public static final int Dependencies=13; + public static final int RightSquareBracket=89; + public static final int PrivateNamespace=7; + public static final int GraphName=21; + public static final int Byte_1=55; + public static final int Float64_1=24; + public static final int Duration=26; + public static final int Uint32_1=32; + public static final int Action_1=36; + public static final int Double=49; + public static final int Type_1=68; + public static final int Value=70; + public static final int Uint64=62; + public static final int Action=53; + public static final int RULE_END=92; + public static final int Message=43; + public static final int Time=81; + public static final int RULE_STRING=96; + public static final int Bool_1=54; + public static final int Any=83; + public static final int Struct=52; + public static final int RULE_SL_COMMENT=93; + public static final int Uint8_1=46; + public static final int RULE_DOUBLE=102; + public static final int Feedback=27; + public static final int ParameterStructMember=4; + public static final int Srv=80; + public static final int RULE_ROS_CONVENTION_A=95; + public static final int RULE_ROS_CONVENTION_PARAM=97; + public static final int Colon=87; public static final int EOF=-1; - public static final int T__74=74; - public static final int T__75=75; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__111=111; - public static final int T__81=81; - public static final int T__110=110; - public static final int T__82=82; - public static final int T__113=113; - public static final int T__83=83; - public static final int T__112=112; - public static final int RULE_WS=23; - public static final int RULE_ANY_OTHER=24; - public static final int T__88=88; - public static final int T__108=108; - public static final int T__89=89; - public static final int T__107=107; - public static final int RULE_MONTH=16; - public static final int T__109=109; - public static final int T__84=84; - public static final int T__104=104; - public static final int T__85=85; - public static final int T__103=103; - public static final int T__86=86; - public static final int T__106=106; - public static final int T__87=87; - public static final int T__105=105; + public static final int Ns=84; + public static final int RULE_WS=112; + public static final int Request=29; + public static final int Int64_1=42; + public static final int Service=45; + public static final int RULE_ANY_OTHER=113; + public static final int Date=71; + public static final int Response=25; + public static final int Integer=35; + public static final int Array=47; + public static final int Serviceclient=9; + public static final int Int64=66; + public static final int RULE_MONTH=104; // delegates // delegators @@ -150,10 +152,101 @@ public InternalRosParser(TokenStream input, RecognizerSharedState state) { public String[] getTokenNames() { return InternalRosParser.tokenNames; } - public String getGrammarFileName() { return "InternalRos.g"; } + public String getGrammarFileName() { return "InternalRosParser.g"; } private RosGrammarAccess grammarAccess; + private final Map tokenNameToValue = new HashMap(); + + { + tokenNameToValue.put("Comma", "','"); + tokenNameToValue.put("Colon", "':'"); + tokenNameToValue.put("LeftSquareBracket", "'['"); + tokenNameToValue.put("RightSquareBracket", "']'"); + tokenNameToValue.put("RightCurlyBracket", "'}'"); + tokenNameToValue.put("LeftSquareBracketRightSquareBracket", "'[]'"); + tokenNameToValue.put("Any", "'Any'"); + tokenNameToValue.put("Ns", "'ns:'"); + tokenNameToValue.put("Date", "'Date'"); + tokenNameToValue.put("List", "'List'"); + tokenNameToValue.put("Bool", "'bool'"); + tokenNameToValue.put("Byte", "'byte'"); + tokenNameToValue.put("Goal", "'goal'"); + tokenNameToValue.put("Int8", "'int8'"); + tokenNameToValue.put("Msg", "'msg:'"); + tokenNameToValue.put("Name", "'name'"); + tokenNameToValue.put("Node", "'node'"); + tokenNameToValue.put("Srv", "'srv:'"); + tokenNameToValue.put("Time", "'time'"); + tokenNameToValue.put("Type", "'type'"); + tokenNameToValue.put("Goal_1", "'goal:'"); + tokenNameToValue.put("Int16", "'int16'"); + tokenNameToValue.put("Int32", "'int32'"); + tokenNameToValue.put("Int64", "'int64'"); + tokenNameToValue.put("Node_1", "'node:'"); + tokenNameToValue.put("Type_1", "'type:'"); + tokenNameToValue.put("Uint8", "'uint8'"); + tokenNameToValue.put("Value", "'value'"); + tokenNameToValue.put("Array", "'Array:'"); + tokenNameToValue.put("Base64", "'Base64'"); + tokenNameToValue.put("Double", "'Double'"); + tokenNameToValue.put("Header", "'Header'"); + tokenNameToValue.put("String", "'String'"); + tokenNameToValue.put("Struct", "'Struct'"); + tokenNameToValue.put("Action", "'action'"); + tokenNameToValue.put("Bool_1", "'bool[]'"); + tokenNameToValue.put("Byte_1", "'byte[]'"); + tokenNameToValue.put("Int8_1", "'int8[]'"); + tokenNameToValue.put("Result", "'result'"); + tokenNameToValue.put("Specs", "'specs:'"); + tokenNameToValue.put("String_1", "'string'"); + tokenNameToValue.put("Uint16", "'uint16'"); + tokenNameToValue.put("Uint32", "'uint32'"); + tokenNameToValue.put("Uint64", "'uint64'"); + tokenNameToValue.put("Boolean", "'Boolean'"); + tokenNameToValue.put("Integer", "'Integer'"); + tokenNameToValue.put("Action_1", "'action:'"); + tokenNameToValue.put("Default", "'default'"); + tokenNameToValue.put("Float32", "'float32'"); + tokenNameToValue.put("Float64", "'float64'"); + tokenNameToValue.put("Int16_1", "'int16[]'"); + tokenNameToValue.put("Int32_1", "'int32[]'"); + tokenNameToValue.put("Int64_1", "'int64[]'"); + tokenNameToValue.put("Message", "'message'"); + tokenNameToValue.put("Result_1", "'result:'"); + tokenNameToValue.put("Service", "'service'"); + tokenNameToValue.put("Uint8_1", "'uint8[]'"); + tokenNameToValue.put("Duration", "'duration'"); + tokenNameToValue.put("Feedback", "'feedback'"); + tokenNameToValue.put("Message_1", "'message:'"); + tokenNameToValue.put("Request", "'request:'"); + tokenNameToValue.put("String_2", "'string[]'"); + tokenNameToValue.put("Uint16_1", "'uint16[]'"); + tokenNameToValue.put("Uint32_1", "'uint32[]'"); + tokenNameToValue.put("Uint64_1", "'uint64[]'"); + tokenNameToValue.put("GraphName", "'GraphName'"); + tokenNameToValue.put("Feedback_1", "'feedback:'"); + tokenNameToValue.put("Float32_1", "'float32[]'"); + tokenNameToValue.put("Float64_1", "'float64[]'"); + tokenNameToValue.put("Response", "'response:'"); + tokenNameToValue.put("Artifacts", "'artifacts:'"); + tokenNameToValue.put("Parameters", "'parameters:'"); + tokenNameToValue.put("Publishers", "'publishers:'"); + tokenNameToValue.put("AmentPackage", "'AmentPackage'"); + tokenNameToValue.put("ParameterAny", "'ParameterAny'"); + tokenNameToValue.put("FromGitRepo", "'fromGitRepo:'"); + tokenNameToValue.put("Subscribers", "'subscribers:'"); + tokenNameToValue.put("Actionclient", "'actionclient:'"); + tokenNameToValue.put("Actionserver", "'actionserver:'"); + tokenNameToValue.put("Dependencies", "'dependencies:'"); + tokenNameToValue.put("Serviceclient", "'serviceclient:'"); + tokenNameToValue.put("Serviceserver", "'serviceserver:'"); + tokenNameToValue.put("GlobalNamespace", "'GlobalNamespace'"); + tokenNameToValue.put("PrivateNamespace", "'PrivateNamespace'"); + tokenNameToValue.put("RelativeNamespace", "'RelativeNamespace'"); + tokenNameToValue.put("ExternalDependency", "'ExternalDependency'"); + tokenNameToValue.put("ParameterStructMember", "'ParameterStructMember'"); + } public void setGrammarAccess(RosGrammarAccess grammarAccess) { this.grammarAccess = grammarAccess; @@ -166,17 +259,20 @@ protected Grammar getGrammar() { @Override protected String getValueForTokenName(String tokenName) { - return tokenName; + String result = tokenNameToValue.get(tokenName); + if (result == null) + result = tokenName; + return result; } // $ANTLR start "entryRulePackageSet" - // InternalRos.g:53:1: entryRulePackageSet : rulePackageSet EOF ; + // InternalRosParser.g:142:1: entryRulePackageSet : rulePackageSet EOF ; public final void entryRulePackageSet() throws RecognitionException { try { - // InternalRos.g:54:1: ( rulePackageSet EOF ) - // InternalRos.g:55:1: rulePackageSet EOF + // InternalRosParser.g:143:1: ( rulePackageSet EOF ) + // InternalRosParser.g:144:1: rulePackageSet EOF { before(grammarAccess.getPackageSetRule()); pushFollow(FOLLOW_1); @@ -202,21 +298,21 @@ public final void entryRulePackageSet() throws RecognitionException { // $ANTLR start "rulePackageSet" - // InternalRos.g:62:1: rulePackageSet : ( ( rule__PackageSet__Group__0 ) ) ; + // InternalRosParser.g:151:1: rulePackageSet : ( ( rule__PackageSet__Group__0 ) ) ; public final void rulePackageSet() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:66:2: ( ( ( rule__PackageSet__Group__0 ) ) ) - // InternalRos.g:67:2: ( ( rule__PackageSet__Group__0 ) ) + // InternalRosParser.g:155:2: ( ( ( rule__PackageSet__Group__0 ) ) ) + // InternalRosParser.g:156:2: ( ( rule__PackageSet__Group__0 ) ) { - // InternalRos.g:67:2: ( ( rule__PackageSet__Group__0 ) ) - // InternalRos.g:68:3: ( rule__PackageSet__Group__0 ) + // InternalRosParser.g:156:2: ( ( rule__PackageSet__Group__0 ) ) + // InternalRosParser.g:157:3: ( rule__PackageSet__Group__0 ) { before(grammarAccess.getPackageSetAccess().getGroup()); - // InternalRos.g:69:3: ( rule__PackageSet__Group__0 ) - // InternalRos.g:69:4: rule__PackageSet__Group__0 + // InternalRosParser.g:158:3: ( rule__PackageSet__Group__0 ) + // InternalRosParser.g:158:4: rule__PackageSet__Group__0 { pushFollow(FOLLOW_2); rule__PackageSet__Group__0(); @@ -248,174 +344,20 @@ public final void rulePackageSet() throws RecognitionException { // $ANTLR end "rulePackageSet" - // $ANTLR start "entryRulePackage" - // InternalRos.g:78:1: entryRulePackage : rulePackage EOF ; - public final void entryRulePackage() throws RecognitionException { - try { - // InternalRos.g:79:1: ( rulePackage EOF ) - // InternalRos.g:80:1: rulePackage EOF - { - before(grammarAccess.getPackageRule()); - pushFollow(FOLLOW_1); - rulePackage(); - - state._fsp--; - - after(grammarAccess.getPackageRule()); - match(input,EOF,FOLLOW_2); - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return ; - } - // $ANTLR end "entryRulePackage" - - - // $ANTLR start "rulePackage" - // InternalRos.g:87:1: rulePackage : ( ( rule__Package__Alternatives ) ) ; - public final void rulePackage() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:91:2: ( ( ( rule__Package__Alternatives ) ) ) - // InternalRos.g:92:2: ( ( rule__Package__Alternatives ) ) - { - // InternalRos.g:92:2: ( ( rule__Package__Alternatives ) ) - // InternalRos.g:93:3: ( rule__Package__Alternatives ) - { - before(grammarAccess.getPackageAccess().getAlternatives()); - // InternalRos.g:94:3: ( rule__Package__Alternatives ) - // InternalRos.g:94:4: rule__Package__Alternatives - { - pushFollow(FOLLOW_2); - rule__Package__Alternatives(); - - state._fsp--; - - - } - - after(grammarAccess.getPackageAccess().getAlternatives()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rulePackage" - - - // $ANTLR start "entryRuleSpecBase" - // InternalRos.g:103:1: entryRuleSpecBase : ruleSpecBase EOF ; - public final void entryRuleSpecBase() throws RecognitionException { - try { - // InternalRos.g:104:1: ( ruleSpecBase EOF ) - // InternalRos.g:105:1: ruleSpecBase EOF - { - before(grammarAccess.getSpecBaseRule()); - pushFollow(FOLLOW_1); - ruleSpecBase(); - - state._fsp--; - - after(grammarAccess.getSpecBaseRule()); - match(input,EOF,FOLLOW_2); - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return ; - } - // $ANTLR end "entryRuleSpecBase" - - - // $ANTLR start "ruleSpecBase" - // InternalRos.g:112:1: ruleSpecBase : ( ( rule__SpecBase__Alternatives ) ) ; - public final void ruleSpecBase() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:116:2: ( ( ( rule__SpecBase__Alternatives ) ) ) - // InternalRos.g:117:2: ( ( rule__SpecBase__Alternatives ) ) - { - // InternalRos.g:117:2: ( ( rule__SpecBase__Alternatives ) ) - // InternalRos.g:118:3: ( rule__SpecBase__Alternatives ) - { - before(grammarAccess.getSpecBaseAccess().getAlternatives()); - // InternalRos.g:119:3: ( rule__SpecBase__Alternatives ) - // InternalRos.g:119:4: rule__SpecBase__Alternatives - { - pushFollow(FOLLOW_2); - rule__SpecBase__Alternatives(); - - state._fsp--; - - - } - - after(grammarAccess.getSpecBaseAccess().getAlternatives()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "ruleSpecBase" - - - // $ANTLR start "entryRuleDependency" - // InternalRos.g:128:1: entryRuleDependency : ruleDependency EOF ; - public final void entryRuleDependency() throws RecognitionException { + // $ANTLR start "entryRuleEString" + // InternalRosParser.g:167:1: entryRuleEString : ruleEString EOF ; + public final void entryRuleEString() throws RecognitionException { try { - // InternalRos.g:129:1: ( ruleDependency EOF ) - // InternalRos.g:130:1: ruleDependency EOF + // InternalRosParser.g:168:1: ( ruleEString EOF ) + // InternalRosParser.g:169:1: ruleEString EOF { - before(grammarAccess.getDependencyRule()); + before(grammarAccess.getEStringRule()); pushFollow(FOLLOW_1); - ruleDependency(); + ruleEString(); state._fsp--; - after(grammarAccess.getDependencyRule()); + after(grammarAccess.getEStringRule()); match(input,EOF,FOLLOW_2); } @@ -429,35 +371,35 @@ public final void entryRuleDependency() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleDependency" + // $ANTLR end "entryRuleEString" - // $ANTLR start "ruleDependency" - // InternalRos.g:137:1: ruleDependency : ( ( rule__Dependency__Alternatives ) ) ; - public final void ruleDependency() throws RecognitionException { + // $ANTLR start "ruleEString" + // InternalRosParser.g:176:1: ruleEString : ( ( rule__EString__Alternatives ) ) ; + public final void ruleEString() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:141:2: ( ( ( rule__Dependency__Alternatives ) ) ) - // InternalRos.g:142:2: ( ( rule__Dependency__Alternatives ) ) + // InternalRosParser.g:180:2: ( ( ( rule__EString__Alternatives ) ) ) + // InternalRosParser.g:181:2: ( ( rule__EString__Alternatives ) ) { - // InternalRos.g:142:2: ( ( rule__Dependency__Alternatives ) ) - // InternalRos.g:143:3: ( rule__Dependency__Alternatives ) + // InternalRosParser.g:181:2: ( ( rule__EString__Alternatives ) ) + // InternalRosParser.g:182:3: ( rule__EString__Alternatives ) { - before(grammarAccess.getDependencyAccess().getAlternatives()); - // InternalRos.g:144:3: ( rule__Dependency__Alternatives ) - // InternalRos.g:144:4: rule__Dependency__Alternatives + before(grammarAccess.getEStringAccess().getAlternatives()); + // InternalRosParser.g:183:3: ( rule__EString__Alternatives ) + // InternalRosParser.g:183:4: rule__EString__Alternatives { pushFollow(FOLLOW_2); - rule__Dependency__Alternatives(); + rule__EString__Alternatives(); state._fsp--; } - after(grammarAccess.getDependencyAccess().getAlternatives()); + after(grammarAccess.getEStringAccess().getAlternatives()); } @@ -476,23 +418,23 @@ public final void ruleDependency() throws RecognitionException { } return ; } - // $ANTLR end "ruleDependency" + // $ANTLR end "ruleEString" - // $ANTLR start "entryRuleNamespace" - // InternalRos.g:153:1: entryRuleNamespace : ruleNamespace EOF ; - public final void entryRuleNamespace() throws RecognitionException { + // $ANTLR start "entryRuleRosNames" + // InternalRosParser.g:192:1: entryRuleRosNames : ruleRosNames EOF ; + public final void entryRuleRosNames() throws RecognitionException { try { - // InternalRos.g:154:1: ( ruleNamespace EOF ) - // InternalRos.g:155:1: ruleNamespace EOF + // InternalRosParser.g:193:1: ( ruleRosNames EOF ) + // InternalRosParser.g:194:1: ruleRosNames EOF { - before(grammarAccess.getNamespaceRule()); + before(grammarAccess.getRosNamesRule()); pushFollow(FOLLOW_1); - ruleNamespace(); + ruleRosNames(); state._fsp--; - after(grammarAccess.getNamespaceRule()); + after(grammarAccess.getRosNamesRule()); match(input,EOF,FOLLOW_2); } @@ -506,35 +448,35 @@ public final void entryRuleNamespace() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleNamespace" + // $ANTLR end "entryRuleRosNames" - // $ANTLR start "ruleNamespace" - // InternalRos.g:162:1: ruleNamespace : ( ( rule__Namespace__Alternatives ) ) ; - public final void ruleNamespace() throws RecognitionException { + // $ANTLR start "ruleRosNames" + // InternalRosParser.g:201:1: ruleRosNames : ( ( rule__RosNames__Alternatives ) ) ; + public final void ruleRosNames() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:166:2: ( ( ( rule__Namespace__Alternatives ) ) ) - // InternalRos.g:167:2: ( ( rule__Namespace__Alternatives ) ) + // InternalRosParser.g:205:2: ( ( ( rule__RosNames__Alternatives ) ) ) + // InternalRosParser.g:206:2: ( ( rule__RosNames__Alternatives ) ) { - // InternalRos.g:167:2: ( ( rule__Namespace__Alternatives ) ) - // InternalRos.g:168:3: ( rule__Namespace__Alternatives ) + // InternalRosParser.g:206:2: ( ( rule__RosNames__Alternatives ) ) + // InternalRosParser.g:207:3: ( rule__RosNames__Alternatives ) { - before(grammarAccess.getNamespaceAccess().getAlternatives()); - // InternalRos.g:169:3: ( rule__Namespace__Alternatives ) - // InternalRos.g:169:4: rule__Namespace__Alternatives + before(grammarAccess.getRosNamesAccess().getAlternatives()); + // InternalRosParser.g:208:3: ( rule__RosNames__Alternatives ) + // InternalRosParser.g:208:4: rule__RosNames__Alternatives { pushFollow(FOLLOW_2); - rule__Namespace__Alternatives(); + rule__RosNames__Alternatives(); state._fsp--; } - after(grammarAccess.getNamespaceAccess().getAlternatives()); + after(grammarAccess.getRosNamesAccess().getAlternatives()); } @@ -553,15 +495,15 @@ public final void ruleNamespace() throws RecognitionException { } return ; } - // $ANTLR end "ruleNamespace" + // $ANTLR end "ruleRosNames" // $ANTLR start "entryRulePackage_Impl" - // InternalRos.g:178:1: entryRulePackage_Impl : rulePackage_Impl EOF ; + // InternalRosParser.g:217:1: entryRulePackage_Impl : rulePackage_Impl EOF ; public final void entryRulePackage_Impl() throws RecognitionException { try { - // InternalRos.g:179:1: ( rulePackage_Impl EOF ) - // InternalRos.g:180:1: rulePackage_Impl EOF + // InternalRosParser.g:218:1: ( rulePackage_Impl EOF ) + // InternalRosParser.g:219:1: rulePackage_Impl EOF { before(grammarAccess.getPackage_ImplRule()); pushFollow(FOLLOW_1); @@ -587,21 +529,21 @@ public final void entryRulePackage_Impl() throws RecognitionException { // $ANTLR start "rulePackage_Impl" - // InternalRos.g:187:1: rulePackage_Impl : ( ( rule__Package_Impl__Group__0 ) ) ; + // InternalRosParser.g:226:1: rulePackage_Impl : ( ( rule__Package_Impl__Group__0 ) ) ; public final void rulePackage_Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:191:2: ( ( ( rule__Package_Impl__Group__0 ) ) ) - // InternalRos.g:192:2: ( ( rule__Package_Impl__Group__0 ) ) + // InternalRosParser.g:230:2: ( ( ( rule__Package_Impl__Group__0 ) ) ) + // InternalRosParser.g:231:2: ( ( rule__Package_Impl__Group__0 ) ) { - // InternalRos.g:192:2: ( ( rule__Package_Impl__Group__0 ) ) - // InternalRos.g:193:3: ( rule__Package_Impl__Group__0 ) + // InternalRosParser.g:231:2: ( ( rule__Package_Impl__Group__0 ) ) + // InternalRosParser.g:232:3: ( rule__Package_Impl__Group__0 ) { before(grammarAccess.getPackage_ImplAccess().getGroup()); - // InternalRos.g:194:3: ( rule__Package_Impl__Group__0 ) - // InternalRos.g:194:4: rule__Package_Impl__Group__0 + // InternalRosParser.g:233:3: ( rule__Package_Impl__Group__0 ) + // InternalRosParser.g:233:4: rule__Package_Impl__Group__0 { pushFollow(FOLLOW_2); rule__Package_Impl__Group__0(); @@ -633,97 +575,20 @@ public final void rulePackage_Impl() throws RecognitionException { // $ANTLR end "rulePackage_Impl" - // $ANTLR start "entryRuleEString" - // InternalRos.g:203:1: entryRuleEString : ruleEString EOF ; - public final void entryRuleEString() throws RecognitionException { - try { - // InternalRos.g:204:1: ( ruleEString EOF ) - // InternalRos.g:205: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" - // InternalRos.g:212:1: ruleEString : ( ( rule__EString__Alternatives ) ) ; - public final void ruleEString() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:216:2: ( ( ( rule__EString__Alternatives ) ) ) - // InternalRos.g:217:2: ( ( rule__EString__Alternatives ) ) - { - // InternalRos.g:217:2: ( ( rule__EString__Alternatives ) ) - // InternalRos.g:218:3: ( rule__EString__Alternatives ) - { - before(grammarAccess.getEStringAccess().getAlternatives()); - // InternalRos.g:219:3: ( rule__EString__Alternatives ) - // InternalRos.g:219: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 "entryRuleRosNames" - // InternalRos.g:228:1: entryRuleRosNames : ruleRosNames EOF ; - public final void entryRuleRosNames() throws RecognitionException { + // $ANTLR start "entryRuleArtifact" + // InternalRosParser.g:242:1: entryRuleArtifact : ruleArtifact EOF ; + public final void entryRuleArtifact() throws RecognitionException { try { - // InternalRos.g:229:1: ( ruleRosNames EOF ) - // InternalRos.g:230:1: ruleRosNames EOF + // InternalRosParser.g:243:1: ( ruleArtifact EOF ) + // InternalRosParser.g:244:1: ruleArtifact EOF { - before(grammarAccess.getRosNamesRule()); + before(grammarAccess.getArtifactRule()); pushFollow(FOLLOW_1); - ruleRosNames(); + ruleArtifact(); state._fsp--; - after(grammarAccess.getRosNamesRule()); + after(grammarAccess.getArtifactRule()); match(input,EOF,FOLLOW_2); } @@ -737,35 +602,35 @@ public final void entryRuleRosNames() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleRosNames" + // $ANTLR end "entryRuleArtifact" - // $ANTLR start "ruleRosNames" - // InternalRos.g:237:1: ruleRosNames : ( ( rule__RosNames__Alternatives ) ) ; - public final void ruleRosNames() throws RecognitionException { + // $ANTLR start "ruleArtifact" + // InternalRosParser.g:251:1: ruleArtifact : ( ( rule__Artifact__Group__0 ) ) ; + public final void ruleArtifact() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:241:2: ( ( ( rule__RosNames__Alternatives ) ) ) - // InternalRos.g:242:2: ( ( rule__RosNames__Alternatives ) ) + // InternalRosParser.g:255:2: ( ( ( rule__Artifact__Group__0 ) ) ) + // InternalRosParser.g:256:2: ( ( rule__Artifact__Group__0 ) ) { - // InternalRos.g:242:2: ( ( rule__RosNames__Alternatives ) ) - // InternalRos.g:243:3: ( rule__RosNames__Alternatives ) + // InternalRosParser.g:256:2: ( ( rule__Artifact__Group__0 ) ) + // InternalRosParser.g:257:3: ( rule__Artifact__Group__0 ) { - before(grammarAccess.getRosNamesAccess().getAlternatives()); - // InternalRos.g:244:3: ( rule__RosNames__Alternatives ) - // InternalRos.g:244:4: rule__RosNames__Alternatives + before(grammarAccess.getArtifactAccess().getGroup()); + // InternalRosParser.g:258:3: ( rule__Artifact__Group__0 ) + // InternalRosParser.g:258:4: rule__Artifact__Group__0 { pushFollow(FOLLOW_2); - rule__RosNames__Alternatives(); + rule__Artifact__Group__0(); state._fsp--; } - after(grammarAccess.getRosNamesAccess().getAlternatives()); + after(grammarAccess.getArtifactAccess().getGroup()); } @@ -784,23 +649,23 @@ public final void ruleRosNames() throws RecognitionException { } return ; } - // $ANTLR end "ruleRosNames" + // $ANTLR end "ruleArtifact" - // $ANTLR start "entryRuleArtifact" - // InternalRos.g:253:1: entryRuleArtifact : ruleArtifact EOF ; - public final void entryRuleArtifact() throws RecognitionException { + // $ANTLR start "entryRuleNode" + // InternalRosParser.g:267:1: entryRuleNode : ruleNode EOF ; + public final void entryRuleNode() throws RecognitionException { try { - // InternalRos.g:254:1: ( ruleArtifact EOF ) - // InternalRos.g:255:1: ruleArtifact EOF + // InternalRosParser.g:268:1: ( ruleNode EOF ) + // InternalRosParser.g:269:1: ruleNode EOF { - before(grammarAccess.getArtifactRule()); + before(grammarAccess.getNodeRule()); pushFollow(FOLLOW_1); - ruleArtifact(); + ruleNode(); state._fsp--; - after(grammarAccess.getArtifactRule()); + after(grammarAccess.getNodeRule()); match(input,EOF,FOLLOW_2); } @@ -814,35 +679,35 @@ public final void entryRuleArtifact() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleArtifact" + // $ANTLR end "entryRuleNode" - // $ANTLR start "ruleArtifact" - // InternalRos.g:262:1: ruleArtifact : ( ( rule__Artifact__Group__0 ) ) ; - public final void ruleArtifact() throws RecognitionException { + // $ANTLR start "ruleNode" + // InternalRosParser.g:276:1: ruleNode : ( ( rule__Node__Group__0 ) ) ; + public final void ruleNode() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:266:2: ( ( ( rule__Artifact__Group__0 ) ) ) - // InternalRos.g:267:2: ( ( rule__Artifact__Group__0 ) ) + // InternalRosParser.g:280:2: ( ( ( rule__Node__Group__0 ) ) ) + // InternalRosParser.g:281:2: ( ( rule__Node__Group__0 ) ) { - // InternalRos.g:267:2: ( ( rule__Artifact__Group__0 ) ) - // InternalRos.g:268:3: ( rule__Artifact__Group__0 ) + // InternalRosParser.g:281:2: ( ( rule__Node__Group__0 ) ) + // InternalRosParser.g:282:3: ( rule__Node__Group__0 ) { - before(grammarAccess.getArtifactAccess().getGroup()); - // InternalRos.g:269:3: ( rule__Artifact__Group__0 ) - // InternalRos.g:269:4: rule__Artifact__Group__0 + before(grammarAccess.getNodeAccess().getGroup()); + // InternalRosParser.g:283:3: ( rule__Node__Group__0 ) + // InternalRosParser.g:283:4: rule__Node__Group__0 { pushFollow(FOLLOW_2); - rule__Artifact__Group__0(); + rule__Node__Group__0(); state._fsp--; } - after(grammarAccess.getArtifactAccess().getGroup()); + after(grammarAccess.getNodeAccess().getGroup()); } @@ -861,23 +726,23 @@ public final void ruleArtifact() throws RecognitionException { } return ; } - // $ANTLR end "ruleArtifact" + // $ANTLR end "ruleNode" - // $ANTLR start "entryRuleCatkinPackage" - // InternalRos.g:278:1: entryRuleCatkinPackage : ruleCatkinPackage EOF ; - public final void entryRuleCatkinPackage() throws RecognitionException { + // $ANTLR start "entryRuleSpecBase" + // InternalRosParser.g:292:1: entryRuleSpecBase : ruleSpecBase EOF ; + public final void entryRuleSpecBase() throws RecognitionException { try { - // InternalRos.g:279:1: ( ruleCatkinPackage EOF ) - // InternalRos.g:280:1: ruleCatkinPackage EOF + // InternalRosParser.g:293:1: ( ruleSpecBase EOF ) + // InternalRosParser.g:294:1: ruleSpecBase EOF { - before(grammarAccess.getCatkinPackageRule()); + before(grammarAccess.getSpecBaseRule()); pushFollow(FOLLOW_1); - ruleCatkinPackage(); + ruleSpecBase(); state._fsp--; - after(grammarAccess.getCatkinPackageRule()); + after(grammarAccess.getSpecBaseRule()); match(input,EOF,FOLLOW_2); } @@ -891,35 +756,35 @@ public final void entryRuleCatkinPackage() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleCatkinPackage" + // $ANTLR end "entryRuleSpecBase" - // $ANTLR start "ruleCatkinPackage" - // InternalRos.g:287:1: ruleCatkinPackage : ( ( rule__CatkinPackage__Group__0 ) ) ; - public final void ruleCatkinPackage() throws RecognitionException { + // $ANTLR start "ruleSpecBase" + // InternalRosParser.g:301:1: ruleSpecBase : ( ( rule__SpecBase__Alternatives ) ) ; + public final void ruleSpecBase() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:291:2: ( ( ( rule__CatkinPackage__Group__0 ) ) ) - // InternalRos.g:292:2: ( ( rule__CatkinPackage__Group__0 ) ) + // InternalRosParser.g:305:2: ( ( ( rule__SpecBase__Alternatives ) ) ) + // InternalRosParser.g:306:2: ( ( rule__SpecBase__Alternatives ) ) { - // InternalRos.g:292:2: ( ( rule__CatkinPackage__Group__0 ) ) - // InternalRos.g:293:3: ( rule__CatkinPackage__Group__0 ) + // InternalRosParser.g:306:2: ( ( rule__SpecBase__Alternatives ) ) + // InternalRosParser.g:307:3: ( rule__SpecBase__Alternatives ) { - before(grammarAccess.getCatkinPackageAccess().getGroup()); - // InternalRos.g:294:3: ( rule__CatkinPackage__Group__0 ) - // InternalRos.g:294:4: rule__CatkinPackage__Group__0 + before(grammarAccess.getSpecBaseAccess().getAlternatives()); + // InternalRosParser.g:308:3: ( rule__SpecBase__Alternatives ) + // InternalRosParser.g:308:4: rule__SpecBase__Alternatives { pushFollow(FOLLOW_2); - rule__CatkinPackage__Group__0(); + rule__SpecBase__Alternatives(); state._fsp--; } - after(grammarAccess.getCatkinPackageAccess().getGroup()); + after(grammarAccess.getSpecBaseAccess().getAlternatives()); } @@ -938,23 +803,23 @@ public final void ruleCatkinPackage() throws RecognitionException { } return ; } - // $ANTLR end "ruleCatkinPackage" + // $ANTLR end "ruleSpecBase" - // $ANTLR start "entryRuleAmentPackage" - // InternalRos.g:303:1: entryRuleAmentPackage : ruleAmentPackage EOF ; - public final void entryRuleAmentPackage() throws RecognitionException { + // $ANTLR start "entryRuleTopicSpec" + // InternalRosParser.g:317:1: entryRuleTopicSpec : ruleTopicSpec EOF ; + public final void entryRuleTopicSpec() throws RecognitionException { try { - // InternalRos.g:304:1: ( ruleAmentPackage EOF ) - // InternalRos.g:305:1: ruleAmentPackage EOF + // InternalRosParser.g:318:1: ( ruleTopicSpec EOF ) + // InternalRosParser.g:319:1: ruleTopicSpec EOF { - before(grammarAccess.getAmentPackageRule()); + before(grammarAccess.getTopicSpecRule()); pushFollow(FOLLOW_1); - ruleAmentPackage(); + ruleTopicSpec(); state._fsp--; - after(grammarAccess.getAmentPackageRule()); + after(grammarAccess.getTopicSpecRule()); match(input,EOF,FOLLOW_2); } @@ -968,35 +833,35 @@ public final void entryRuleAmentPackage() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleAmentPackage" + // $ANTLR end "entryRuleTopicSpec" - // $ANTLR start "ruleAmentPackage" - // InternalRos.g:312:1: ruleAmentPackage : ( ( rule__AmentPackage__Group__0 ) ) ; - public final void ruleAmentPackage() throws RecognitionException { + // $ANTLR start "ruleTopicSpec" + // InternalRosParser.g:326:1: ruleTopicSpec : ( ( rule__TopicSpec__Group__0 ) ) ; + public final void ruleTopicSpec() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:316:2: ( ( ( rule__AmentPackage__Group__0 ) ) ) - // InternalRos.g:317:2: ( ( rule__AmentPackage__Group__0 ) ) + // InternalRosParser.g:330:2: ( ( ( rule__TopicSpec__Group__0 ) ) ) + // InternalRosParser.g:331:2: ( ( rule__TopicSpec__Group__0 ) ) { - // InternalRos.g:317:2: ( ( rule__AmentPackage__Group__0 ) ) - // InternalRos.g:318:3: ( rule__AmentPackage__Group__0 ) + // InternalRosParser.g:331:2: ( ( rule__TopicSpec__Group__0 ) ) + // InternalRosParser.g:332:3: ( rule__TopicSpec__Group__0 ) { - before(grammarAccess.getAmentPackageAccess().getGroup()); - // InternalRos.g:319:3: ( rule__AmentPackage__Group__0 ) - // InternalRos.g:319:4: rule__AmentPackage__Group__0 + before(grammarAccess.getTopicSpecAccess().getGroup()); + // InternalRosParser.g:333:3: ( rule__TopicSpec__Group__0 ) + // InternalRosParser.g:333:4: rule__TopicSpec__Group__0 { pushFollow(FOLLOW_2); - rule__AmentPackage__Group__0(); + rule__TopicSpec__Group__0(); state._fsp--; } - after(grammarAccess.getAmentPackageAccess().getGroup()); + after(grammarAccess.getTopicSpecAccess().getGroup()); } @@ -1015,15 +880,15 @@ public final void ruleAmentPackage() throws RecognitionException { } return ; } - // $ANTLR end "ruleAmentPackage" + // $ANTLR end "ruleTopicSpec" // $ANTLR start "entryRuleServiceSpec" - // InternalRos.g:328:1: entryRuleServiceSpec : ruleServiceSpec EOF ; + // InternalRosParser.g:342:1: entryRuleServiceSpec : ruleServiceSpec EOF ; public final void entryRuleServiceSpec() throws RecognitionException { try { - // InternalRos.g:329:1: ( ruleServiceSpec EOF ) - // InternalRos.g:330:1: ruleServiceSpec EOF + // InternalRosParser.g:343:1: ( ruleServiceSpec EOF ) + // InternalRosParser.g:344:1: ruleServiceSpec EOF { before(grammarAccess.getServiceSpecRule()); pushFollow(FOLLOW_1); @@ -1049,21 +914,21 @@ public final void entryRuleServiceSpec() throws RecognitionException { // $ANTLR start "ruleServiceSpec" - // InternalRos.g:337:1: ruleServiceSpec : ( ( rule__ServiceSpec__Group__0 ) ) ; + // InternalRosParser.g:351:1: ruleServiceSpec : ( ( rule__ServiceSpec__Group__0 ) ) ; public final void ruleServiceSpec() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:341:2: ( ( ( rule__ServiceSpec__Group__0 ) ) ) - // InternalRos.g:342:2: ( ( rule__ServiceSpec__Group__0 ) ) + // InternalRosParser.g:355:2: ( ( ( rule__ServiceSpec__Group__0 ) ) ) + // InternalRosParser.g:356:2: ( ( rule__ServiceSpec__Group__0 ) ) { - // InternalRos.g:342:2: ( ( rule__ServiceSpec__Group__0 ) ) - // InternalRos.g:343:3: ( rule__ServiceSpec__Group__0 ) + // InternalRosParser.g:356:2: ( ( rule__ServiceSpec__Group__0 ) ) + // InternalRosParser.g:357:3: ( rule__ServiceSpec__Group__0 ) { before(grammarAccess.getServiceSpecAccess().getGroup()); - // InternalRos.g:344:3: ( rule__ServiceSpec__Group__0 ) - // InternalRos.g:344:4: rule__ServiceSpec__Group__0 + // InternalRosParser.g:358:3: ( rule__ServiceSpec__Group__0 ) + // InternalRosParser.g:358:4: rule__ServiceSpec__Group__0 { pushFollow(FOLLOW_2); rule__ServiceSpec__Group__0(); @@ -1095,20 +960,20 @@ public final void ruleServiceSpec() throws RecognitionException { // $ANTLR end "ruleServiceSpec" - // $ANTLR start "entryRuleTopicSpec" - // InternalRos.g:353:1: entryRuleTopicSpec : ruleTopicSpec EOF ; - public final void entryRuleTopicSpec() throws RecognitionException { + // $ANTLR start "entryRuleActionSpec" + // InternalRosParser.g:367:1: entryRuleActionSpec : ruleActionSpec EOF ; + public final void entryRuleActionSpec() throws RecognitionException { try { - // InternalRos.g:354:1: ( ruleTopicSpec EOF ) - // InternalRos.g:355:1: ruleTopicSpec EOF + // InternalRosParser.g:368:1: ( ruleActionSpec EOF ) + // InternalRosParser.g:369:1: ruleActionSpec EOF { - before(grammarAccess.getTopicSpecRule()); + before(grammarAccess.getActionSpecRule()); pushFollow(FOLLOW_1); - ruleTopicSpec(); + ruleActionSpec(); state._fsp--; - after(grammarAccess.getTopicSpecRule()); + after(grammarAccess.getActionSpecRule()); match(input,EOF,FOLLOW_2); } @@ -1122,35 +987,35 @@ public final void entryRuleTopicSpec() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleTopicSpec" + // $ANTLR end "entryRuleActionSpec" - // $ANTLR start "ruleTopicSpec" - // InternalRos.g:362:1: ruleTopicSpec : ( ( rule__TopicSpec__Group__0 ) ) ; - public final void ruleTopicSpec() throws RecognitionException { + // $ANTLR start "ruleActionSpec" + // InternalRosParser.g:376:1: ruleActionSpec : ( ( rule__ActionSpec__Group__0 ) ) ; + public final void ruleActionSpec() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:366:2: ( ( ( rule__TopicSpec__Group__0 ) ) ) - // InternalRos.g:367:2: ( ( rule__TopicSpec__Group__0 ) ) + // InternalRosParser.g:380:2: ( ( ( rule__ActionSpec__Group__0 ) ) ) + // InternalRosParser.g:381:2: ( ( rule__ActionSpec__Group__0 ) ) { - // InternalRos.g:367:2: ( ( rule__TopicSpec__Group__0 ) ) - // InternalRos.g:368:3: ( rule__TopicSpec__Group__0 ) + // InternalRosParser.g:381:2: ( ( rule__ActionSpec__Group__0 ) ) + // InternalRosParser.g:382:3: ( rule__ActionSpec__Group__0 ) { - before(grammarAccess.getTopicSpecAccess().getGroup()); - // InternalRos.g:369:3: ( rule__TopicSpec__Group__0 ) - // InternalRos.g:369:4: rule__TopicSpec__Group__0 + before(grammarAccess.getActionSpecAccess().getGroup()); + // InternalRosParser.g:383:3: ( rule__ActionSpec__Group__0 ) + // InternalRosParser.g:383:4: rule__ActionSpec__Group__0 { pushFollow(FOLLOW_2); - rule__TopicSpec__Group__0(); + rule__ActionSpec__Group__0(); state._fsp--; } - after(grammarAccess.getTopicSpecAccess().getGroup()); + after(grammarAccess.getActionSpecAccess().getGroup()); } @@ -1169,23 +1034,23 @@ public final void ruleTopicSpec() throws RecognitionException { } return ; } - // $ANTLR end "ruleTopicSpec" + // $ANTLR end "ruleActionSpec" - // $ANTLR start "entryRuleActionSpec" - // InternalRos.g:378:1: entryRuleActionSpec : ruleActionSpec EOF ; - public final void entryRuleActionSpec() throws RecognitionException { + // $ANTLR start "entryRuleMessageDefinition" + // InternalRosParser.g:392:1: entryRuleMessageDefinition : ruleMessageDefinition EOF ; + public final void entryRuleMessageDefinition() throws RecognitionException { try { - // InternalRos.g:379:1: ( ruleActionSpec EOF ) - // InternalRos.g:380:1: ruleActionSpec EOF + // InternalRosParser.g:393:1: ( ruleMessageDefinition EOF ) + // InternalRosParser.g:394:1: ruleMessageDefinition EOF { - before(grammarAccess.getActionSpecRule()); + before(grammarAccess.getMessageDefinitionRule()); pushFollow(FOLLOW_1); - ruleActionSpec(); + ruleMessageDefinition(); state._fsp--; - after(grammarAccess.getActionSpecRule()); + after(grammarAccess.getMessageDefinitionRule()); match(input,EOF,FOLLOW_2); } @@ -1199,35 +1064,35 @@ public final void entryRuleActionSpec() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleActionSpec" + // $ANTLR end "entryRuleMessageDefinition" - // $ANTLR start "ruleActionSpec" - // InternalRos.g:387:1: ruleActionSpec : ( ( rule__ActionSpec__Group__0 ) ) ; - public final void ruleActionSpec() throws RecognitionException { + // $ANTLR start "ruleMessageDefinition" + // InternalRosParser.g:401:1: ruleMessageDefinition : ( ( rule__MessageDefinition__Group__0 ) ) ; + public final void ruleMessageDefinition() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:391:2: ( ( ( rule__ActionSpec__Group__0 ) ) ) - // InternalRos.g:392:2: ( ( rule__ActionSpec__Group__0 ) ) + // InternalRosParser.g:405:2: ( ( ( rule__MessageDefinition__Group__0 ) ) ) + // InternalRosParser.g:406:2: ( ( rule__MessageDefinition__Group__0 ) ) { - // InternalRos.g:392:2: ( ( rule__ActionSpec__Group__0 ) ) - // InternalRos.g:393:3: ( rule__ActionSpec__Group__0 ) + // InternalRosParser.g:406:2: ( ( rule__MessageDefinition__Group__0 ) ) + // InternalRosParser.g:407:3: ( rule__MessageDefinition__Group__0 ) { - before(grammarAccess.getActionSpecAccess().getGroup()); - // InternalRos.g:394:3: ( rule__ActionSpec__Group__0 ) - // InternalRos.g:394:4: rule__ActionSpec__Group__0 + before(grammarAccess.getMessageDefinitionAccess().getGroup()); + // InternalRosParser.g:408:3: ( rule__MessageDefinition__Group__0 ) + // InternalRosParser.g:408:4: rule__MessageDefinition__Group__0 { pushFollow(FOLLOW_2); - rule__ActionSpec__Group__0(); + rule__MessageDefinition__Group__0(); state._fsp--; } - after(grammarAccess.getActionSpecAccess().getGroup()); + after(grammarAccess.getMessageDefinitionAccess().getGroup()); } @@ -1246,23 +1111,23 @@ public final void ruleActionSpec() throws RecognitionException { } return ; } - // $ANTLR end "ruleActionSpec" + // $ANTLR end "ruleMessageDefinition" - // $ANTLR start "entryRuleMessageDefinition" - // InternalRos.g:403:1: entryRuleMessageDefinition : ruleMessageDefinition EOF ; - public final void entryRuleMessageDefinition() throws RecognitionException { + // $ANTLR start "entryRulePublisher" + // InternalRosParser.g:417:1: entryRulePublisher : rulePublisher EOF ; + public final void entryRulePublisher() throws RecognitionException { try { - // InternalRos.g:404:1: ( ruleMessageDefinition EOF ) - // InternalRos.g:405:1: ruleMessageDefinition EOF + // InternalRosParser.g:418:1: ( rulePublisher EOF ) + // InternalRosParser.g:419:1: rulePublisher EOF { - before(grammarAccess.getMessageDefinitionRule()); + before(grammarAccess.getPublisherRule()); pushFollow(FOLLOW_1); - ruleMessageDefinition(); + rulePublisher(); state._fsp--; - after(grammarAccess.getMessageDefinitionRule()); + after(grammarAccess.getPublisherRule()); match(input,EOF,FOLLOW_2); } @@ -1276,35 +1141,35 @@ public final void entryRuleMessageDefinition() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleMessageDefinition" + // $ANTLR end "entryRulePublisher" - // $ANTLR start "ruleMessageDefinition" - // InternalRos.g:412:1: ruleMessageDefinition : ( ( rule__MessageDefinition__Group__0 ) ) ; - public final void ruleMessageDefinition() throws RecognitionException { + // $ANTLR start "rulePublisher" + // InternalRosParser.g:426:1: rulePublisher : ( ( rule__Publisher__Group__0 ) ) ; + public final void rulePublisher() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:416:2: ( ( ( rule__MessageDefinition__Group__0 ) ) ) - // InternalRos.g:417:2: ( ( rule__MessageDefinition__Group__0 ) ) + // InternalRosParser.g:430:2: ( ( ( rule__Publisher__Group__0 ) ) ) + // InternalRosParser.g:431:2: ( ( rule__Publisher__Group__0 ) ) { - // InternalRos.g:417:2: ( ( rule__MessageDefinition__Group__0 ) ) - // InternalRos.g:418:3: ( rule__MessageDefinition__Group__0 ) + // InternalRosParser.g:431:2: ( ( rule__Publisher__Group__0 ) ) + // InternalRosParser.g:432:3: ( rule__Publisher__Group__0 ) { - before(grammarAccess.getMessageDefinitionAccess().getGroup()); - // InternalRos.g:419:3: ( rule__MessageDefinition__Group__0 ) - // InternalRos.g:419:4: rule__MessageDefinition__Group__0 + before(grammarAccess.getPublisherAccess().getGroup()); + // InternalRosParser.g:433:3: ( rule__Publisher__Group__0 ) + // InternalRosParser.g:433:4: rule__Publisher__Group__0 { pushFollow(FOLLOW_2); - rule__MessageDefinition__Group__0(); + rule__Publisher__Group__0(); state._fsp--; } - after(grammarAccess.getMessageDefinitionAccess().getGroup()); + after(grammarAccess.getPublisherAccess().getGroup()); } @@ -1323,23 +1188,23 @@ public final void ruleMessageDefinition() throws RecognitionException { } return ; } - // $ANTLR end "ruleMessageDefinition" + // $ANTLR end "rulePublisher" - // $ANTLR start "entryRuleNode" - // InternalRos.g:428:1: entryRuleNode : ruleNode EOF ; - public final void entryRuleNode() throws RecognitionException { + // $ANTLR start "entryRuleSubscriber" + // InternalRosParser.g:442:1: entryRuleSubscriber : ruleSubscriber EOF ; + public final void entryRuleSubscriber() throws RecognitionException { try { - // InternalRos.g:429:1: ( ruleNode EOF ) - // InternalRos.g:430:1: ruleNode EOF + // InternalRosParser.g:443:1: ( ruleSubscriber EOF ) + // InternalRosParser.g:444:1: ruleSubscriber EOF { - before(grammarAccess.getNodeRule()); + before(grammarAccess.getSubscriberRule()); pushFollow(FOLLOW_1); - ruleNode(); + ruleSubscriber(); state._fsp--; - after(grammarAccess.getNodeRule()); + after(grammarAccess.getSubscriberRule()); match(input,EOF,FOLLOW_2); } @@ -1353,35 +1218,35 @@ public final void entryRuleNode() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleNode" + // $ANTLR end "entryRuleSubscriber" - // $ANTLR start "ruleNode" - // InternalRos.g:437:1: ruleNode : ( ( rule__Node__Group__0 ) ) ; - public final void ruleNode() throws RecognitionException { + // $ANTLR start "ruleSubscriber" + // InternalRosParser.g:451:1: ruleSubscriber : ( ( rule__Subscriber__Group__0 ) ) ; + public final void ruleSubscriber() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:441:2: ( ( ( rule__Node__Group__0 ) ) ) - // InternalRos.g:442:2: ( ( rule__Node__Group__0 ) ) + // InternalRosParser.g:455:2: ( ( ( rule__Subscriber__Group__0 ) ) ) + // InternalRosParser.g:456:2: ( ( rule__Subscriber__Group__0 ) ) { - // InternalRos.g:442:2: ( ( rule__Node__Group__0 ) ) - // InternalRos.g:443:3: ( rule__Node__Group__0 ) + // InternalRosParser.g:456:2: ( ( rule__Subscriber__Group__0 ) ) + // InternalRosParser.g:457:3: ( rule__Subscriber__Group__0 ) { - before(grammarAccess.getNodeAccess().getGroup()); - // InternalRos.g:444:3: ( rule__Node__Group__0 ) - // InternalRos.g:444:4: rule__Node__Group__0 + before(grammarAccess.getSubscriberAccess().getGroup()); + // InternalRosParser.g:458:3: ( rule__Subscriber__Group__0 ) + // InternalRosParser.g:458:4: rule__Subscriber__Group__0 { pushFollow(FOLLOW_2); - rule__Node__Group__0(); + rule__Subscriber__Group__0(); state._fsp--; } - after(grammarAccess.getNodeAccess().getGroup()); + after(grammarAccess.getSubscriberAccess().getGroup()); } @@ -1400,15 +1265,15 @@ public final void ruleNode() throws RecognitionException { } return ; } - // $ANTLR end "ruleNode" + // $ANTLR end "ruleSubscriber" // $ANTLR start "entryRuleServiceServer" - // InternalRos.g:453:1: entryRuleServiceServer : ruleServiceServer EOF ; + // InternalRosParser.g:467:1: entryRuleServiceServer : ruleServiceServer EOF ; public final void entryRuleServiceServer() throws RecognitionException { try { - // InternalRos.g:454:1: ( ruleServiceServer EOF ) - // InternalRos.g:455:1: ruleServiceServer EOF + // InternalRosParser.g:468:1: ( ruleServiceServer EOF ) + // InternalRosParser.g:469:1: ruleServiceServer EOF { before(grammarAccess.getServiceServerRule()); pushFollow(FOLLOW_1); @@ -1434,21 +1299,21 @@ public final void entryRuleServiceServer() throws RecognitionException { // $ANTLR start "ruleServiceServer" - // InternalRos.g:462:1: ruleServiceServer : ( ( rule__ServiceServer__Group__0 ) ) ; + // InternalRosParser.g:476:1: ruleServiceServer : ( ( rule__ServiceServer__Group__0 ) ) ; public final void ruleServiceServer() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:466:2: ( ( ( rule__ServiceServer__Group__0 ) ) ) - // InternalRos.g:467:2: ( ( rule__ServiceServer__Group__0 ) ) + // InternalRosParser.g:480:2: ( ( ( rule__ServiceServer__Group__0 ) ) ) + // InternalRosParser.g:481:2: ( ( rule__ServiceServer__Group__0 ) ) { - // InternalRos.g:467:2: ( ( rule__ServiceServer__Group__0 ) ) - // InternalRos.g:468:3: ( rule__ServiceServer__Group__0 ) + // InternalRosParser.g:481:2: ( ( rule__ServiceServer__Group__0 ) ) + // InternalRosParser.g:482:3: ( rule__ServiceServer__Group__0 ) { before(grammarAccess.getServiceServerAccess().getGroup()); - // InternalRos.g:469:3: ( rule__ServiceServer__Group__0 ) - // InternalRos.g:469:4: rule__ServiceServer__Group__0 + // InternalRosParser.g:483:3: ( rule__ServiceServer__Group__0 ) + // InternalRosParser.g:483:4: rule__ServiceServer__Group__0 { pushFollow(FOLLOW_2); rule__ServiceServer__Group__0(); @@ -1480,20 +1345,20 @@ public final void ruleServiceServer() throws RecognitionException { // $ANTLR end "ruleServiceServer" - // $ANTLR start "entryRulePublisher" - // InternalRos.g:478:1: entryRulePublisher : rulePublisher EOF ; - public final void entryRulePublisher() throws RecognitionException { + // $ANTLR start "entryRuleServiceClient" + // InternalRosParser.g:492:1: entryRuleServiceClient : ruleServiceClient EOF ; + public final void entryRuleServiceClient() throws RecognitionException { try { - // InternalRos.g:479:1: ( rulePublisher EOF ) - // InternalRos.g:480:1: rulePublisher EOF + // InternalRosParser.g:493:1: ( ruleServiceClient EOF ) + // InternalRosParser.g:494:1: ruleServiceClient EOF { - before(grammarAccess.getPublisherRule()); + before(grammarAccess.getServiceClientRule()); pushFollow(FOLLOW_1); - rulePublisher(); + ruleServiceClient(); state._fsp--; - after(grammarAccess.getPublisherRule()); + after(grammarAccess.getServiceClientRule()); match(input,EOF,FOLLOW_2); } @@ -1507,35 +1372,35 @@ public final void entryRulePublisher() throws RecognitionException { } return ; } - // $ANTLR end "entryRulePublisher" + // $ANTLR end "entryRuleServiceClient" - // $ANTLR start "rulePublisher" - // InternalRos.g:487:1: rulePublisher : ( ( rule__Publisher__Group__0 ) ) ; - public final void rulePublisher() throws RecognitionException { + // $ANTLR start "ruleServiceClient" + // InternalRosParser.g:501:1: ruleServiceClient : ( ( rule__ServiceClient__Group__0 ) ) ; + public final void ruleServiceClient() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:491:2: ( ( ( rule__Publisher__Group__0 ) ) ) - // InternalRos.g:492:2: ( ( rule__Publisher__Group__0 ) ) + // InternalRosParser.g:505:2: ( ( ( rule__ServiceClient__Group__0 ) ) ) + // InternalRosParser.g:506:2: ( ( rule__ServiceClient__Group__0 ) ) { - // InternalRos.g:492:2: ( ( rule__Publisher__Group__0 ) ) - // InternalRos.g:493:3: ( rule__Publisher__Group__0 ) + // InternalRosParser.g:506:2: ( ( rule__ServiceClient__Group__0 ) ) + // InternalRosParser.g:507:3: ( rule__ServiceClient__Group__0 ) { - before(grammarAccess.getPublisherAccess().getGroup()); - // InternalRos.g:494:3: ( rule__Publisher__Group__0 ) - // InternalRos.g:494:4: rule__Publisher__Group__0 + before(grammarAccess.getServiceClientAccess().getGroup()); + // InternalRosParser.g:508:3: ( rule__ServiceClient__Group__0 ) + // InternalRosParser.g:508:4: rule__ServiceClient__Group__0 { pushFollow(FOLLOW_2); - rule__Publisher__Group__0(); + rule__ServiceClient__Group__0(); state._fsp--; } - after(grammarAccess.getPublisherAccess().getGroup()); + after(grammarAccess.getServiceClientAccess().getGroup()); } @@ -1554,23 +1419,23 @@ public final void rulePublisher() throws RecognitionException { } return ; } - // $ANTLR end "rulePublisher" + // $ANTLR end "ruleServiceClient" - // $ANTLR start "entryRuleSubscriber" - // InternalRos.g:503:1: entryRuleSubscriber : ruleSubscriber EOF ; - public final void entryRuleSubscriber() throws RecognitionException { + // $ANTLR start "entryRuleActionServer" + // InternalRosParser.g:517:1: entryRuleActionServer : ruleActionServer EOF ; + public final void entryRuleActionServer() throws RecognitionException { try { - // InternalRos.g:504:1: ( ruleSubscriber EOF ) - // InternalRos.g:505:1: ruleSubscriber EOF + // InternalRosParser.g:518:1: ( ruleActionServer EOF ) + // InternalRosParser.g:519:1: ruleActionServer EOF { - before(grammarAccess.getSubscriberRule()); + before(grammarAccess.getActionServerRule()); pushFollow(FOLLOW_1); - ruleSubscriber(); + ruleActionServer(); state._fsp--; - after(grammarAccess.getSubscriberRule()); + after(grammarAccess.getActionServerRule()); match(input,EOF,FOLLOW_2); } @@ -1584,35 +1449,35 @@ public final void entryRuleSubscriber() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleSubscriber" + // $ANTLR end "entryRuleActionServer" - // $ANTLR start "ruleSubscriber" - // InternalRos.g:512:1: ruleSubscriber : ( ( rule__Subscriber__Group__0 ) ) ; - public final void ruleSubscriber() throws RecognitionException { + // $ANTLR start "ruleActionServer" + // InternalRosParser.g:526:1: ruleActionServer : ( ( rule__ActionServer__Group__0 ) ) ; + public final void ruleActionServer() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:516:2: ( ( ( rule__Subscriber__Group__0 ) ) ) - // InternalRos.g:517:2: ( ( rule__Subscriber__Group__0 ) ) + // InternalRosParser.g:530:2: ( ( ( rule__ActionServer__Group__0 ) ) ) + // InternalRosParser.g:531:2: ( ( rule__ActionServer__Group__0 ) ) { - // InternalRos.g:517:2: ( ( rule__Subscriber__Group__0 ) ) - // InternalRos.g:518:3: ( rule__Subscriber__Group__0 ) + // InternalRosParser.g:531:2: ( ( rule__ActionServer__Group__0 ) ) + // InternalRosParser.g:532:3: ( rule__ActionServer__Group__0 ) { - before(grammarAccess.getSubscriberAccess().getGroup()); - // InternalRos.g:519:3: ( rule__Subscriber__Group__0 ) - // InternalRos.g:519:4: rule__Subscriber__Group__0 + before(grammarAccess.getActionServerAccess().getGroup()); + // InternalRosParser.g:533:3: ( rule__ActionServer__Group__0 ) + // InternalRosParser.g:533:4: rule__ActionServer__Group__0 { pushFollow(FOLLOW_2); - rule__Subscriber__Group__0(); + rule__ActionServer__Group__0(); state._fsp--; } - after(grammarAccess.getSubscriberAccess().getGroup()); + after(grammarAccess.getActionServerAccess().getGroup()); } @@ -1631,23 +1496,23 @@ public final void ruleSubscriber() throws RecognitionException { } return ; } - // $ANTLR end "ruleSubscriber" + // $ANTLR end "ruleActionServer" - // $ANTLR start "entryRuleServiceClient" - // InternalRos.g:528:1: entryRuleServiceClient : ruleServiceClient EOF ; - public final void entryRuleServiceClient() throws RecognitionException { + // $ANTLR start "entryRuleActionClient" + // InternalRosParser.g:542:1: entryRuleActionClient : ruleActionClient EOF ; + public final void entryRuleActionClient() throws RecognitionException { try { - // InternalRos.g:529:1: ( ruleServiceClient EOF ) - // InternalRos.g:530:1: ruleServiceClient EOF + // InternalRosParser.g:543:1: ( ruleActionClient EOF ) + // InternalRosParser.g:544:1: ruleActionClient EOF { - before(grammarAccess.getServiceClientRule()); + before(grammarAccess.getActionClientRule()); pushFollow(FOLLOW_1); - ruleServiceClient(); + ruleActionClient(); state._fsp--; - after(grammarAccess.getServiceClientRule()); + after(grammarAccess.getActionClientRule()); match(input,EOF,FOLLOW_2); } @@ -1661,35 +1526,35 @@ public final void entryRuleServiceClient() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleServiceClient" + // $ANTLR end "entryRuleActionClient" - // $ANTLR start "ruleServiceClient" - // InternalRos.g:537:1: ruleServiceClient : ( ( rule__ServiceClient__Group__0 ) ) ; - public final void ruleServiceClient() throws RecognitionException { + // $ANTLR start "ruleActionClient" + // InternalRosParser.g:551:1: ruleActionClient : ( ( rule__ActionClient__Group__0 ) ) ; + public final void ruleActionClient() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:541:2: ( ( ( rule__ServiceClient__Group__0 ) ) ) - // InternalRos.g:542:2: ( ( rule__ServiceClient__Group__0 ) ) + // InternalRosParser.g:555:2: ( ( ( rule__ActionClient__Group__0 ) ) ) + // InternalRosParser.g:556:2: ( ( rule__ActionClient__Group__0 ) ) { - // InternalRos.g:542:2: ( ( rule__ServiceClient__Group__0 ) ) - // InternalRos.g:543:3: ( rule__ServiceClient__Group__0 ) + // InternalRosParser.g:556:2: ( ( rule__ActionClient__Group__0 ) ) + // InternalRosParser.g:557:3: ( rule__ActionClient__Group__0 ) { - before(grammarAccess.getServiceClientAccess().getGroup()); - // InternalRos.g:544:3: ( rule__ServiceClient__Group__0 ) - // InternalRos.g:544:4: rule__ServiceClient__Group__0 + before(grammarAccess.getActionClientAccess().getGroup()); + // InternalRosParser.g:558:3: ( rule__ActionClient__Group__0 ) + // InternalRosParser.g:558:4: rule__ActionClient__Group__0 { pushFollow(FOLLOW_2); - rule__ServiceClient__Group__0(); + rule__ActionClient__Group__0(); state._fsp--; } - after(grammarAccess.getServiceClientAccess().getGroup()); + after(grammarAccess.getActionClientAccess().getGroup()); } @@ -1708,23 +1573,23 @@ public final void ruleServiceClient() throws RecognitionException { } return ; } - // $ANTLR end "ruleServiceClient" + // $ANTLR end "ruleActionClient" - // $ANTLR start "entryRuleActionServer" - // InternalRos.g:553:1: entryRuleActionServer : ruleActionServer EOF ; - public final void entryRuleActionServer() throws RecognitionException { + // $ANTLR start "entryRuleDependency" + // InternalRosParser.g:567:1: entryRuleDependency : ruleDependency EOF ; + public final void entryRuleDependency() throws RecognitionException { try { - // InternalRos.g:554:1: ( ruleActionServer EOF ) - // InternalRos.g:555:1: ruleActionServer EOF + // InternalRosParser.g:568:1: ( ruleDependency EOF ) + // InternalRosParser.g:569:1: ruleDependency EOF { - before(grammarAccess.getActionServerRule()); + before(grammarAccess.getDependencyRule()); pushFollow(FOLLOW_1); - ruleActionServer(); + ruleDependency(); state._fsp--; - after(grammarAccess.getActionServerRule()); + after(grammarAccess.getDependencyRule()); match(input,EOF,FOLLOW_2); } @@ -1738,35 +1603,35 @@ public final void entryRuleActionServer() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleActionServer" + // $ANTLR end "entryRuleDependency" - // $ANTLR start "ruleActionServer" - // InternalRos.g:562:1: ruleActionServer : ( ( rule__ActionServer__Group__0 ) ) ; - public final void ruleActionServer() throws RecognitionException { + // $ANTLR start "ruleDependency" + // InternalRosParser.g:576:1: ruleDependency : ( ( rule__Dependency__Alternatives ) ) ; + public final void ruleDependency() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:566:2: ( ( ( rule__ActionServer__Group__0 ) ) ) - // InternalRos.g:567:2: ( ( rule__ActionServer__Group__0 ) ) + // InternalRosParser.g:580:2: ( ( ( rule__Dependency__Alternatives ) ) ) + // InternalRosParser.g:581:2: ( ( rule__Dependency__Alternatives ) ) { - // InternalRos.g:567:2: ( ( rule__ActionServer__Group__0 ) ) - // InternalRos.g:568:3: ( rule__ActionServer__Group__0 ) + // InternalRosParser.g:581:2: ( ( rule__Dependency__Alternatives ) ) + // InternalRosParser.g:582:3: ( rule__Dependency__Alternatives ) { - before(grammarAccess.getActionServerAccess().getGroup()); - // InternalRos.g:569:3: ( rule__ActionServer__Group__0 ) - // InternalRos.g:569:4: rule__ActionServer__Group__0 + before(grammarAccess.getDependencyAccess().getAlternatives()); + // InternalRosParser.g:583:3: ( rule__Dependency__Alternatives ) + // InternalRosParser.g:583:4: rule__Dependency__Alternatives { pushFollow(FOLLOW_2); - rule__ActionServer__Group__0(); + rule__Dependency__Alternatives(); state._fsp--; } - after(grammarAccess.getActionServerAccess().getGroup()); + after(grammarAccess.getDependencyAccess().getAlternatives()); } @@ -1785,23 +1650,23 @@ public final void ruleActionServer() throws RecognitionException { } return ; } - // $ANTLR end "ruleActionServer" + // $ANTLR end "ruleDependency" - // $ANTLR start "entryRuleActionClient" - // InternalRos.g:578:1: entryRuleActionClient : ruleActionClient EOF ; - public final void entryRuleActionClient() throws RecognitionException { + // $ANTLR start "entryRulePackageDependency" + // InternalRosParser.g:592:1: entryRulePackageDependency : rulePackageDependency EOF ; + public final void entryRulePackageDependency() throws RecognitionException { try { - // InternalRos.g:579:1: ( ruleActionClient EOF ) - // InternalRos.g:580:1: ruleActionClient EOF + // InternalRosParser.g:593:1: ( rulePackageDependency EOF ) + // InternalRosParser.g:594:1: rulePackageDependency EOF { - before(grammarAccess.getActionClientRule()); + before(grammarAccess.getPackageDependencyRule()); pushFollow(FOLLOW_1); - ruleActionClient(); + rulePackageDependency(); state._fsp--; - after(grammarAccess.getActionClientRule()); + after(grammarAccess.getPackageDependencyRule()); match(input,EOF,FOLLOW_2); } @@ -1815,35 +1680,35 @@ public final void entryRuleActionClient() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleActionClient" + // $ANTLR end "entryRulePackageDependency" - // $ANTLR start "ruleActionClient" - // InternalRos.g:587:1: ruleActionClient : ( ( rule__ActionClient__Group__0 ) ) ; - public final void ruleActionClient() throws RecognitionException { + // $ANTLR start "rulePackageDependency" + // InternalRosParser.g:601:1: rulePackageDependency : ( ( rule__PackageDependency__PackageAssignment ) ) ; + public final void rulePackageDependency() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:591:2: ( ( ( rule__ActionClient__Group__0 ) ) ) - // InternalRos.g:592:2: ( ( rule__ActionClient__Group__0 ) ) + // InternalRosParser.g:605:2: ( ( ( rule__PackageDependency__PackageAssignment ) ) ) + // InternalRosParser.g:606:2: ( ( rule__PackageDependency__PackageAssignment ) ) { - // InternalRos.g:592:2: ( ( rule__ActionClient__Group__0 ) ) - // InternalRos.g:593:3: ( rule__ActionClient__Group__0 ) + // InternalRosParser.g:606:2: ( ( rule__PackageDependency__PackageAssignment ) ) + // InternalRosParser.g:607:3: ( rule__PackageDependency__PackageAssignment ) { - before(grammarAccess.getActionClientAccess().getGroup()); - // InternalRos.g:594:3: ( rule__ActionClient__Group__0 ) - // InternalRos.g:594:4: rule__ActionClient__Group__0 + before(grammarAccess.getPackageDependencyAccess().getPackageAssignment()); + // InternalRosParser.g:608:3: ( rule__PackageDependency__PackageAssignment ) + // InternalRosParser.g:608:4: rule__PackageDependency__PackageAssignment { pushFollow(FOLLOW_2); - rule__ActionClient__Group__0(); + rule__PackageDependency__PackageAssignment(); state._fsp--; } - after(grammarAccess.getActionClientAccess().getGroup()); + after(grammarAccess.getPackageDependencyAccess().getPackageAssignment()); } @@ -1862,23 +1727,23 @@ public final void ruleActionClient() throws RecognitionException { } return ; } - // $ANTLR end "ruleActionClient" + // $ANTLR end "rulePackageDependency" - // $ANTLR start "entryRuleGraphName" - // InternalRos.g:603:1: entryRuleGraphName : ruleGraphName EOF ; - public final void entryRuleGraphName() throws RecognitionException { + // $ANTLR start "entryRuleExternalDependency" + // InternalRosParser.g:617:1: entryRuleExternalDependency : ruleExternalDependency EOF ; + public final void entryRuleExternalDependency() throws RecognitionException { try { - // InternalRos.g:604:1: ( ruleGraphName EOF ) - // InternalRos.g:605:1: ruleGraphName EOF + // InternalRosParser.g:618:1: ( ruleExternalDependency EOF ) + // InternalRosParser.g:619:1: ruleExternalDependency EOF { - before(grammarAccess.getGraphNameRule()); + before(grammarAccess.getExternalDependencyRule()); pushFollow(FOLLOW_1); - ruleGraphName(); + ruleExternalDependency(); state._fsp--; - after(grammarAccess.getGraphNameRule()); + after(grammarAccess.getExternalDependencyRule()); match(input,EOF,FOLLOW_2); } @@ -1892,25 +1757,35 @@ public final void entryRuleGraphName() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleGraphName" + // $ANTLR end "entryRuleExternalDependency" - // $ANTLR start "ruleGraphName" - // InternalRos.g:612:1: ruleGraphName : ( 'GraphName' ) ; - public final void ruleGraphName() throws RecognitionException { + // $ANTLR start "ruleExternalDependency" + // InternalRosParser.g:626:1: ruleExternalDependency : ( ( rule__ExternalDependency__Group__0 ) ) ; + public final void ruleExternalDependency() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:616:2: ( ( 'GraphName' ) ) - // InternalRos.g:617:2: ( 'GraphName' ) + // InternalRosParser.g:630:2: ( ( ( rule__ExternalDependency__Group__0 ) ) ) + // InternalRosParser.g:631:2: ( ( rule__ExternalDependency__Group__0 ) ) { - // InternalRos.g:617:2: ( 'GraphName' ) - // InternalRos.g:618:3: 'GraphName' + // InternalRosParser.g:631:2: ( ( rule__ExternalDependency__Group__0 ) ) + // InternalRosParser.g:632:3: ( rule__ExternalDependency__Group__0 ) { - before(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); - match(input,25,FOLLOW_2); - after(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + before(grammarAccess.getExternalDependencyAccess().getGroup()); + // InternalRosParser.g:633:3: ( rule__ExternalDependency__Group__0 ) + // InternalRosParser.g:633:4: rule__ExternalDependency__Group__0 + { + pushFollow(FOLLOW_2); + rule__ExternalDependency__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getExternalDependencyAccess().getGroup()); } @@ -1929,23 +1804,23 @@ public final void ruleGraphName() throws RecognitionException { } return ; } - // $ANTLR end "ruleGraphName" + // $ANTLR end "ruleExternalDependency" - // $ANTLR start "entryRulePackageDependency" - // InternalRos.g:628:1: entryRulePackageDependency : rulePackageDependency EOF ; - public final void entryRulePackageDependency() throws RecognitionException { + // $ANTLR start "entryRuleNamespace" + // InternalRosParser.g:642:1: entryRuleNamespace : ruleNamespace EOF ; + public final void entryRuleNamespace() throws RecognitionException { try { - // InternalRos.g:629:1: ( rulePackageDependency EOF ) - // InternalRos.g:630:1: rulePackageDependency EOF + // InternalRosParser.g:643:1: ( ruleNamespace EOF ) + // InternalRosParser.g:644:1: ruleNamespace EOF { - before(grammarAccess.getPackageDependencyRule()); + before(grammarAccess.getNamespaceRule()); pushFollow(FOLLOW_1); - rulePackageDependency(); + ruleNamespace(); state._fsp--; - after(grammarAccess.getPackageDependencyRule()); + after(grammarAccess.getNamespaceRule()); match(input,EOF,FOLLOW_2); } @@ -1959,35 +1834,35 @@ public final void entryRulePackageDependency() throws RecognitionException { } return ; } - // $ANTLR end "entryRulePackageDependency" + // $ANTLR end "entryRuleNamespace" - // $ANTLR start "rulePackageDependency" - // InternalRos.g:637:1: rulePackageDependency : ( ( rule__PackageDependency__PackageAssignment ) ) ; - public final void rulePackageDependency() throws RecognitionException { + // $ANTLR start "ruleNamespace" + // InternalRosParser.g:651:1: ruleNamespace : ( ( rule__Namespace__Alternatives ) ) ; + public final void ruleNamespace() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:641:2: ( ( ( rule__PackageDependency__PackageAssignment ) ) ) - // InternalRos.g:642:2: ( ( rule__PackageDependency__PackageAssignment ) ) + // InternalRosParser.g:655:2: ( ( ( rule__Namespace__Alternatives ) ) ) + // InternalRosParser.g:656:2: ( ( rule__Namespace__Alternatives ) ) { - // InternalRos.g:642:2: ( ( rule__PackageDependency__PackageAssignment ) ) - // InternalRos.g:643:3: ( rule__PackageDependency__PackageAssignment ) + // InternalRosParser.g:656:2: ( ( rule__Namespace__Alternatives ) ) + // InternalRosParser.g:657:3: ( rule__Namespace__Alternatives ) { - before(grammarAccess.getPackageDependencyAccess().getPackageAssignment()); - // InternalRos.g:644:3: ( rule__PackageDependency__PackageAssignment ) - // InternalRos.g:644:4: rule__PackageDependency__PackageAssignment + before(grammarAccess.getNamespaceAccess().getAlternatives()); + // InternalRosParser.g:658:3: ( rule__Namespace__Alternatives ) + // InternalRosParser.g:658:4: rule__Namespace__Alternatives { pushFollow(FOLLOW_2); - rule__PackageDependency__PackageAssignment(); + rule__Namespace__Alternatives(); state._fsp--; } - after(grammarAccess.getPackageDependencyAccess().getPackageAssignment()); + after(grammarAccess.getNamespaceAccess().getAlternatives()); } @@ -2006,23 +1881,23 @@ public final void rulePackageDependency() throws RecognitionException { } return ; } - // $ANTLR end "rulePackageDependency" + // $ANTLR end "ruleNamespace" - // $ANTLR start "entryRuleExternalDependency" - // InternalRos.g:653:1: entryRuleExternalDependency : ruleExternalDependency EOF ; - public final void entryRuleExternalDependency() throws RecognitionException { + // $ANTLR start "entryRuleGraphName" + // InternalRosParser.g:667:1: entryRuleGraphName : ruleGraphName EOF ; + public final void entryRuleGraphName() throws RecognitionException { try { - // InternalRos.g:654:1: ( ruleExternalDependency EOF ) - // InternalRos.g:655:1: ruleExternalDependency EOF + // InternalRosParser.g:668:1: ( ruleGraphName EOF ) + // InternalRosParser.g:669:1: ruleGraphName EOF { - before(grammarAccess.getExternalDependencyRule()); + before(grammarAccess.getGraphNameRule()); pushFollow(FOLLOW_1); - ruleExternalDependency(); + ruleGraphName(); state._fsp--; - after(grammarAccess.getExternalDependencyRule()); + after(grammarAccess.getGraphNameRule()); match(input,EOF,FOLLOW_2); } @@ -2036,35 +1911,25 @@ public final void entryRuleExternalDependency() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleExternalDependency" + // $ANTLR end "entryRuleGraphName" - // $ANTLR start "ruleExternalDependency" - // InternalRos.g:662:1: ruleExternalDependency : ( ( rule__ExternalDependency__Group__0 ) ) ; - public final void ruleExternalDependency() throws RecognitionException { + // $ANTLR start "ruleGraphName" + // InternalRosParser.g:676:1: ruleGraphName : ( GraphName ) ; + public final void ruleGraphName() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:666:2: ( ( ( rule__ExternalDependency__Group__0 ) ) ) - // InternalRos.g:667:2: ( ( rule__ExternalDependency__Group__0 ) ) - { - // InternalRos.g:667:2: ( ( rule__ExternalDependency__Group__0 ) ) - // InternalRos.g:668:3: ( rule__ExternalDependency__Group__0 ) + // InternalRosParser.g:680:2: ( ( GraphName ) ) + // InternalRosParser.g:681:2: ( GraphName ) { - before(grammarAccess.getExternalDependencyAccess().getGroup()); - // InternalRos.g:669:3: ( rule__ExternalDependency__Group__0 ) - // InternalRos.g:669:4: rule__ExternalDependency__Group__0 + // InternalRosParser.g:681:2: ( GraphName ) + // InternalRosParser.g:682:3: GraphName { - pushFollow(FOLLOW_2); - rule__ExternalDependency__Group__0(); - - state._fsp--; - - - } - - after(grammarAccess.getExternalDependencyAccess().getGroup()); + before(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + match(input,GraphName,FOLLOW_2); + after(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); } @@ -2083,15 +1948,15 @@ public final void ruleExternalDependency() throws RecognitionException { } return ; } - // $ANTLR end "ruleExternalDependency" + // $ANTLR end "ruleGraphName" // $ANTLR start "entryRuleGlobalNamespace" - // InternalRos.g:678:1: entryRuleGlobalNamespace : ruleGlobalNamespace EOF ; + // InternalRosParser.g:692:1: entryRuleGlobalNamespace : ruleGlobalNamespace EOF ; public final void entryRuleGlobalNamespace() throws RecognitionException { try { - // InternalRos.g:679:1: ( ruleGlobalNamespace EOF ) - // InternalRos.g:680:1: ruleGlobalNamespace EOF + // InternalRosParser.g:693:1: ( ruleGlobalNamespace EOF ) + // InternalRosParser.g:694:1: ruleGlobalNamespace EOF { before(grammarAccess.getGlobalNamespaceRule()); pushFollow(FOLLOW_1); @@ -2117,21 +1982,21 @@ public final void entryRuleGlobalNamespace() throws RecognitionException { // $ANTLR start "ruleGlobalNamespace" - // InternalRos.g:687:1: ruleGlobalNamespace : ( ( rule__GlobalNamespace__Group__0 ) ) ; + // InternalRosParser.g:701:1: ruleGlobalNamespace : ( ( rule__GlobalNamespace__Group__0 ) ) ; public final void ruleGlobalNamespace() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:691:2: ( ( ( rule__GlobalNamespace__Group__0 ) ) ) - // InternalRos.g:692:2: ( ( rule__GlobalNamespace__Group__0 ) ) + // InternalRosParser.g:705:2: ( ( ( rule__GlobalNamespace__Group__0 ) ) ) + // InternalRosParser.g:706:2: ( ( rule__GlobalNamespace__Group__0 ) ) { - // InternalRos.g:692:2: ( ( rule__GlobalNamespace__Group__0 ) ) - // InternalRos.g:693:3: ( rule__GlobalNamespace__Group__0 ) + // InternalRosParser.g:706:2: ( ( rule__GlobalNamespace__Group__0 ) ) + // InternalRosParser.g:707:3: ( rule__GlobalNamespace__Group__0 ) { before(grammarAccess.getGlobalNamespaceAccess().getGroup()); - // InternalRos.g:694:3: ( rule__GlobalNamespace__Group__0 ) - // InternalRos.g:694:4: rule__GlobalNamespace__Group__0 + // InternalRosParser.g:708:3: ( rule__GlobalNamespace__Group__0 ) + // InternalRosParser.g:708:4: rule__GlobalNamespace__Group__0 { pushFollow(FOLLOW_2); rule__GlobalNamespace__Group__0(); @@ -2164,11 +2029,11 @@ public final void ruleGlobalNamespace() throws RecognitionException { // $ANTLR start "entryRuleRelativeNamespace_Impl" - // InternalRos.g:703:1: entryRuleRelativeNamespace_Impl : ruleRelativeNamespace_Impl EOF ; + // InternalRosParser.g:717:1: entryRuleRelativeNamespace_Impl : ruleRelativeNamespace_Impl EOF ; public final void entryRuleRelativeNamespace_Impl() throws RecognitionException { try { - // InternalRos.g:704:1: ( ruleRelativeNamespace_Impl EOF ) - // InternalRos.g:705:1: ruleRelativeNamespace_Impl EOF + // InternalRosParser.g:718:1: ( ruleRelativeNamespace_Impl EOF ) + // InternalRosParser.g:719:1: ruleRelativeNamespace_Impl EOF { before(grammarAccess.getRelativeNamespace_ImplRule()); pushFollow(FOLLOW_1); @@ -2194,21 +2059,21 @@ public final void entryRuleRelativeNamespace_Impl() throws RecognitionException // $ANTLR start "ruleRelativeNamespace_Impl" - // InternalRos.g:712:1: ruleRelativeNamespace_Impl : ( ( rule__RelativeNamespace_Impl__Group__0 ) ) ; + // InternalRosParser.g:726:1: ruleRelativeNamespace_Impl : ( ( rule__RelativeNamespace_Impl__Group__0 ) ) ; public final void ruleRelativeNamespace_Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:716:2: ( ( ( rule__RelativeNamespace_Impl__Group__0 ) ) ) - // InternalRos.g:717:2: ( ( rule__RelativeNamespace_Impl__Group__0 ) ) + // InternalRosParser.g:730:2: ( ( ( rule__RelativeNamespace_Impl__Group__0 ) ) ) + // InternalRosParser.g:731:2: ( ( rule__RelativeNamespace_Impl__Group__0 ) ) { - // InternalRos.g:717:2: ( ( rule__RelativeNamespace_Impl__Group__0 ) ) - // InternalRos.g:718:3: ( rule__RelativeNamespace_Impl__Group__0 ) + // InternalRosParser.g:731:2: ( ( rule__RelativeNamespace_Impl__Group__0 ) ) + // InternalRosParser.g:732:3: ( rule__RelativeNamespace_Impl__Group__0 ) { before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup()); - // InternalRos.g:719:3: ( rule__RelativeNamespace_Impl__Group__0 ) - // InternalRos.g:719:4: rule__RelativeNamespace_Impl__Group__0 + // InternalRosParser.g:733:3: ( rule__RelativeNamespace_Impl__Group__0 ) + // InternalRosParser.g:733:4: rule__RelativeNamespace_Impl__Group__0 { pushFollow(FOLLOW_2); rule__RelativeNamespace_Impl__Group__0(); @@ -2241,11 +2106,11 @@ public final void ruleRelativeNamespace_Impl() throws RecognitionException { // $ANTLR start "entryRulePrivateNamespace" - // InternalRos.g:728:1: entryRulePrivateNamespace : rulePrivateNamespace EOF ; + // InternalRosParser.g:742:1: entryRulePrivateNamespace : rulePrivateNamespace EOF ; public final void entryRulePrivateNamespace() throws RecognitionException { try { - // InternalRos.g:729:1: ( rulePrivateNamespace EOF ) - // InternalRos.g:730:1: rulePrivateNamespace EOF + // InternalRosParser.g:743:1: ( rulePrivateNamespace EOF ) + // InternalRosParser.g:744:1: rulePrivateNamespace EOF { before(grammarAccess.getPrivateNamespaceRule()); pushFollow(FOLLOW_1); @@ -2271,21 +2136,21 @@ public final void entryRulePrivateNamespace() throws RecognitionException { // $ANTLR start "rulePrivateNamespace" - // InternalRos.g:737:1: rulePrivateNamespace : ( ( rule__PrivateNamespace__Group__0 ) ) ; + // InternalRosParser.g:751:1: rulePrivateNamespace : ( ( rule__PrivateNamespace__Group__0 ) ) ; public final void rulePrivateNamespace() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:741:2: ( ( ( rule__PrivateNamespace__Group__0 ) ) ) - // InternalRos.g:742:2: ( ( rule__PrivateNamespace__Group__0 ) ) + // InternalRosParser.g:755:2: ( ( ( rule__PrivateNamespace__Group__0 ) ) ) + // InternalRosParser.g:756:2: ( ( rule__PrivateNamespace__Group__0 ) ) { - // InternalRos.g:742:2: ( ( rule__PrivateNamespace__Group__0 ) ) - // InternalRos.g:743:3: ( rule__PrivateNamespace__Group__0 ) + // InternalRosParser.g:756:2: ( ( rule__PrivateNamespace__Group__0 ) ) + // InternalRosParser.g:757:3: ( rule__PrivateNamespace__Group__0 ) { before(grammarAccess.getPrivateNamespaceAccess().getGroup()); - // InternalRos.g:744:3: ( rule__PrivateNamespace__Group__0 ) - // InternalRos.g:744:4: rule__PrivateNamespace__Group__0 + // InternalRosParser.g:758:3: ( rule__PrivateNamespace__Group__0 ) + // InternalRosParser.g:758:4: rule__PrivateNamespace__Group__0 { pushFollow(FOLLOW_2); rule__PrivateNamespace__Group__0(); @@ -2318,11 +2183,11 @@ public final void rulePrivateNamespace() throws RecognitionException { // $ANTLR start "entryRuleParameter" - // InternalRos.g:753:1: entryRuleParameter : ruleParameter EOF ; + // InternalRosParser.g:767:1: entryRuleParameter : ruleParameter EOF ; public final void entryRuleParameter() throws RecognitionException { try { - // InternalRos.g:754:1: ( ruleParameter EOF ) - // InternalRos.g:755:1: ruleParameter EOF + // InternalRosParser.g:768:1: ( ruleParameter EOF ) + // InternalRosParser.g:769:1: ruleParameter EOF { before(grammarAccess.getParameterRule()); pushFollow(FOLLOW_1); @@ -2348,21 +2213,21 @@ public final void entryRuleParameter() throws RecognitionException { // $ANTLR start "ruleParameter" - // InternalRos.g:762:1: ruleParameter : ( ( rule__Parameter__Group__0 ) ) ; + // InternalRosParser.g:776:1: ruleParameter : ( ( rule__Parameter__Group__0 ) ) ; public final void ruleParameter() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:766:2: ( ( ( rule__Parameter__Group__0 ) ) ) - // InternalRos.g:767:2: ( ( rule__Parameter__Group__0 ) ) + // InternalRosParser.g:780:2: ( ( ( rule__Parameter__Group__0 ) ) ) + // InternalRosParser.g:781:2: ( ( rule__Parameter__Group__0 ) ) { - // InternalRos.g:767:2: ( ( rule__Parameter__Group__0 ) ) - // InternalRos.g:768:3: ( rule__Parameter__Group__0 ) + // InternalRosParser.g:781:2: ( ( rule__Parameter__Group__0 ) ) + // InternalRosParser.g:782:3: ( rule__Parameter__Group__0 ) { before(grammarAccess.getParameterAccess().getGroup()); - // InternalRos.g:769:3: ( rule__Parameter__Group__0 ) - // InternalRos.g:769:4: rule__Parameter__Group__0 + // InternalRosParser.g:783:3: ( rule__Parameter__Group__0 ) + // InternalRosParser.g:783:4: rule__Parameter__Group__0 { pushFollow(FOLLOW_2); rule__Parameter__Group__0(); @@ -2395,11 +2260,11 @@ public final void ruleParameter() throws RecognitionException { // $ANTLR start "entryRuleParameterType" - // InternalRos.g:778:1: entryRuleParameterType : ruleParameterType EOF ; + // InternalRosParser.g:792:1: entryRuleParameterType : ruleParameterType EOF ; public final void entryRuleParameterType() throws RecognitionException { try { - // InternalRos.g:779:1: ( ruleParameterType EOF ) - // InternalRos.g:780:1: ruleParameterType EOF + // InternalRosParser.g:793:1: ( ruleParameterType EOF ) + // InternalRosParser.g:794:1: ruleParameterType EOF { before(grammarAccess.getParameterTypeRule()); pushFollow(FOLLOW_1); @@ -2425,21 +2290,21 @@ public final void entryRuleParameterType() throws RecognitionException { // $ANTLR start "ruleParameterType" - // InternalRos.g:787:1: ruleParameterType : ( ( rule__ParameterType__Alternatives ) ) ; + // InternalRosParser.g:801:1: ruleParameterType : ( ( rule__ParameterType__Alternatives ) ) ; public final void ruleParameterType() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:791:2: ( ( ( rule__ParameterType__Alternatives ) ) ) - // InternalRos.g:792:2: ( ( rule__ParameterType__Alternatives ) ) + // InternalRosParser.g:805:2: ( ( ( rule__ParameterType__Alternatives ) ) ) + // InternalRosParser.g:806:2: ( ( rule__ParameterType__Alternatives ) ) { - // InternalRos.g:792:2: ( ( rule__ParameterType__Alternatives ) ) - // InternalRos.g:793:3: ( rule__ParameterType__Alternatives ) + // InternalRosParser.g:806:2: ( ( rule__ParameterType__Alternatives ) ) + // InternalRosParser.g:807:3: ( rule__ParameterType__Alternatives ) { before(grammarAccess.getParameterTypeAccess().getAlternatives()); - // InternalRos.g:794:3: ( rule__ParameterType__Alternatives ) - // InternalRos.g:794:4: rule__ParameterType__Alternatives + // InternalRosParser.g:808:3: ( rule__ParameterType__Alternatives ) + // InternalRosParser.g:808:4: rule__ParameterType__Alternatives { pushFollow(FOLLOW_2); rule__ParameterType__Alternatives(); @@ -2472,11 +2337,11 @@ public final void ruleParameterType() throws RecognitionException { // $ANTLR start "entryRuleParameterValue" - // InternalRos.g:803:1: entryRuleParameterValue : ruleParameterValue EOF ; + // InternalRosParser.g:817:1: entryRuleParameterValue : ruleParameterValue EOF ; public final void entryRuleParameterValue() throws RecognitionException { try { - // InternalRos.g:804:1: ( ruleParameterValue EOF ) - // InternalRos.g:805:1: ruleParameterValue EOF + // InternalRosParser.g:818:1: ( ruleParameterValue EOF ) + // InternalRosParser.g:819:1: ruleParameterValue EOF { before(grammarAccess.getParameterValueRule()); pushFollow(FOLLOW_1); @@ -2502,21 +2367,21 @@ public final void entryRuleParameterValue() throws RecognitionException { // $ANTLR start "ruleParameterValue" - // InternalRos.g:812:1: ruleParameterValue : ( ( rule__ParameterValue__Alternatives ) ) ; + // InternalRosParser.g:826:1: ruleParameterValue : ( ( rule__ParameterValue__Alternatives ) ) ; public final void ruleParameterValue() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:816:2: ( ( ( rule__ParameterValue__Alternatives ) ) ) - // InternalRos.g:817:2: ( ( rule__ParameterValue__Alternatives ) ) + // InternalRosParser.g:830:2: ( ( ( rule__ParameterValue__Alternatives ) ) ) + // InternalRosParser.g:831:2: ( ( rule__ParameterValue__Alternatives ) ) { - // InternalRos.g:817:2: ( ( rule__ParameterValue__Alternatives ) ) - // InternalRos.g:818:3: ( rule__ParameterValue__Alternatives ) + // InternalRosParser.g:831:2: ( ( rule__ParameterValue__Alternatives ) ) + // InternalRosParser.g:832:3: ( rule__ParameterValue__Alternatives ) { before(grammarAccess.getParameterValueAccess().getAlternatives()); - // InternalRos.g:819:3: ( rule__ParameterValue__Alternatives ) - // InternalRos.g:819:4: rule__ParameterValue__Alternatives + // InternalRosParser.g:833:3: ( rule__ParameterValue__Alternatives ) + // InternalRosParser.g:833:4: rule__ParameterValue__Alternatives { pushFollow(FOLLOW_2); rule__ParameterValue__Alternatives(); @@ -2549,11 +2414,11 @@ public final void ruleParameterValue() throws RecognitionException { // $ANTLR start "entryRuleParameterListType" - // InternalRos.g:828:1: entryRuleParameterListType : ruleParameterListType EOF ; + // InternalRosParser.g:842:1: entryRuleParameterListType : ruleParameterListType EOF ; public final void entryRuleParameterListType() throws RecognitionException { try { - // InternalRos.g:829:1: ( ruleParameterListType EOF ) - // InternalRos.g:830:1: ruleParameterListType EOF + // InternalRosParser.g:843:1: ( ruleParameterListType EOF ) + // InternalRosParser.g:844:1: ruleParameterListType EOF { before(grammarAccess.getParameterListTypeRule()); pushFollow(FOLLOW_1); @@ -2579,21 +2444,21 @@ public final void entryRuleParameterListType() throws RecognitionException { // $ANTLR start "ruleParameterListType" - // InternalRos.g:837:1: ruleParameterListType : ( ( rule__ParameterListType__Group__0 ) ) ; + // InternalRosParser.g:851:1: ruleParameterListType : ( ( rule__ParameterListType__Group__0 ) ) ; public final void ruleParameterListType() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:841:2: ( ( ( rule__ParameterListType__Group__0 ) ) ) - // InternalRos.g:842:2: ( ( rule__ParameterListType__Group__0 ) ) + // InternalRosParser.g:855:2: ( ( ( rule__ParameterListType__Group__0 ) ) ) + // InternalRosParser.g:856:2: ( ( rule__ParameterListType__Group__0 ) ) { - // InternalRos.g:842:2: ( ( rule__ParameterListType__Group__0 ) ) - // InternalRos.g:843:3: ( rule__ParameterListType__Group__0 ) + // InternalRosParser.g:856:2: ( ( rule__ParameterListType__Group__0 ) ) + // InternalRosParser.g:857:3: ( rule__ParameterListType__Group__0 ) { before(grammarAccess.getParameterListTypeAccess().getGroup()); - // InternalRos.g:844:3: ( rule__ParameterListType__Group__0 ) - // InternalRos.g:844:4: rule__ParameterListType__Group__0 + // InternalRosParser.g:858:3: ( rule__ParameterListType__Group__0 ) + // InternalRosParser.g:858:4: rule__ParameterListType__Group__0 { pushFollow(FOLLOW_2); rule__ParameterListType__Group__0(); @@ -2626,11 +2491,11 @@ public final void ruleParameterListType() throws RecognitionException { // $ANTLR start "entryRuleParameterStructType" - // InternalRos.g:853:1: entryRuleParameterStructType : ruleParameterStructType EOF ; + // InternalRosParser.g:867:1: entryRuleParameterStructType : ruleParameterStructType EOF ; public final void entryRuleParameterStructType() throws RecognitionException { try { - // InternalRos.g:854:1: ( ruleParameterStructType EOF ) - // InternalRos.g:855:1: ruleParameterStructType EOF + // InternalRosParser.g:868:1: ( ruleParameterStructType EOF ) + // InternalRosParser.g:869:1: ruleParameterStructType EOF { before(grammarAccess.getParameterStructTypeRule()); pushFollow(FOLLOW_1); @@ -2656,21 +2521,21 @@ public final void entryRuleParameterStructType() throws RecognitionException { // $ANTLR start "ruleParameterStructType" - // InternalRos.g:862:1: ruleParameterStructType : ( ( rule__ParameterStructType__Group__0 ) ) ; + // InternalRosParser.g:876:1: ruleParameterStructType : ( ( rule__ParameterStructType__Group__0 ) ) ; public final void ruleParameterStructType() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:866:2: ( ( ( rule__ParameterStructType__Group__0 ) ) ) - // InternalRos.g:867:2: ( ( rule__ParameterStructType__Group__0 ) ) + // InternalRosParser.g:880:2: ( ( ( rule__ParameterStructType__Group__0 ) ) ) + // InternalRosParser.g:881:2: ( ( rule__ParameterStructType__Group__0 ) ) { - // InternalRos.g:867:2: ( ( rule__ParameterStructType__Group__0 ) ) - // InternalRos.g:868:3: ( rule__ParameterStructType__Group__0 ) + // InternalRosParser.g:881:2: ( ( rule__ParameterStructType__Group__0 ) ) + // InternalRosParser.g:882:3: ( rule__ParameterStructType__Group__0 ) { before(grammarAccess.getParameterStructTypeAccess().getGroup()); - // InternalRos.g:869:3: ( rule__ParameterStructType__Group__0 ) - // InternalRos.g:869:4: rule__ParameterStructType__Group__0 + // InternalRosParser.g:883:3: ( rule__ParameterStructType__Group__0 ) + // InternalRosParser.g:883:4: rule__ParameterStructType__Group__0 { pushFollow(FOLLOW_2); rule__ParameterStructType__Group__0(); @@ -2703,11 +2568,11 @@ public final void ruleParameterStructType() throws RecognitionException { // $ANTLR start "entryRuleParameterIntegerType" - // InternalRos.g:878:1: entryRuleParameterIntegerType : ruleParameterIntegerType EOF ; + // InternalRosParser.g:892:1: entryRuleParameterIntegerType : ruleParameterIntegerType EOF ; public final void entryRuleParameterIntegerType() throws RecognitionException { try { - // InternalRos.g:879:1: ( ruleParameterIntegerType EOF ) - // InternalRos.g:880:1: ruleParameterIntegerType EOF + // InternalRosParser.g:893:1: ( ruleParameterIntegerType EOF ) + // InternalRosParser.g:894:1: ruleParameterIntegerType EOF { before(grammarAccess.getParameterIntegerTypeRule()); pushFollow(FOLLOW_1); @@ -2733,21 +2598,21 @@ public final void entryRuleParameterIntegerType() throws RecognitionException { // $ANTLR start "ruleParameterIntegerType" - // InternalRos.g:887:1: ruleParameterIntegerType : ( ( rule__ParameterIntegerType__Group__0 ) ) ; + // InternalRosParser.g:901:1: ruleParameterIntegerType : ( ( rule__ParameterIntegerType__Group__0 ) ) ; public final void ruleParameterIntegerType() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:891:2: ( ( ( rule__ParameterIntegerType__Group__0 ) ) ) - // InternalRos.g:892:2: ( ( rule__ParameterIntegerType__Group__0 ) ) + // InternalRosParser.g:905:2: ( ( ( rule__ParameterIntegerType__Group__0 ) ) ) + // InternalRosParser.g:906:2: ( ( rule__ParameterIntegerType__Group__0 ) ) { - // InternalRos.g:892:2: ( ( rule__ParameterIntegerType__Group__0 ) ) - // InternalRos.g:893:3: ( rule__ParameterIntegerType__Group__0 ) + // InternalRosParser.g:906:2: ( ( rule__ParameterIntegerType__Group__0 ) ) + // InternalRosParser.g:907:3: ( rule__ParameterIntegerType__Group__0 ) { before(grammarAccess.getParameterIntegerTypeAccess().getGroup()); - // InternalRos.g:894:3: ( rule__ParameterIntegerType__Group__0 ) - // InternalRos.g:894:4: rule__ParameterIntegerType__Group__0 + // InternalRosParser.g:908:3: ( rule__ParameterIntegerType__Group__0 ) + // InternalRosParser.g:908:4: rule__ParameterIntegerType__Group__0 { pushFollow(FOLLOW_2); rule__ParameterIntegerType__Group__0(); @@ -2780,11 +2645,11 @@ public final void ruleParameterIntegerType() throws RecognitionException { // $ANTLR start "entryRuleParameterStringType" - // InternalRos.g:903:1: entryRuleParameterStringType : ruleParameterStringType EOF ; + // InternalRosParser.g:917:1: entryRuleParameterStringType : ruleParameterStringType EOF ; public final void entryRuleParameterStringType() throws RecognitionException { try { - // InternalRos.g:904:1: ( ruleParameterStringType EOF ) - // InternalRos.g:905:1: ruleParameterStringType EOF + // InternalRosParser.g:918:1: ( ruleParameterStringType EOF ) + // InternalRosParser.g:919:1: ruleParameterStringType EOF { before(grammarAccess.getParameterStringTypeRule()); pushFollow(FOLLOW_1); @@ -2810,21 +2675,21 @@ public final void entryRuleParameterStringType() throws RecognitionException { // $ANTLR start "ruleParameterStringType" - // InternalRos.g:912:1: ruleParameterStringType : ( ( rule__ParameterStringType__Group__0 ) ) ; + // InternalRosParser.g:926:1: ruleParameterStringType : ( ( rule__ParameterStringType__Group__0 ) ) ; public final void ruleParameterStringType() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:916:2: ( ( ( rule__ParameterStringType__Group__0 ) ) ) - // InternalRos.g:917:2: ( ( rule__ParameterStringType__Group__0 ) ) + // InternalRosParser.g:930:2: ( ( ( rule__ParameterStringType__Group__0 ) ) ) + // InternalRosParser.g:931:2: ( ( rule__ParameterStringType__Group__0 ) ) { - // InternalRos.g:917:2: ( ( rule__ParameterStringType__Group__0 ) ) - // InternalRos.g:918:3: ( rule__ParameterStringType__Group__0 ) + // InternalRosParser.g:931:2: ( ( rule__ParameterStringType__Group__0 ) ) + // InternalRosParser.g:932:3: ( rule__ParameterStringType__Group__0 ) { before(grammarAccess.getParameterStringTypeAccess().getGroup()); - // InternalRos.g:919:3: ( rule__ParameterStringType__Group__0 ) - // InternalRos.g:919:4: rule__ParameterStringType__Group__0 + // InternalRosParser.g:933:3: ( rule__ParameterStringType__Group__0 ) + // InternalRosParser.g:933:4: rule__ParameterStringType__Group__0 { pushFollow(FOLLOW_2); rule__ParameterStringType__Group__0(); @@ -2857,11 +2722,11 @@ public final void ruleParameterStringType() throws RecognitionException { // $ANTLR start "entryRuleParameterDoubleType" - // InternalRos.g:928:1: entryRuleParameterDoubleType : ruleParameterDoubleType EOF ; + // InternalRosParser.g:942:1: entryRuleParameterDoubleType : ruleParameterDoubleType EOF ; public final void entryRuleParameterDoubleType() throws RecognitionException { try { - // InternalRos.g:929:1: ( ruleParameterDoubleType EOF ) - // InternalRos.g:930:1: ruleParameterDoubleType EOF + // InternalRosParser.g:943:1: ( ruleParameterDoubleType EOF ) + // InternalRosParser.g:944:1: ruleParameterDoubleType EOF { before(grammarAccess.getParameterDoubleTypeRule()); pushFollow(FOLLOW_1); @@ -2887,21 +2752,21 @@ public final void entryRuleParameterDoubleType() throws RecognitionException { // $ANTLR start "ruleParameterDoubleType" - // InternalRos.g:937:1: ruleParameterDoubleType : ( ( rule__ParameterDoubleType__Group__0 ) ) ; + // InternalRosParser.g:951:1: ruleParameterDoubleType : ( ( rule__ParameterDoubleType__Group__0 ) ) ; public final void ruleParameterDoubleType() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:941:2: ( ( ( rule__ParameterDoubleType__Group__0 ) ) ) - // InternalRos.g:942:2: ( ( rule__ParameterDoubleType__Group__0 ) ) + // InternalRosParser.g:955:2: ( ( ( rule__ParameterDoubleType__Group__0 ) ) ) + // InternalRosParser.g:956:2: ( ( rule__ParameterDoubleType__Group__0 ) ) { - // InternalRos.g:942:2: ( ( rule__ParameterDoubleType__Group__0 ) ) - // InternalRos.g:943:3: ( rule__ParameterDoubleType__Group__0 ) + // InternalRosParser.g:956:2: ( ( rule__ParameterDoubleType__Group__0 ) ) + // InternalRosParser.g:957:3: ( rule__ParameterDoubleType__Group__0 ) { before(grammarAccess.getParameterDoubleTypeAccess().getGroup()); - // InternalRos.g:944:3: ( rule__ParameterDoubleType__Group__0 ) - // InternalRos.g:944:4: rule__ParameterDoubleType__Group__0 + // InternalRosParser.g:958:3: ( rule__ParameterDoubleType__Group__0 ) + // InternalRosParser.g:958:4: rule__ParameterDoubleType__Group__0 { pushFollow(FOLLOW_2); rule__ParameterDoubleType__Group__0(); @@ -2934,11 +2799,11 @@ public final void ruleParameterDoubleType() throws RecognitionException { // $ANTLR start "entryRuleParameterBooleanType" - // InternalRos.g:953:1: entryRuleParameterBooleanType : ruleParameterBooleanType EOF ; + // InternalRosParser.g:967:1: entryRuleParameterBooleanType : ruleParameterBooleanType EOF ; public final void entryRuleParameterBooleanType() throws RecognitionException { try { - // InternalRos.g:954:1: ( ruleParameterBooleanType EOF ) - // InternalRos.g:955:1: ruleParameterBooleanType EOF + // InternalRosParser.g:968:1: ( ruleParameterBooleanType EOF ) + // InternalRosParser.g:969:1: ruleParameterBooleanType EOF { before(grammarAccess.getParameterBooleanTypeRule()); pushFollow(FOLLOW_1); @@ -2964,21 +2829,21 @@ public final void entryRuleParameterBooleanType() throws RecognitionException { // $ANTLR start "ruleParameterBooleanType" - // InternalRos.g:962:1: ruleParameterBooleanType : ( ( rule__ParameterBooleanType__Group__0 ) ) ; + // InternalRosParser.g:976:1: ruleParameterBooleanType : ( ( rule__ParameterBooleanType__Group__0 ) ) ; public final void ruleParameterBooleanType() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:966:2: ( ( ( rule__ParameterBooleanType__Group__0 ) ) ) - // InternalRos.g:967:2: ( ( rule__ParameterBooleanType__Group__0 ) ) + // InternalRosParser.g:980:2: ( ( ( rule__ParameterBooleanType__Group__0 ) ) ) + // InternalRosParser.g:981:2: ( ( rule__ParameterBooleanType__Group__0 ) ) { - // InternalRos.g:967:2: ( ( rule__ParameterBooleanType__Group__0 ) ) - // InternalRos.g:968:3: ( rule__ParameterBooleanType__Group__0 ) + // InternalRosParser.g:981:2: ( ( rule__ParameterBooleanType__Group__0 ) ) + // InternalRosParser.g:982:3: ( rule__ParameterBooleanType__Group__0 ) { before(grammarAccess.getParameterBooleanTypeAccess().getGroup()); - // InternalRos.g:969:3: ( rule__ParameterBooleanType__Group__0 ) - // InternalRos.g:969:4: rule__ParameterBooleanType__Group__0 + // InternalRosParser.g:983:3: ( rule__ParameterBooleanType__Group__0 ) + // InternalRosParser.g:983:4: rule__ParameterBooleanType__Group__0 { pushFollow(FOLLOW_2); rule__ParameterBooleanType__Group__0(); @@ -3011,11 +2876,11 @@ public final void ruleParameterBooleanType() throws RecognitionException { // $ANTLR start "entryRuleParameterBase64Type" - // InternalRos.g:978:1: entryRuleParameterBase64Type : ruleParameterBase64Type EOF ; + // InternalRosParser.g:992:1: entryRuleParameterBase64Type : ruleParameterBase64Type EOF ; public final void entryRuleParameterBase64Type() throws RecognitionException { try { - // InternalRos.g:979:1: ( ruleParameterBase64Type EOF ) - // InternalRos.g:980:1: ruleParameterBase64Type EOF + // InternalRosParser.g:993:1: ( ruleParameterBase64Type EOF ) + // InternalRosParser.g:994:1: ruleParameterBase64Type EOF { before(grammarAccess.getParameterBase64TypeRule()); pushFollow(FOLLOW_1); @@ -3041,21 +2906,21 @@ public final void entryRuleParameterBase64Type() throws RecognitionException { // $ANTLR start "ruleParameterBase64Type" - // InternalRos.g:987:1: ruleParameterBase64Type : ( ( rule__ParameterBase64Type__Group__0 ) ) ; + // InternalRosParser.g:1001:1: ruleParameterBase64Type : ( ( rule__ParameterBase64Type__Group__0 ) ) ; public final void ruleParameterBase64Type() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:991:2: ( ( ( rule__ParameterBase64Type__Group__0 ) ) ) - // InternalRos.g:992:2: ( ( rule__ParameterBase64Type__Group__0 ) ) + // InternalRosParser.g:1005:2: ( ( ( rule__ParameterBase64Type__Group__0 ) ) ) + // InternalRosParser.g:1006:2: ( ( rule__ParameterBase64Type__Group__0 ) ) { - // InternalRos.g:992:2: ( ( rule__ParameterBase64Type__Group__0 ) ) - // InternalRos.g:993:3: ( rule__ParameterBase64Type__Group__0 ) + // InternalRosParser.g:1006:2: ( ( rule__ParameterBase64Type__Group__0 ) ) + // InternalRosParser.g:1007:3: ( rule__ParameterBase64Type__Group__0 ) { before(grammarAccess.getParameterBase64TypeAccess().getGroup()); - // InternalRos.g:994:3: ( rule__ParameterBase64Type__Group__0 ) - // InternalRos.g:994:4: rule__ParameterBase64Type__Group__0 + // InternalRosParser.g:1008:3: ( rule__ParameterBase64Type__Group__0 ) + // InternalRosParser.g:1008:4: rule__ParameterBase64Type__Group__0 { pushFollow(FOLLOW_2); rule__ParameterBase64Type__Group__0(); @@ -3088,11 +2953,11 @@ public final void ruleParameterBase64Type() throws RecognitionException { // $ANTLR start "entryRuleParameterArrayType" - // InternalRos.g:1003:1: entryRuleParameterArrayType : ruleParameterArrayType EOF ; + // InternalRosParser.g:1017:1: entryRuleParameterArrayType : ruleParameterArrayType EOF ; public final void entryRuleParameterArrayType() throws RecognitionException { try { - // InternalRos.g:1004:1: ( ruleParameterArrayType EOF ) - // InternalRos.g:1005:1: ruleParameterArrayType EOF + // InternalRosParser.g:1018:1: ( ruleParameterArrayType EOF ) + // InternalRosParser.g:1019:1: ruleParameterArrayType EOF { before(grammarAccess.getParameterArrayTypeRule()); pushFollow(FOLLOW_1); @@ -3118,21 +2983,21 @@ public final void entryRuleParameterArrayType() throws RecognitionException { // $ANTLR start "ruleParameterArrayType" - // InternalRos.g:1012:1: ruleParameterArrayType : ( ( rule__ParameterArrayType__Group__0 ) ) ; + // InternalRosParser.g:1026:1: ruleParameterArrayType : ( ( rule__ParameterArrayType__Group__0 ) ) ; public final void ruleParameterArrayType() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1016:2: ( ( ( rule__ParameterArrayType__Group__0 ) ) ) - // InternalRos.g:1017:2: ( ( rule__ParameterArrayType__Group__0 ) ) + // InternalRosParser.g:1030:2: ( ( ( rule__ParameterArrayType__Group__0 ) ) ) + // InternalRosParser.g:1031:2: ( ( rule__ParameterArrayType__Group__0 ) ) { - // InternalRos.g:1017:2: ( ( rule__ParameterArrayType__Group__0 ) ) - // InternalRos.g:1018:3: ( rule__ParameterArrayType__Group__0 ) + // InternalRosParser.g:1031:2: ( ( rule__ParameterArrayType__Group__0 ) ) + // InternalRosParser.g:1032:3: ( rule__ParameterArrayType__Group__0 ) { before(grammarAccess.getParameterArrayTypeAccess().getGroup()); - // InternalRos.g:1019:3: ( rule__ParameterArrayType__Group__0 ) - // InternalRos.g:1019:4: rule__ParameterArrayType__Group__0 + // InternalRosParser.g:1033:3: ( rule__ParameterArrayType__Group__0 ) + // InternalRosParser.g:1033:4: rule__ParameterArrayType__Group__0 { pushFollow(FOLLOW_2); rule__ParameterArrayType__Group__0(); @@ -3165,11 +3030,11 @@ public final void ruleParameterArrayType() throws RecognitionException { // $ANTLR start "entryRuleParameterList" - // InternalRos.g:1028:1: entryRuleParameterList : ruleParameterList EOF ; + // InternalRosParser.g:1042:1: entryRuleParameterList : ruleParameterList EOF ; public final void entryRuleParameterList() throws RecognitionException { try { - // InternalRos.g:1029:1: ( ruleParameterList EOF ) - // InternalRos.g:1030:1: ruleParameterList EOF + // InternalRosParser.g:1043:1: ( ruleParameterList EOF ) + // InternalRosParser.g:1044:1: ruleParameterList EOF { before(grammarAccess.getParameterListRule()); pushFollow(FOLLOW_1); @@ -3195,21 +3060,21 @@ public final void entryRuleParameterList() throws RecognitionException { // $ANTLR start "ruleParameterList" - // InternalRos.g:1037:1: ruleParameterList : ( ( rule__ParameterList__Group__0 ) ) ; + // InternalRosParser.g:1051:1: ruleParameterList : ( ( rule__ParameterList__Group__0 ) ) ; public final void ruleParameterList() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1041:2: ( ( ( rule__ParameterList__Group__0 ) ) ) - // InternalRos.g:1042:2: ( ( rule__ParameterList__Group__0 ) ) + // InternalRosParser.g:1055:2: ( ( ( rule__ParameterList__Group__0 ) ) ) + // InternalRosParser.g:1056:2: ( ( rule__ParameterList__Group__0 ) ) { - // InternalRos.g:1042:2: ( ( rule__ParameterList__Group__0 ) ) - // InternalRos.g:1043:3: ( rule__ParameterList__Group__0 ) + // InternalRosParser.g:1056:2: ( ( rule__ParameterList__Group__0 ) ) + // InternalRosParser.g:1057:3: ( rule__ParameterList__Group__0 ) { before(grammarAccess.getParameterListAccess().getGroup()); - // InternalRos.g:1044:3: ( rule__ParameterList__Group__0 ) - // InternalRos.g:1044:4: rule__ParameterList__Group__0 + // InternalRosParser.g:1058:3: ( rule__ParameterList__Group__0 ) + // InternalRosParser.g:1058:4: rule__ParameterList__Group__0 { pushFollow(FOLLOW_2); rule__ParameterList__Group__0(); @@ -3242,11 +3107,11 @@ public final void ruleParameterList() throws RecognitionException { // $ANTLR start "entryRuleParameterAny" - // InternalRos.g:1053:1: entryRuleParameterAny : ruleParameterAny EOF ; + // InternalRosParser.g:1067:1: entryRuleParameterAny : ruleParameterAny EOF ; public final void entryRuleParameterAny() throws RecognitionException { try { - // InternalRos.g:1054:1: ( ruleParameterAny EOF ) - // InternalRos.g:1055:1: ruleParameterAny EOF + // InternalRosParser.g:1068:1: ( ruleParameterAny EOF ) + // InternalRosParser.g:1069:1: ruleParameterAny EOF { before(grammarAccess.getParameterAnyRule()); pushFollow(FOLLOW_1); @@ -3272,21 +3137,21 @@ public final void entryRuleParameterAny() throws RecognitionException { // $ANTLR start "ruleParameterAny" - // InternalRos.g:1062:1: ruleParameterAny : ( ( rule__ParameterAny__Group__0 ) ) ; + // InternalRosParser.g:1076:1: ruleParameterAny : ( ( rule__ParameterAny__Group__0 ) ) ; public final void ruleParameterAny() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1066:2: ( ( ( rule__ParameterAny__Group__0 ) ) ) - // InternalRos.g:1067:2: ( ( rule__ParameterAny__Group__0 ) ) + // InternalRosParser.g:1080:2: ( ( ( rule__ParameterAny__Group__0 ) ) ) + // InternalRosParser.g:1081:2: ( ( rule__ParameterAny__Group__0 ) ) { - // InternalRos.g:1067:2: ( ( rule__ParameterAny__Group__0 ) ) - // InternalRos.g:1068:3: ( rule__ParameterAny__Group__0 ) + // InternalRosParser.g:1081:2: ( ( rule__ParameterAny__Group__0 ) ) + // InternalRosParser.g:1082:3: ( rule__ParameterAny__Group__0 ) { before(grammarAccess.getParameterAnyAccess().getGroup()); - // InternalRos.g:1069:3: ( rule__ParameterAny__Group__0 ) - // InternalRos.g:1069:4: rule__ParameterAny__Group__0 + // InternalRosParser.g:1083:3: ( rule__ParameterAny__Group__0 ) + // InternalRosParser.g:1083:4: rule__ParameterAny__Group__0 { pushFollow(FOLLOW_2); rule__ParameterAny__Group__0(); @@ -3319,11 +3184,11 @@ public final void ruleParameterAny() throws RecognitionException { // $ANTLR start "entryRuleParameterString" - // InternalRos.g:1078:1: entryRuleParameterString : ruleParameterString EOF ; + // InternalRosParser.g:1092:1: entryRuleParameterString : ruleParameterString EOF ; public final void entryRuleParameterString() throws RecognitionException { try { - // InternalRos.g:1079:1: ( ruleParameterString EOF ) - // InternalRos.g:1080:1: ruleParameterString EOF + // InternalRosParser.g:1093:1: ( ruleParameterString EOF ) + // InternalRosParser.g:1094:1: ruleParameterString EOF { before(grammarAccess.getParameterStringRule()); pushFollow(FOLLOW_1); @@ -3349,21 +3214,21 @@ public final void entryRuleParameterString() throws RecognitionException { // $ANTLR start "ruleParameterString" - // InternalRos.g:1087:1: ruleParameterString : ( ( rule__ParameterString__ValueAssignment ) ) ; + // InternalRosParser.g:1101:1: ruleParameterString : ( ( rule__ParameterString__ValueAssignment ) ) ; public final void ruleParameterString() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1091:2: ( ( ( rule__ParameterString__ValueAssignment ) ) ) - // InternalRos.g:1092:2: ( ( rule__ParameterString__ValueAssignment ) ) + // InternalRosParser.g:1105:2: ( ( ( rule__ParameterString__ValueAssignment ) ) ) + // InternalRosParser.g:1106:2: ( ( rule__ParameterString__ValueAssignment ) ) { - // InternalRos.g:1092:2: ( ( rule__ParameterString__ValueAssignment ) ) - // InternalRos.g:1093:3: ( rule__ParameterString__ValueAssignment ) + // InternalRosParser.g:1106:2: ( ( rule__ParameterString__ValueAssignment ) ) + // InternalRosParser.g:1107:3: ( rule__ParameterString__ValueAssignment ) { before(grammarAccess.getParameterStringAccess().getValueAssignment()); - // InternalRos.g:1094:3: ( rule__ParameterString__ValueAssignment ) - // InternalRos.g:1094:4: rule__ParameterString__ValueAssignment + // InternalRosParser.g:1108:3: ( rule__ParameterString__ValueAssignment ) + // InternalRosParser.g:1108:4: rule__ParameterString__ValueAssignment { pushFollow(FOLLOW_2); rule__ParameterString__ValueAssignment(); @@ -3396,11 +3261,11 @@ public final void ruleParameterString() throws RecognitionException { // $ANTLR start "entryRuleParameterBase64" - // InternalRos.g:1103:1: entryRuleParameterBase64 : ruleParameterBase64 EOF ; + // InternalRosParser.g:1117:1: entryRuleParameterBase64 : ruleParameterBase64 EOF ; public final void entryRuleParameterBase64() throws RecognitionException { try { - // InternalRos.g:1104:1: ( ruleParameterBase64 EOF ) - // InternalRos.g:1105:1: ruleParameterBase64 EOF + // InternalRosParser.g:1118:1: ( ruleParameterBase64 EOF ) + // InternalRosParser.g:1119:1: ruleParameterBase64 EOF { before(grammarAccess.getParameterBase64Rule()); pushFollow(FOLLOW_1); @@ -3426,21 +3291,21 @@ public final void entryRuleParameterBase64() throws RecognitionException { // $ANTLR start "ruleParameterBase64" - // InternalRos.g:1112:1: ruleParameterBase64 : ( ( rule__ParameterBase64__ValueAssignment ) ) ; + // InternalRosParser.g:1126:1: ruleParameterBase64 : ( ( rule__ParameterBase64__ValueAssignment ) ) ; public final void ruleParameterBase64() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1116:2: ( ( ( rule__ParameterBase64__ValueAssignment ) ) ) - // InternalRos.g:1117:2: ( ( rule__ParameterBase64__ValueAssignment ) ) + // InternalRosParser.g:1130:2: ( ( ( rule__ParameterBase64__ValueAssignment ) ) ) + // InternalRosParser.g:1131:2: ( ( rule__ParameterBase64__ValueAssignment ) ) { - // InternalRos.g:1117:2: ( ( rule__ParameterBase64__ValueAssignment ) ) - // InternalRos.g:1118:3: ( rule__ParameterBase64__ValueAssignment ) + // InternalRosParser.g:1131:2: ( ( rule__ParameterBase64__ValueAssignment ) ) + // InternalRosParser.g:1132:3: ( rule__ParameterBase64__ValueAssignment ) { before(grammarAccess.getParameterBase64Access().getValueAssignment()); - // InternalRos.g:1119:3: ( rule__ParameterBase64__ValueAssignment ) - // InternalRos.g:1119:4: rule__ParameterBase64__ValueAssignment + // InternalRosParser.g:1133:3: ( rule__ParameterBase64__ValueAssignment ) + // InternalRosParser.g:1133:4: rule__ParameterBase64__ValueAssignment { pushFollow(FOLLOW_2); rule__ParameterBase64__ValueAssignment(); @@ -3473,11 +3338,11 @@ public final void ruleParameterBase64() throws RecognitionException { // $ANTLR start "entryRuleParameterInteger" - // InternalRos.g:1128:1: entryRuleParameterInteger : ruleParameterInteger EOF ; + // InternalRosParser.g:1142:1: entryRuleParameterInteger : ruleParameterInteger EOF ; public final void entryRuleParameterInteger() throws RecognitionException { try { - // InternalRos.g:1129:1: ( ruleParameterInteger EOF ) - // InternalRos.g:1130:1: ruleParameterInteger EOF + // InternalRosParser.g:1143:1: ( ruleParameterInteger EOF ) + // InternalRosParser.g:1144:1: ruleParameterInteger EOF { before(grammarAccess.getParameterIntegerRule()); pushFollow(FOLLOW_1); @@ -3503,21 +3368,21 @@ public final void entryRuleParameterInteger() throws RecognitionException { // $ANTLR start "ruleParameterInteger" - // InternalRos.g:1137:1: ruleParameterInteger : ( ( rule__ParameterInteger__ValueAssignment ) ) ; + // InternalRosParser.g:1151:1: ruleParameterInteger : ( ( rule__ParameterInteger__ValueAssignment ) ) ; public final void ruleParameterInteger() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1141:2: ( ( ( rule__ParameterInteger__ValueAssignment ) ) ) - // InternalRos.g:1142:2: ( ( rule__ParameterInteger__ValueAssignment ) ) + // InternalRosParser.g:1155:2: ( ( ( rule__ParameterInteger__ValueAssignment ) ) ) + // InternalRosParser.g:1156:2: ( ( rule__ParameterInteger__ValueAssignment ) ) { - // InternalRos.g:1142:2: ( ( rule__ParameterInteger__ValueAssignment ) ) - // InternalRos.g:1143:3: ( rule__ParameterInteger__ValueAssignment ) + // InternalRosParser.g:1156:2: ( ( rule__ParameterInteger__ValueAssignment ) ) + // InternalRosParser.g:1157:3: ( rule__ParameterInteger__ValueAssignment ) { before(grammarAccess.getParameterIntegerAccess().getValueAssignment()); - // InternalRos.g:1144:3: ( rule__ParameterInteger__ValueAssignment ) - // InternalRos.g:1144:4: rule__ParameterInteger__ValueAssignment + // InternalRosParser.g:1158:3: ( rule__ParameterInteger__ValueAssignment ) + // InternalRosParser.g:1158:4: rule__ParameterInteger__ValueAssignment { pushFollow(FOLLOW_2); rule__ParameterInteger__ValueAssignment(); @@ -3550,11 +3415,11 @@ public final void ruleParameterInteger() throws RecognitionException { // $ANTLR start "entryRuleParameterDouble" - // InternalRos.g:1153:1: entryRuleParameterDouble : ruleParameterDouble EOF ; + // InternalRosParser.g:1167:1: entryRuleParameterDouble : ruleParameterDouble EOF ; public final void entryRuleParameterDouble() throws RecognitionException { try { - // InternalRos.g:1154:1: ( ruleParameterDouble EOF ) - // InternalRos.g:1155:1: ruleParameterDouble EOF + // InternalRosParser.g:1168:1: ( ruleParameterDouble EOF ) + // InternalRosParser.g:1169:1: ruleParameterDouble EOF { before(grammarAccess.getParameterDoubleRule()); pushFollow(FOLLOW_1); @@ -3580,21 +3445,21 @@ public final void entryRuleParameterDouble() throws RecognitionException { // $ANTLR start "ruleParameterDouble" - // InternalRos.g:1162:1: ruleParameterDouble : ( ( rule__ParameterDouble__ValueAssignment ) ) ; + // InternalRosParser.g:1176:1: ruleParameterDouble : ( ( rule__ParameterDouble__ValueAssignment ) ) ; public final void ruleParameterDouble() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1166:2: ( ( ( rule__ParameterDouble__ValueAssignment ) ) ) - // InternalRos.g:1167:2: ( ( rule__ParameterDouble__ValueAssignment ) ) + // InternalRosParser.g:1180:2: ( ( ( rule__ParameterDouble__ValueAssignment ) ) ) + // InternalRosParser.g:1181:2: ( ( rule__ParameterDouble__ValueAssignment ) ) { - // InternalRos.g:1167:2: ( ( rule__ParameterDouble__ValueAssignment ) ) - // InternalRos.g:1168:3: ( rule__ParameterDouble__ValueAssignment ) + // InternalRosParser.g:1181:2: ( ( rule__ParameterDouble__ValueAssignment ) ) + // InternalRosParser.g:1182:3: ( rule__ParameterDouble__ValueAssignment ) { before(grammarAccess.getParameterDoubleAccess().getValueAssignment()); - // InternalRos.g:1169:3: ( rule__ParameterDouble__ValueAssignment ) - // InternalRos.g:1169:4: rule__ParameterDouble__ValueAssignment + // InternalRosParser.g:1183:3: ( rule__ParameterDouble__ValueAssignment ) + // InternalRosParser.g:1183:4: rule__ParameterDouble__ValueAssignment { pushFollow(FOLLOW_2); rule__ParameterDouble__ValueAssignment(); @@ -3627,11 +3492,11 @@ public final void ruleParameterDouble() throws RecognitionException { // $ANTLR start "entryRuleParameterBoolean" - // InternalRos.g:1178:1: entryRuleParameterBoolean : ruleParameterBoolean EOF ; + // InternalRosParser.g:1192:1: entryRuleParameterBoolean : ruleParameterBoolean EOF ; public final void entryRuleParameterBoolean() throws RecognitionException { try { - // InternalRos.g:1179:1: ( ruleParameterBoolean EOF ) - // InternalRos.g:1180:1: ruleParameterBoolean EOF + // InternalRosParser.g:1193:1: ( ruleParameterBoolean EOF ) + // InternalRosParser.g:1194:1: ruleParameterBoolean EOF { before(grammarAccess.getParameterBooleanRule()); pushFollow(FOLLOW_1); @@ -3657,21 +3522,21 @@ public final void entryRuleParameterBoolean() throws RecognitionException { // $ANTLR start "ruleParameterBoolean" - // InternalRos.g:1187:1: ruleParameterBoolean : ( ( rule__ParameterBoolean__ValueAssignment ) ) ; + // InternalRosParser.g:1201:1: ruleParameterBoolean : ( ( rule__ParameterBoolean__ValueAssignment ) ) ; public final void ruleParameterBoolean() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1191:2: ( ( ( rule__ParameterBoolean__ValueAssignment ) ) ) - // InternalRos.g:1192:2: ( ( rule__ParameterBoolean__ValueAssignment ) ) + // InternalRosParser.g:1205:2: ( ( ( rule__ParameterBoolean__ValueAssignment ) ) ) + // InternalRosParser.g:1206:2: ( ( rule__ParameterBoolean__ValueAssignment ) ) { - // InternalRos.g:1192:2: ( ( rule__ParameterBoolean__ValueAssignment ) ) - // InternalRos.g:1193:3: ( rule__ParameterBoolean__ValueAssignment ) + // InternalRosParser.g:1206:2: ( ( rule__ParameterBoolean__ValueAssignment ) ) + // InternalRosParser.g:1207:3: ( rule__ParameterBoolean__ValueAssignment ) { before(grammarAccess.getParameterBooleanAccess().getValueAssignment()); - // InternalRos.g:1194:3: ( rule__ParameterBoolean__ValueAssignment ) - // InternalRos.g:1194:4: rule__ParameterBoolean__ValueAssignment + // InternalRosParser.g:1208:3: ( rule__ParameterBoolean__ValueAssignment ) + // InternalRosParser.g:1208:4: rule__ParameterBoolean__ValueAssignment { pushFollow(FOLLOW_2); rule__ParameterBoolean__ValueAssignment(); @@ -3704,11 +3569,11 @@ public final void ruleParameterBoolean() throws RecognitionException { // $ANTLR start "entryRuleParameterStruct" - // InternalRos.g:1203:1: entryRuleParameterStruct : ruleParameterStruct EOF ; + // InternalRosParser.g:1217:1: entryRuleParameterStruct : ruleParameterStruct EOF ; public final void entryRuleParameterStruct() throws RecognitionException { try { - // InternalRos.g:1204:1: ( ruleParameterStruct EOF ) - // InternalRos.g:1205:1: ruleParameterStruct EOF + // InternalRosParser.g:1218:1: ( ruleParameterStruct EOF ) + // InternalRosParser.g:1219:1: ruleParameterStruct EOF { before(grammarAccess.getParameterStructRule()); pushFollow(FOLLOW_1); @@ -3734,21 +3599,21 @@ public final void entryRuleParameterStruct() throws RecognitionException { // $ANTLR start "ruleParameterStruct" - // InternalRos.g:1212:1: ruleParameterStruct : ( ( rule__ParameterStruct__Group__0 ) ) ; + // InternalRosParser.g:1226:1: ruleParameterStruct : ( ( rule__ParameterStruct__Group__0 ) ) ; public final void ruleParameterStruct() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1216:2: ( ( ( rule__ParameterStruct__Group__0 ) ) ) - // InternalRos.g:1217:2: ( ( rule__ParameterStruct__Group__0 ) ) + // InternalRosParser.g:1230:2: ( ( ( rule__ParameterStruct__Group__0 ) ) ) + // InternalRosParser.g:1231:2: ( ( rule__ParameterStruct__Group__0 ) ) { - // InternalRos.g:1217:2: ( ( rule__ParameterStruct__Group__0 ) ) - // InternalRos.g:1218:3: ( rule__ParameterStruct__Group__0 ) + // InternalRosParser.g:1231:2: ( ( rule__ParameterStruct__Group__0 ) ) + // InternalRosParser.g:1232:3: ( rule__ParameterStruct__Group__0 ) { before(grammarAccess.getParameterStructAccess().getGroup()); - // InternalRos.g:1219:3: ( rule__ParameterStruct__Group__0 ) - // InternalRos.g:1219:4: rule__ParameterStruct__Group__0 + // InternalRosParser.g:1233:3: ( rule__ParameterStruct__Group__0 ) + // InternalRosParser.g:1233:4: rule__ParameterStruct__Group__0 { pushFollow(FOLLOW_2); rule__ParameterStruct__Group__0(); @@ -3781,11 +3646,11 @@ public final void ruleParameterStruct() throws RecognitionException { // $ANTLR start "entryRuleParameterDate" - // InternalRos.g:1228:1: entryRuleParameterDate : ruleParameterDate EOF ; + // InternalRosParser.g:1242:1: entryRuleParameterDate : ruleParameterDate EOF ; public final void entryRuleParameterDate() throws RecognitionException { try { - // InternalRos.g:1229:1: ( ruleParameterDate EOF ) - // InternalRos.g:1230:1: ruleParameterDate EOF + // InternalRosParser.g:1243:1: ( ruleParameterDate EOF ) + // InternalRosParser.g:1244:1: ruleParameterDate EOF { before(grammarAccess.getParameterDateRule()); pushFollow(FOLLOW_1); @@ -3811,21 +3676,21 @@ public final void entryRuleParameterDate() throws RecognitionException { // $ANTLR start "ruleParameterDate" - // InternalRos.g:1237:1: ruleParameterDate : ( ( rule__ParameterDate__ValueAssignment ) ) ; + // InternalRosParser.g:1251:1: ruleParameterDate : ( ( rule__ParameterDate__ValueAssignment ) ) ; public final void ruleParameterDate() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1241:2: ( ( ( rule__ParameterDate__ValueAssignment ) ) ) - // InternalRos.g:1242:2: ( ( rule__ParameterDate__ValueAssignment ) ) + // InternalRosParser.g:1255:2: ( ( ( rule__ParameterDate__ValueAssignment ) ) ) + // InternalRosParser.g:1256:2: ( ( rule__ParameterDate__ValueAssignment ) ) { - // InternalRos.g:1242:2: ( ( rule__ParameterDate__ValueAssignment ) ) - // InternalRos.g:1243:3: ( rule__ParameterDate__ValueAssignment ) + // InternalRosParser.g:1256:2: ( ( rule__ParameterDate__ValueAssignment ) ) + // InternalRosParser.g:1257:3: ( rule__ParameterDate__ValueAssignment ) { before(grammarAccess.getParameterDateAccess().getValueAssignment()); - // InternalRos.g:1244:3: ( rule__ParameterDate__ValueAssignment ) - // InternalRos.g:1244:4: rule__ParameterDate__ValueAssignment + // InternalRosParser.g:1258:3: ( rule__ParameterDate__ValueAssignment ) + // InternalRosParser.g:1258:4: rule__ParameterDate__ValueAssignment { pushFollow(FOLLOW_2); rule__ParameterDate__ValueAssignment(); @@ -3858,11 +3723,11 @@ public final void ruleParameterDate() throws RecognitionException { // $ANTLR start "entryRuleParameterStructMember" - // InternalRos.g:1253:1: entryRuleParameterStructMember : ruleParameterStructMember EOF ; + // InternalRosParser.g:1267:1: entryRuleParameterStructMember : ruleParameterStructMember EOF ; public final void entryRuleParameterStructMember() throws RecognitionException { try { - // InternalRos.g:1254:1: ( ruleParameterStructMember EOF ) - // InternalRos.g:1255:1: ruleParameterStructMember EOF + // InternalRosParser.g:1268:1: ( ruleParameterStructMember EOF ) + // InternalRosParser.g:1269:1: ruleParameterStructMember EOF { before(grammarAccess.getParameterStructMemberRule()); pushFollow(FOLLOW_1); @@ -3888,21 +3753,21 @@ public final void entryRuleParameterStructMember() throws RecognitionException { // $ANTLR start "ruleParameterStructMember" - // InternalRos.g:1262:1: ruleParameterStructMember : ( ( rule__ParameterStructMember__Group__0 ) ) ; + // InternalRosParser.g:1276:1: ruleParameterStructMember : ( ( rule__ParameterStructMember__Group__0 ) ) ; public final void ruleParameterStructMember() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1266:2: ( ( ( rule__ParameterStructMember__Group__0 ) ) ) - // InternalRos.g:1267:2: ( ( rule__ParameterStructMember__Group__0 ) ) + // InternalRosParser.g:1280:2: ( ( ( rule__ParameterStructMember__Group__0 ) ) ) + // InternalRosParser.g:1281:2: ( ( rule__ParameterStructMember__Group__0 ) ) { - // InternalRos.g:1267:2: ( ( rule__ParameterStructMember__Group__0 ) ) - // InternalRos.g:1268:3: ( rule__ParameterStructMember__Group__0 ) + // InternalRosParser.g:1281:2: ( ( rule__ParameterStructMember__Group__0 ) ) + // InternalRosParser.g:1282:3: ( rule__ParameterStructMember__Group__0 ) { before(grammarAccess.getParameterStructMemberAccess().getGroup()); - // InternalRos.g:1269:3: ( rule__ParameterStructMember__Group__0 ) - // InternalRos.g:1269:4: rule__ParameterStructMember__Group__0 + // InternalRosParser.g:1283:3: ( rule__ParameterStructMember__Group__0 ) + // InternalRosParser.g:1283:4: rule__ParameterStructMember__Group__0 { pushFollow(FOLLOW_2); rule__ParameterStructMember__Group__0(); @@ -3935,11 +3800,11 @@ public final void ruleParameterStructMember() throws RecognitionException { // $ANTLR start "entryRuleParameterStructTypeMember" - // InternalRos.g:1278:1: entryRuleParameterStructTypeMember : ruleParameterStructTypeMember EOF ; + // InternalRosParser.g:1292:1: entryRuleParameterStructTypeMember : ruleParameterStructTypeMember EOF ; public final void entryRuleParameterStructTypeMember() throws RecognitionException { try { - // InternalRos.g:1279:1: ( ruleParameterStructTypeMember EOF ) - // InternalRos.g:1280:1: ruleParameterStructTypeMember EOF + // InternalRosParser.g:1293:1: ( ruleParameterStructTypeMember EOF ) + // InternalRosParser.g:1294:1: ruleParameterStructTypeMember EOF { before(grammarAccess.getParameterStructTypeMemberRule()); pushFollow(FOLLOW_1); @@ -3965,21 +3830,21 @@ public final void entryRuleParameterStructTypeMember() throws RecognitionExcepti // $ANTLR start "ruleParameterStructTypeMember" - // InternalRos.g:1287:1: ruleParameterStructTypeMember : ( ( rule__ParameterStructTypeMember__Group__0 ) ) ; + // InternalRosParser.g:1301:1: ruleParameterStructTypeMember : ( ( rule__ParameterStructTypeMember__Group__0 ) ) ; public final void ruleParameterStructTypeMember() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1291:2: ( ( ( rule__ParameterStructTypeMember__Group__0 ) ) ) - // InternalRos.g:1292:2: ( ( rule__ParameterStructTypeMember__Group__0 ) ) + // InternalRosParser.g:1305:2: ( ( ( rule__ParameterStructTypeMember__Group__0 ) ) ) + // InternalRosParser.g:1306:2: ( ( rule__ParameterStructTypeMember__Group__0 ) ) { - // InternalRos.g:1292:2: ( ( rule__ParameterStructTypeMember__Group__0 ) ) - // InternalRos.g:1293:3: ( rule__ParameterStructTypeMember__Group__0 ) + // InternalRosParser.g:1306:2: ( ( rule__ParameterStructTypeMember__Group__0 ) ) + // InternalRosParser.g:1307:3: ( rule__ParameterStructTypeMember__Group__0 ) { before(grammarAccess.getParameterStructTypeMemberAccess().getGroup()); - // InternalRos.g:1294:3: ( rule__ParameterStructTypeMember__Group__0 ) - // InternalRos.g:1294:4: rule__ParameterStructTypeMember__Group__0 + // InternalRosParser.g:1308:3: ( rule__ParameterStructTypeMember__Group__0 ) + // InternalRosParser.g:1308:4: rule__ParameterStructTypeMember__Group__0 { pushFollow(FOLLOW_2); rule__ParameterStructTypeMember__Group__0(); @@ -4012,11 +3877,11 @@ public final void ruleParameterStructTypeMember() throws RecognitionException { // $ANTLR start "entryRuleBase64Binary" - // InternalRos.g:1303:1: entryRuleBase64Binary : ruleBase64Binary EOF ; + // InternalRosParser.g:1317:1: entryRuleBase64Binary : ruleBase64Binary EOF ; public final void entryRuleBase64Binary() throws RecognitionException { try { - // InternalRos.g:1304:1: ( ruleBase64Binary EOF ) - // InternalRos.g:1305:1: ruleBase64Binary EOF + // InternalRosParser.g:1318:1: ( ruleBase64Binary EOF ) + // InternalRosParser.g:1319:1: ruleBase64Binary EOF { before(grammarAccess.getBase64BinaryRule()); pushFollow(FOLLOW_1); @@ -4042,17 +3907,17 @@ public final void entryRuleBase64Binary() throws RecognitionException { // $ANTLR start "ruleBase64Binary" - // InternalRos.g:1312:1: ruleBase64Binary : ( RULE_BINARY ) ; + // InternalRosParser.g:1326:1: ruleBase64Binary : ( RULE_BINARY ) ; public final void ruleBase64Binary() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1316:2: ( ( RULE_BINARY ) ) - // InternalRos.g:1317:2: ( RULE_BINARY ) + // InternalRosParser.g:1330:2: ( ( RULE_BINARY ) ) + // InternalRosParser.g:1331:2: ( RULE_BINARY ) { - // InternalRos.g:1317:2: ( RULE_BINARY ) - // InternalRos.g:1318:3: RULE_BINARY + // InternalRosParser.g:1331:2: ( RULE_BINARY ) + // InternalRosParser.g:1332:3: RULE_BINARY { before(grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); match(input,RULE_BINARY,FOLLOW_2); @@ -4079,11 +3944,11 @@ public final void ruleBase64Binary() throws RecognitionException { // $ANTLR start "entryRuleboolean0" - // InternalRos.g:1328:1: entryRuleboolean0 : ruleboolean0 EOF ; + // InternalRosParser.g:1342:1: entryRuleboolean0 : ruleboolean0 EOF ; public final void entryRuleboolean0() throws RecognitionException { try { - // InternalRos.g:1329:1: ( ruleboolean0 EOF ) - // InternalRos.g:1330:1: ruleboolean0 EOF + // InternalRosParser.g:1343:1: ( ruleboolean0 EOF ) + // InternalRosParser.g:1344:1: ruleboolean0 EOF { before(grammarAccess.getBoolean0Rule()); pushFollow(FOLLOW_1); @@ -4109,17 +3974,17 @@ public final void entryRuleboolean0() throws RecognitionException { // $ANTLR start "ruleboolean0" - // InternalRos.g:1337:1: ruleboolean0 : ( RULE_BOOLEAN ) ; + // InternalRosParser.g:1351:1: ruleboolean0 : ( RULE_BOOLEAN ) ; public final void ruleboolean0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1341:2: ( ( RULE_BOOLEAN ) ) - // InternalRos.g:1342:2: ( RULE_BOOLEAN ) + // InternalRosParser.g:1355:2: ( ( RULE_BOOLEAN ) ) + // InternalRosParser.g:1356:2: ( RULE_BOOLEAN ) { - // InternalRos.g:1342:2: ( RULE_BOOLEAN ) - // InternalRos.g:1343:3: RULE_BOOLEAN + // InternalRosParser.g:1356:2: ( RULE_BOOLEAN ) + // InternalRosParser.g:1357:3: RULE_BOOLEAN { before(grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); match(input,RULE_BOOLEAN,FOLLOW_2); @@ -4146,11 +4011,11 @@ public final void ruleboolean0() throws RecognitionException { // $ANTLR start "entryRuleDouble0" - // InternalRos.g:1353:1: entryRuleDouble0 : ruleDouble0 EOF ; + // InternalRosParser.g:1367:1: entryRuleDouble0 : ruleDouble0 EOF ; public final void entryRuleDouble0() throws RecognitionException { try { - // InternalRos.g:1354:1: ( ruleDouble0 EOF ) - // InternalRos.g:1355:1: ruleDouble0 EOF + // InternalRosParser.g:1368:1: ( ruleDouble0 EOF ) + // InternalRosParser.g:1369:1: ruleDouble0 EOF { before(grammarAccess.getDouble0Rule()); pushFollow(FOLLOW_1); @@ -4176,17 +4041,17 @@ public final void entryRuleDouble0() throws RecognitionException { // $ANTLR start "ruleDouble0" - // InternalRos.g:1362:1: ruleDouble0 : ( RULE_DOUBLE ) ; + // InternalRosParser.g:1376:1: ruleDouble0 : ( RULE_DOUBLE ) ; public final void ruleDouble0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1366:2: ( ( RULE_DOUBLE ) ) - // InternalRos.g:1367:2: ( RULE_DOUBLE ) + // InternalRosParser.g:1380:2: ( ( RULE_DOUBLE ) ) + // InternalRosParser.g:1381:2: ( RULE_DOUBLE ) { - // InternalRos.g:1367:2: ( RULE_DOUBLE ) - // InternalRos.g:1368:3: RULE_DOUBLE + // InternalRosParser.g:1381:2: ( RULE_DOUBLE ) + // InternalRosParser.g:1382:3: RULE_DOUBLE { before(grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); match(input,RULE_DOUBLE,FOLLOW_2); @@ -4213,11 +4078,11 @@ public final void ruleDouble0() throws RecognitionException { // $ANTLR start "entryRuleInteger0" - // InternalRos.g:1378:1: entryRuleInteger0 : ruleInteger0 EOF ; + // InternalRosParser.g:1392:1: entryRuleInteger0 : ruleInteger0 EOF ; public final void entryRuleInteger0() throws RecognitionException { try { - // InternalRos.g:1379:1: ( ruleInteger0 EOF ) - // InternalRos.g:1380:1: ruleInteger0 EOF + // InternalRosParser.g:1393:1: ( ruleInteger0 EOF ) + // InternalRosParser.g:1394:1: ruleInteger0 EOF { before(grammarAccess.getInteger0Rule()); pushFollow(FOLLOW_1); @@ -4243,17 +4108,17 @@ public final void entryRuleInteger0() throws RecognitionException { // $ANTLR start "ruleInteger0" - // InternalRos.g:1387:1: ruleInteger0 : ( RULE_DECINT ) ; + // InternalRosParser.g:1401:1: ruleInteger0 : ( RULE_DECINT ) ; public final void ruleInteger0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1391:2: ( ( RULE_DECINT ) ) - // InternalRos.g:1392:2: ( RULE_DECINT ) + // InternalRosParser.g:1405:2: ( ( RULE_DECINT ) ) + // InternalRosParser.g:1406:2: ( RULE_DECINT ) { - // InternalRos.g:1392:2: ( RULE_DECINT ) - // InternalRos.g:1393:3: RULE_DECINT + // InternalRosParser.g:1406:2: ( RULE_DECINT ) + // InternalRosParser.g:1407:3: RULE_DECINT { before(grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); match(input,RULE_DECINT,FOLLOW_2); @@ -4280,11 +4145,11 @@ public final void ruleInteger0() throws RecognitionException { // $ANTLR start "entryRuleDateTime0" - // InternalRos.g:1403:1: entryRuleDateTime0 : ruleDateTime0 EOF ; + // InternalRosParser.g:1417:1: entryRuleDateTime0 : ruleDateTime0 EOF ; public final void entryRuleDateTime0() throws RecognitionException { try { - // InternalRos.g:1404:1: ( ruleDateTime0 EOF ) - // InternalRos.g:1405:1: ruleDateTime0 EOF + // InternalRosParser.g:1418:1: ( ruleDateTime0 EOF ) + // InternalRosParser.g:1419:1: ruleDateTime0 EOF { before(grammarAccess.getDateTime0Rule()); pushFollow(FOLLOW_1); @@ -4310,17 +4175,17 @@ public final void entryRuleDateTime0() throws RecognitionException { // $ANTLR start "ruleDateTime0" - // InternalRos.g:1412:1: ruleDateTime0 : ( RULE_DATE_TIME ) ; + // InternalRosParser.g:1426:1: ruleDateTime0 : ( RULE_DATE_TIME ) ; public final void ruleDateTime0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1416:2: ( ( RULE_DATE_TIME ) ) - // InternalRos.g:1417:2: ( RULE_DATE_TIME ) + // InternalRosParser.g:1430:2: ( ( RULE_DATE_TIME ) ) + // InternalRosParser.g:1431:2: ( RULE_DATE_TIME ) { - // InternalRos.g:1417:2: ( RULE_DATE_TIME ) - // InternalRos.g:1418:3: RULE_DATE_TIME + // InternalRosParser.g:1431:2: ( RULE_DATE_TIME ) + // InternalRosParser.g:1432:3: RULE_DATE_TIME { before(grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); match(input,RULE_DATE_TIME,FOLLOW_2); @@ -4347,11 +4212,11 @@ public final void ruleDateTime0() throws RecognitionException { // $ANTLR start "entryRuleMessagePart" - // InternalRos.g:1428:1: entryRuleMessagePart : ruleMessagePart EOF ; + // InternalRosParser.g:1442:1: entryRuleMessagePart : ruleMessagePart EOF ; public final void entryRuleMessagePart() throws RecognitionException { try { - // InternalRos.g:1429:1: ( ruleMessagePart EOF ) - // InternalRos.g:1430:1: ruleMessagePart EOF + // InternalRosParser.g:1443:1: ( ruleMessagePart EOF ) + // InternalRosParser.g:1444:1: ruleMessagePart EOF { before(grammarAccess.getMessagePartRule()); pushFollow(FOLLOW_1); @@ -4377,21 +4242,21 @@ public final void entryRuleMessagePart() throws RecognitionException { // $ANTLR start "ruleMessagePart" - // InternalRos.g:1437:1: ruleMessagePart : ( ( rule__MessagePart__Group__0 ) ) ; + // InternalRosParser.g:1451:1: ruleMessagePart : ( ( rule__MessagePart__Group__0 ) ) ; public final void ruleMessagePart() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1441:2: ( ( ( rule__MessagePart__Group__0 ) ) ) - // InternalRos.g:1442:2: ( ( rule__MessagePart__Group__0 ) ) + // InternalRosParser.g:1455:2: ( ( ( rule__MessagePart__Group__0 ) ) ) + // InternalRosParser.g:1456:2: ( ( rule__MessagePart__Group__0 ) ) { - // InternalRos.g:1442:2: ( ( rule__MessagePart__Group__0 ) ) - // InternalRos.g:1443:3: ( rule__MessagePart__Group__0 ) + // InternalRosParser.g:1456:2: ( ( rule__MessagePart__Group__0 ) ) + // InternalRosParser.g:1457:3: ( rule__MessagePart__Group__0 ) { before(grammarAccess.getMessagePartAccess().getGroup()); - // InternalRos.g:1444:3: ( rule__MessagePart__Group__0 ) - // InternalRos.g:1444:4: rule__MessagePart__Group__0 + // InternalRosParser.g:1458:3: ( rule__MessagePart__Group__0 ) + // InternalRosParser.g:1458:4: rule__MessagePart__Group__0 { pushFollow(FOLLOW_2); rule__MessagePart__Group__0(); @@ -4424,11 +4289,11 @@ public final void ruleMessagePart() throws RecognitionException { // $ANTLR start "entryRuleAbstractType" - // InternalRos.g:1453:1: entryRuleAbstractType : ruleAbstractType EOF ; + // InternalRosParser.g:1467:1: entryRuleAbstractType : ruleAbstractType EOF ; public final void entryRuleAbstractType() throws RecognitionException { try { - // InternalRos.g:1454:1: ( ruleAbstractType EOF ) - // InternalRos.g:1455:1: ruleAbstractType EOF + // InternalRosParser.g:1468:1: ( ruleAbstractType EOF ) + // InternalRosParser.g:1469:1: ruleAbstractType EOF { before(grammarAccess.getAbstractTypeRule()); pushFollow(FOLLOW_1); @@ -4454,21 +4319,21 @@ public final void entryRuleAbstractType() throws RecognitionException { // $ANTLR start "ruleAbstractType" - // InternalRos.g:1462:1: ruleAbstractType : ( ( rule__AbstractType__Alternatives ) ) ; + // InternalRosParser.g:1476:1: ruleAbstractType : ( ( rule__AbstractType__Alternatives ) ) ; public final void ruleAbstractType() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1466:2: ( ( ( rule__AbstractType__Alternatives ) ) ) - // InternalRos.g:1467:2: ( ( rule__AbstractType__Alternatives ) ) + // InternalRosParser.g:1480:2: ( ( ( rule__AbstractType__Alternatives ) ) ) + // InternalRosParser.g:1481:2: ( ( rule__AbstractType__Alternatives ) ) { - // InternalRos.g:1467:2: ( ( rule__AbstractType__Alternatives ) ) - // InternalRos.g:1468:3: ( rule__AbstractType__Alternatives ) + // InternalRosParser.g:1481:2: ( ( rule__AbstractType__Alternatives ) ) + // InternalRosParser.g:1482:3: ( rule__AbstractType__Alternatives ) { before(grammarAccess.getAbstractTypeAccess().getAlternatives()); - // InternalRos.g:1469:3: ( rule__AbstractType__Alternatives ) - // InternalRos.g:1469:4: rule__AbstractType__Alternatives + // InternalRosParser.g:1483:3: ( rule__AbstractType__Alternatives ) + // InternalRosParser.g:1483:4: rule__AbstractType__Alternatives { pushFollow(FOLLOW_2); rule__AbstractType__Alternatives(); @@ -4501,11 +4366,11 @@ public final void ruleAbstractType() throws RecognitionException { // $ANTLR start "entryRulebool" - // InternalRos.g:1478:1: entryRulebool : rulebool EOF ; + // InternalRosParser.g:1492:1: entryRulebool : rulebool EOF ; public final void entryRulebool() throws RecognitionException { try { - // InternalRos.g:1479:1: ( rulebool EOF ) - // InternalRos.g:1480:1: rulebool EOF + // InternalRosParser.g:1493:1: ( rulebool EOF ) + // InternalRosParser.g:1494:1: rulebool EOF { before(grammarAccess.getBoolRule()); pushFollow(FOLLOW_1); @@ -4531,21 +4396,21 @@ public final void entryRulebool() throws RecognitionException { // $ANTLR start "rulebool" - // InternalRos.g:1487:1: rulebool : ( ( rule__Bool__Group__0 ) ) ; + // InternalRosParser.g:1501:1: rulebool : ( ( rule__Bool__Group__0 ) ) ; public final void rulebool() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1491:2: ( ( ( rule__Bool__Group__0 ) ) ) - // InternalRos.g:1492:2: ( ( rule__Bool__Group__0 ) ) + // InternalRosParser.g:1505:2: ( ( ( rule__Bool__Group__0 ) ) ) + // InternalRosParser.g:1506:2: ( ( rule__Bool__Group__0 ) ) { - // InternalRos.g:1492:2: ( ( rule__Bool__Group__0 ) ) - // InternalRos.g:1493:3: ( rule__Bool__Group__0 ) + // InternalRosParser.g:1506:2: ( ( rule__Bool__Group__0 ) ) + // InternalRosParser.g:1507:3: ( rule__Bool__Group__0 ) { before(grammarAccess.getBoolAccess().getGroup()); - // InternalRos.g:1494:3: ( rule__Bool__Group__0 ) - // InternalRos.g:1494:4: rule__Bool__Group__0 + // InternalRosParser.g:1508:3: ( rule__Bool__Group__0 ) + // InternalRosParser.g:1508:4: rule__Bool__Group__0 { pushFollow(FOLLOW_2); rule__Bool__Group__0(); @@ -4578,11 +4443,11 @@ public final void rulebool() throws RecognitionException { // $ANTLR start "entryRuleint8" - // InternalRos.g:1503:1: entryRuleint8 : ruleint8 EOF ; + // InternalRosParser.g:1517:1: entryRuleint8 : ruleint8 EOF ; public final void entryRuleint8() throws RecognitionException { try { - // InternalRos.g:1504:1: ( ruleint8 EOF ) - // InternalRos.g:1505:1: ruleint8 EOF + // InternalRosParser.g:1518:1: ( ruleint8 EOF ) + // InternalRosParser.g:1519:1: ruleint8 EOF { before(grammarAccess.getInt8Rule()); pushFollow(FOLLOW_1); @@ -4608,21 +4473,21 @@ public final void entryRuleint8() throws RecognitionException { // $ANTLR start "ruleint8" - // InternalRos.g:1512:1: ruleint8 : ( ( rule__Int8__Group__0 ) ) ; + // InternalRosParser.g:1526:1: ruleint8 : ( ( rule__Int8__Group__0 ) ) ; public final void ruleint8() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1516:2: ( ( ( rule__Int8__Group__0 ) ) ) - // InternalRos.g:1517:2: ( ( rule__Int8__Group__0 ) ) + // InternalRosParser.g:1530:2: ( ( ( rule__Int8__Group__0 ) ) ) + // InternalRosParser.g:1531:2: ( ( rule__Int8__Group__0 ) ) { - // InternalRos.g:1517:2: ( ( rule__Int8__Group__0 ) ) - // InternalRos.g:1518:3: ( rule__Int8__Group__0 ) + // InternalRosParser.g:1531:2: ( ( rule__Int8__Group__0 ) ) + // InternalRosParser.g:1532:3: ( rule__Int8__Group__0 ) { before(grammarAccess.getInt8Access().getGroup()); - // InternalRos.g:1519:3: ( rule__Int8__Group__0 ) - // InternalRos.g:1519:4: rule__Int8__Group__0 + // InternalRosParser.g:1533:3: ( rule__Int8__Group__0 ) + // InternalRosParser.g:1533:4: rule__Int8__Group__0 { pushFollow(FOLLOW_2); rule__Int8__Group__0(); @@ -4655,11 +4520,11 @@ public final void ruleint8() throws RecognitionException { // $ANTLR start "entryRuleuint8" - // InternalRos.g:1528:1: entryRuleuint8 : ruleuint8 EOF ; + // InternalRosParser.g:1542:1: entryRuleuint8 : ruleuint8 EOF ; public final void entryRuleuint8() throws RecognitionException { try { - // InternalRos.g:1529:1: ( ruleuint8 EOF ) - // InternalRos.g:1530:1: ruleuint8 EOF + // InternalRosParser.g:1543:1: ( ruleuint8 EOF ) + // InternalRosParser.g:1544:1: ruleuint8 EOF { before(grammarAccess.getUint8Rule()); pushFollow(FOLLOW_1); @@ -4685,21 +4550,21 @@ public final void entryRuleuint8() throws RecognitionException { // $ANTLR start "ruleuint8" - // InternalRos.g:1537:1: ruleuint8 : ( ( rule__Uint8__Group__0 ) ) ; + // InternalRosParser.g:1551:1: ruleuint8 : ( ( rule__Uint8__Group__0 ) ) ; public final void ruleuint8() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1541:2: ( ( ( rule__Uint8__Group__0 ) ) ) - // InternalRos.g:1542:2: ( ( rule__Uint8__Group__0 ) ) + // InternalRosParser.g:1555:2: ( ( ( rule__Uint8__Group__0 ) ) ) + // InternalRosParser.g:1556:2: ( ( rule__Uint8__Group__0 ) ) { - // InternalRos.g:1542:2: ( ( rule__Uint8__Group__0 ) ) - // InternalRos.g:1543:3: ( rule__Uint8__Group__0 ) + // InternalRosParser.g:1556:2: ( ( rule__Uint8__Group__0 ) ) + // InternalRosParser.g:1557:3: ( rule__Uint8__Group__0 ) { before(grammarAccess.getUint8Access().getGroup()); - // InternalRos.g:1544:3: ( rule__Uint8__Group__0 ) - // InternalRos.g:1544:4: rule__Uint8__Group__0 + // InternalRosParser.g:1558:3: ( rule__Uint8__Group__0 ) + // InternalRosParser.g:1558:4: rule__Uint8__Group__0 { pushFollow(FOLLOW_2); rule__Uint8__Group__0(); @@ -4732,11 +4597,11 @@ public final void ruleuint8() throws RecognitionException { // $ANTLR start "entryRuleint16" - // InternalRos.g:1553:1: entryRuleint16 : ruleint16 EOF ; + // InternalRosParser.g:1567:1: entryRuleint16 : ruleint16 EOF ; public final void entryRuleint16() throws RecognitionException { try { - // InternalRos.g:1554:1: ( ruleint16 EOF ) - // InternalRos.g:1555:1: ruleint16 EOF + // InternalRosParser.g:1568:1: ( ruleint16 EOF ) + // InternalRosParser.g:1569:1: ruleint16 EOF { before(grammarAccess.getInt16Rule()); pushFollow(FOLLOW_1); @@ -4762,21 +4627,21 @@ public final void entryRuleint16() throws RecognitionException { // $ANTLR start "ruleint16" - // InternalRos.g:1562:1: ruleint16 : ( ( rule__Int16__Group__0 ) ) ; + // InternalRosParser.g:1576:1: ruleint16 : ( ( rule__Int16__Group__0 ) ) ; public final void ruleint16() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1566:2: ( ( ( rule__Int16__Group__0 ) ) ) - // InternalRos.g:1567:2: ( ( rule__Int16__Group__0 ) ) + // InternalRosParser.g:1580:2: ( ( ( rule__Int16__Group__0 ) ) ) + // InternalRosParser.g:1581:2: ( ( rule__Int16__Group__0 ) ) { - // InternalRos.g:1567:2: ( ( rule__Int16__Group__0 ) ) - // InternalRos.g:1568:3: ( rule__Int16__Group__0 ) + // InternalRosParser.g:1581:2: ( ( rule__Int16__Group__0 ) ) + // InternalRosParser.g:1582:3: ( rule__Int16__Group__0 ) { before(grammarAccess.getInt16Access().getGroup()); - // InternalRos.g:1569:3: ( rule__Int16__Group__0 ) - // InternalRos.g:1569:4: rule__Int16__Group__0 + // InternalRosParser.g:1583:3: ( rule__Int16__Group__0 ) + // InternalRosParser.g:1583:4: rule__Int16__Group__0 { pushFollow(FOLLOW_2); rule__Int16__Group__0(); @@ -4809,11 +4674,11 @@ public final void ruleint16() throws RecognitionException { // $ANTLR start "entryRuleuint16" - // InternalRos.g:1578:1: entryRuleuint16 : ruleuint16 EOF ; + // InternalRosParser.g:1592:1: entryRuleuint16 : ruleuint16 EOF ; public final void entryRuleuint16() throws RecognitionException { try { - // InternalRos.g:1579:1: ( ruleuint16 EOF ) - // InternalRos.g:1580:1: ruleuint16 EOF + // InternalRosParser.g:1593:1: ( ruleuint16 EOF ) + // InternalRosParser.g:1594:1: ruleuint16 EOF { before(grammarAccess.getUint16Rule()); pushFollow(FOLLOW_1); @@ -4839,21 +4704,21 @@ public final void entryRuleuint16() throws RecognitionException { // $ANTLR start "ruleuint16" - // InternalRos.g:1587:1: ruleuint16 : ( ( rule__Uint16__Group__0 ) ) ; + // InternalRosParser.g:1601:1: ruleuint16 : ( ( rule__Uint16__Group__0 ) ) ; public final void ruleuint16() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1591:2: ( ( ( rule__Uint16__Group__0 ) ) ) - // InternalRos.g:1592:2: ( ( rule__Uint16__Group__0 ) ) + // InternalRosParser.g:1605:2: ( ( ( rule__Uint16__Group__0 ) ) ) + // InternalRosParser.g:1606:2: ( ( rule__Uint16__Group__0 ) ) { - // InternalRos.g:1592:2: ( ( rule__Uint16__Group__0 ) ) - // InternalRos.g:1593:3: ( rule__Uint16__Group__0 ) + // InternalRosParser.g:1606:2: ( ( rule__Uint16__Group__0 ) ) + // InternalRosParser.g:1607:3: ( rule__Uint16__Group__0 ) { before(grammarAccess.getUint16Access().getGroup()); - // InternalRos.g:1594:3: ( rule__Uint16__Group__0 ) - // InternalRos.g:1594:4: rule__Uint16__Group__0 + // InternalRosParser.g:1608:3: ( rule__Uint16__Group__0 ) + // InternalRosParser.g:1608:4: rule__Uint16__Group__0 { pushFollow(FOLLOW_2); rule__Uint16__Group__0(); @@ -4886,11 +4751,11 @@ public final void ruleuint16() throws RecognitionException { // $ANTLR start "entryRuleint32" - // InternalRos.g:1603:1: entryRuleint32 : ruleint32 EOF ; + // InternalRosParser.g:1617:1: entryRuleint32 : ruleint32 EOF ; public final void entryRuleint32() throws RecognitionException { try { - // InternalRos.g:1604:1: ( ruleint32 EOF ) - // InternalRos.g:1605:1: ruleint32 EOF + // InternalRosParser.g:1618:1: ( ruleint32 EOF ) + // InternalRosParser.g:1619:1: ruleint32 EOF { before(grammarAccess.getInt32Rule()); pushFollow(FOLLOW_1); @@ -4916,21 +4781,21 @@ public final void entryRuleint32() throws RecognitionException { // $ANTLR start "ruleint32" - // InternalRos.g:1612:1: ruleint32 : ( ( rule__Int32__Group__0 ) ) ; + // InternalRosParser.g:1626:1: ruleint32 : ( ( rule__Int32__Group__0 ) ) ; public final void ruleint32() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1616:2: ( ( ( rule__Int32__Group__0 ) ) ) - // InternalRos.g:1617:2: ( ( rule__Int32__Group__0 ) ) + // InternalRosParser.g:1630:2: ( ( ( rule__Int32__Group__0 ) ) ) + // InternalRosParser.g:1631:2: ( ( rule__Int32__Group__0 ) ) { - // InternalRos.g:1617:2: ( ( rule__Int32__Group__0 ) ) - // InternalRos.g:1618:3: ( rule__Int32__Group__0 ) + // InternalRosParser.g:1631:2: ( ( rule__Int32__Group__0 ) ) + // InternalRosParser.g:1632:3: ( rule__Int32__Group__0 ) { before(grammarAccess.getInt32Access().getGroup()); - // InternalRos.g:1619:3: ( rule__Int32__Group__0 ) - // InternalRos.g:1619:4: rule__Int32__Group__0 + // InternalRosParser.g:1633:3: ( rule__Int32__Group__0 ) + // InternalRosParser.g:1633:4: rule__Int32__Group__0 { pushFollow(FOLLOW_2); rule__Int32__Group__0(); @@ -4963,11 +4828,11 @@ public final void ruleint32() throws RecognitionException { // $ANTLR start "entryRuleuint32" - // InternalRos.g:1628:1: entryRuleuint32 : ruleuint32 EOF ; + // InternalRosParser.g:1642:1: entryRuleuint32 : ruleuint32 EOF ; public final void entryRuleuint32() throws RecognitionException { try { - // InternalRos.g:1629:1: ( ruleuint32 EOF ) - // InternalRos.g:1630:1: ruleuint32 EOF + // InternalRosParser.g:1643:1: ( ruleuint32 EOF ) + // InternalRosParser.g:1644:1: ruleuint32 EOF { before(grammarAccess.getUint32Rule()); pushFollow(FOLLOW_1); @@ -4993,21 +4858,21 @@ public final void entryRuleuint32() throws RecognitionException { // $ANTLR start "ruleuint32" - // InternalRos.g:1637:1: ruleuint32 : ( ( rule__Uint32__Group__0 ) ) ; + // InternalRosParser.g:1651:1: ruleuint32 : ( ( rule__Uint32__Group__0 ) ) ; public final void ruleuint32() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1641:2: ( ( ( rule__Uint32__Group__0 ) ) ) - // InternalRos.g:1642:2: ( ( rule__Uint32__Group__0 ) ) + // InternalRosParser.g:1655:2: ( ( ( rule__Uint32__Group__0 ) ) ) + // InternalRosParser.g:1656:2: ( ( rule__Uint32__Group__0 ) ) { - // InternalRos.g:1642:2: ( ( rule__Uint32__Group__0 ) ) - // InternalRos.g:1643:3: ( rule__Uint32__Group__0 ) + // InternalRosParser.g:1656:2: ( ( rule__Uint32__Group__0 ) ) + // InternalRosParser.g:1657:3: ( rule__Uint32__Group__0 ) { before(grammarAccess.getUint32Access().getGroup()); - // InternalRos.g:1644:3: ( rule__Uint32__Group__0 ) - // InternalRos.g:1644:4: rule__Uint32__Group__0 + // InternalRosParser.g:1658:3: ( rule__Uint32__Group__0 ) + // InternalRosParser.g:1658:4: rule__Uint32__Group__0 { pushFollow(FOLLOW_2); rule__Uint32__Group__0(); @@ -5040,11 +4905,11 @@ public final void ruleuint32() throws RecognitionException { // $ANTLR start "entryRuleint64" - // InternalRos.g:1653:1: entryRuleint64 : ruleint64 EOF ; + // InternalRosParser.g:1667:1: entryRuleint64 : ruleint64 EOF ; public final void entryRuleint64() throws RecognitionException { try { - // InternalRos.g:1654:1: ( ruleint64 EOF ) - // InternalRos.g:1655:1: ruleint64 EOF + // InternalRosParser.g:1668:1: ( ruleint64 EOF ) + // InternalRosParser.g:1669:1: ruleint64 EOF { before(grammarAccess.getInt64Rule()); pushFollow(FOLLOW_1); @@ -5070,21 +4935,21 @@ public final void entryRuleint64() throws RecognitionException { // $ANTLR start "ruleint64" - // InternalRos.g:1662:1: ruleint64 : ( ( rule__Int64__Group__0 ) ) ; + // InternalRosParser.g:1676:1: ruleint64 : ( ( rule__Int64__Group__0 ) ) ; public final void ruleint64() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1666:2: ( ( ( rule__Int64__Group__0 ) ) ) - // InternalRos.g:1667:2: ( ( rule__Int64__Group__0 ) ) + // InternalRosParser.g:1680:2: ( ( ( rule__Int64__Group__0 ) ) ) + // InternalRosParser.g:1681:2: ( ( rule__Int64__Group__0 ) ) { - // InternalRos.g:1667:2: ( ( rule__Int64__Group__0 ) ) - // InternalRos.g:1668:3: ( rule__Int64__Group__0 ) + // InternalRosParser.g:1681:2: ( ( rule__Int64__Group__0 ) ) + // InternalRosParser.g:1682:3: ( rule__Int64__Group__0 ) { before(grammarAccess.getInt64Access().getGroup()); - // InternalRos.g:1669:3: ( rule__Int64__Group__0 ) - // InternalRos.g:1669:4: rule__Int64__Group__0 + // InternalRosParser.g:1683:3: ( rule__Int64__Group__0 ) + // InternalRosParser.g:1683:4: rule__Int64__Group__0 { pushFollow(FOLLOW_2); rule__Int64__Group__0(); @@ -5117,11 +4982,11 @@ public final void ruleint64() throws RecognitionException { // $ANTLR start "entryRuleuint64" - // InternalRos.g:1678:1: entryRuleuint64 : ruleuint64 EOF ; + // InternalRosParser.g:1692:1: entryRuleuint64 : ruleuint64 EOF ; public final void entryRuleuint64() throws RecognitionException { try { - // InternalRos.g:1679:1: ( ruleuint64 EOF ) - // InternalRos.g:1680:1: ruleuint64 EOF + // InternalRosParser.g:1693:1: ( ruleuint64 EOF ) + // InternalRosParser.g:1694:1: ruleuint64 EOF { before(grammarAccess.getUint64Rule()); pushFollow(FOLLOW_1); @@ -5147,21 +5012,21 @@ public final void entryRuleuint64() throws RecognitionException { // $ANTLR start "ruleuint64" - // InternalRos.g:1687:1: ruleuint64 : ( ( rule__Uint64__Group__0 ) ) ; + // InternalRosParser.g:1701:1: ruleuint64 : ( ( rule__Uint64__Group__0 ) ) ; public final void ruleuint64() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1691:2: ( ( ( rule__Uint64__Group__0 ) ) ) - // InternalRos.g:1692:2: ( ( rule__Uint64__Group__0 ) ) + // InternalRosParser.g:1705:2: ( ( ( rule__Uint64__Group__0 ) ) ) + // InternalRosParser.g:1706:2: ( ( rule__Uint64__Group__0 ) ) { - // InternalRos.g:1692:2: ( ( rule__Uint64__Group__0 ) ) - // InternalRos.g:1693:3: ( rule__Uint64__Group__0 ) + // InternalRosParser.g:1706:2: ( ( rule__Uint64__Group__0 ) ) + // InternalRosParser.g:1707:3: ( rule__Uint64__Group__0 ) { before(grammarAccess.getUint64Access().getGroup()); - // InternalRos.g:1694:3: ( rule__Uint64__Group__0 ) - // InternalRos.g:1694:4: rule__Uint64__Group__0 + // InternalRosParser.g:1708:3: ( rule__Uint64__Group__0 ) + // InternalRosParser.g:1708:4: rule__Uint64__Group__0 { pushFollow(FOLLOW_2); rule__Uint64__Group__0(); @@ -5194,11 +5059,11 @@ public final void ruleuint64() throws RecognitionException { // $ANTLR start "entryRulefloat32" - // InternalRos.g:1703:1: entryRulefloat32 : rulefloat32 EOF ; + // InternalRosParser.g:1717:1: entryRulefloat32 : rulefloat32 EOF ; public final void entryRulefloat32() throws RecognitionException { try { - // InternalRos.g:1704:1: ( rulefloat32 EOF ) - // InternalRos.g:1705:1: rulefloat32 EOF + // InternalRosParser.g:1718:1: ( rulefloat32 EOF ) + // InternalRosParser.g:1719:1: rulefloat32 EOF { before(grammarAccess.getFloat32Rule()); pushFollow(FOLLOW_1); @@ -5224,21 +5089,21 @@ public final void entryRulefloat32() throws RecognitionException { // $ANTLR start "rulefloat32" - // InternalRos.g:1712:1: rulefloat32 : ( ( rule__Float32__Group__0 ) ) ; + // InternalRosParser.g:1726:1: rulefloat32 : ( ( rule__Float32__Group__0 ) ) ; public final void rulefloat32() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1716:2: ( ( ( rule__Float32__Group__0 ) ) ) - // InternalRos.g:1717:2: ( ( rule__Float32__Group__0 ) ) + // InternalRosParser.g:1730:2: ( ( ( rule__Float32__Group__0 ) ) ) + // InternalRosParser.g:1731:2: ( ( rule__Float32__Group__0 ) ) { - // InternalRos.g:1717:2: ( ( rule__Float32__Group__0 ) ) - // InternalRos.g:1718:3: ( rule__Float32__Group__0 ) + // InternalRosParser.g:1731:2: ( ( rule__Float32__Group__0 ) ) + // InternalRosParser.g:1732:3: ( rule__Float32__Group__0 ) { before(grammarAccess.getFloat32Access().getGroup()); - // InternalRos.g:1719:3: ( rule__Float32__Group__0 ) - // InternalRos.g:1719:4: rule__Float32__Group__0 + // InternalRosParser.g:1733:3: ( rule__Float32__Group__0 ) + // InternalRosParser.g:1733:4: rule__Float32__Group__0 { pushFollow(FOLLOW_2); rule__Float32__Group__0(); @@ -5271,11 +5136,11 @@ public final void rulefloat32() throws RecognitionException { // $ANTLR start "entryRulefloat64" - // InternalRos.g:1728:1: entryRulefloat64 : rulefloat64 EOF ; + // InternalRosParser.g:1742:1: entryRulefloat64 : rulefloat64 EOF ; public final void entryRulefloat64() throws RecognitionException { try { - // InternalRos.g:1729:1: ( rulefloat64 EOF ) - // InternalRos.g:1730:1: rulefloat64 EOF + // InternalRosParser.g:1743:1: ( rulefloat64 EOF ) + // InternalRosParser.g:1744:1: rulefloat64 EOF { before(grammarAccess.getFloat64Rule()); pushFollow(FOLLOW_1); @@ -5301,21 +5166,21 @@ public final void entryRulefloat64() throws RecognitionException { // $ANTLR start "rulefloat64" - // InternalRos.g:1737:1: rulefloat64 : ( ( rule__Float64__Group__0 ) ) ; + // InternalRosParser.g:1751:1: rulefloat64 : ( ( rule__Float64__Group__0 ) ) ; public final void rulefloat64() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1741:2: ( ( ( rule__Float64__Group__0 ) ) ) - // InternalRos.g:1742:2: ( ( rule__Float64__Group__0 ) ) + // InternalRosParser.g:1755:2: ( ( ( rule__Float64__Group__0 ) ) ) + // InternalRosParser.g:1756:2: ( ( rule__Float64__Group__0 ) ) { - // InternalRos.g:1742:2: ( ( rule__Float64__Group__0 ) ) - // InternalRos.g:1743:3: ( rule__Float64__Group__0 ) + // InternalRosParser.g:1756:2: ( ( rule__Float64__Group__0 ) ) + // InternalRosParser.g:1757:3: ( rule__Float64__Group__0 ) { before(grammarAccess.getFloat64Access().getGroup()); - // InternalRos.g:1744:3: ( rule__Float64__Group__0 ) - // InternalRos.g:1744:4: rule__Float64__Group__0 + // InternalRosParser.g:1758:3: ( rule__Float64__Group__0 ) + // InternalRosParser.g:1758:4: rule__Float64__Group__0 { pushFollow(FOLLOW_2); rule__Float64__Group__0(); @@ -5348,11 +5213,11 @@ public final void rulefloat64() throws RecognitionException { // $ANTLR start "entryRulestring0" - // InternalRos.g:1753:1: entryRulestring0 : rulestring0 EOF ; + // InternalRosParser.g:1767:1: entryRulestring0 : rulestring0 EOF ; public final void entryRulestring0() throws RecognitionException { try { - // InternalRos.g:1754:1: ( rulestring0 EOF ) - // InternalRos.g:1755:1: rulestring0 EOF + // InternalRosParser.g:1768:1: ( rulestring0 EOF ) + // InternalRosParser.g:1769:1: rulestring0 EOF { before(grammarAccess.getString0Rule()); pushFollow(FOLLOW_1); @@ -5378,21 +5243,21 @@ public final void entryRulestring0() throws RecognitionException { // $ANTLR start "rulestring0" - // InternalRos.g:1762:1: rulestring0 : ( ( rule__String0__Group__0 ) ) ; + // InternalRosParser.g:1776:1: rulestring0 : ( ( rule__String0__Group__0 ) ) ; public final void rulestring0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1766:2: ( ( ( rule__String0__Group__0 ) ) ) - // InternalRos.g:1767:2: ( ( rule__String0__Group__0 ) ) + // InternalRosParser.g:1780:2: ( ( ( rule__String0__Group__0 ) ) ) + // InternalRosParser.g:1781:2: ( ( rule__String0__Group__0 ) ) { - // InternalRos.g:1767:2: ( ( rule__String0__Group__0 ) ) - // InternalRos.g:1768:3: ( rule__String0__Group__0 ) + // InternalRosParser.g:1781:2: ( ( rule__String0__Group__0 ) ) + // InternalRosParser.g:1782:3: ( rule__String0__Group__0 ) { before(grammarAccess.getString0Access().getGroup()); - // InternalRos.g:1769:3: ( rule__String0__Group__0 ) - // InternalRos.g:1769:4: rule__String0__Group__0 + // InternalRosParser.g:1783:3: ( rule__String0__Group__0 ) + // InternalRosParser.g:1783:4: rule__String0__Group__0 { pushFollow(FOLLOW_2); rule__String0__Group__0(); @@ -5425,11 +5290,11 @@ public final void rulestring0() throws RecognitionException { // $ANTLR start "entryRulebyte" - // InternalRos.g:1778:1: entryRulebyte : rulebyte EOF ; + // InternalRosParser.g:1792:1: entryRulebyte : rulebyte EOF ; public final void entryRulebyte() throws RecognitionException { try { - // InternalRos.g:1779:1: ( rulebyte EOF ) - // InternalRos.g:1780:1: rulebyte EOF + // InternalRosParser.g:1793:1: ( rulebyte EOF ) + // InternalRosParser.g:1794:1: rulebyte EOF { before(grammarAccess.getByteRule()); pushFollow(FOLLOW_1); @@ -5455,21 +5320,21 @@ public final void entryRulebyte() throws RecognitionException { // $ANTLR start "rulebyte" - // InternalRos.g:1787:1: rulebyte : ( ( rule__Byte__Group__0 ) ) ; + // InternalRosParser.g:1801:1: rulebyte : ( ( rule__Byte__Group__0 ) ) ; public final void rulebyte() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1791:2: ( ( ( rule__Byte__Group__0 ) ) ) - // InternalRos.g:1792:2: ( ( rule__Byte__Group__0 ) ) + // InternalRosParser.g:1805:2: ( ( ( rule__Byte__Group__0 ) ) ) + // InternalRosParser.g:1806:2: ( ( rule__Byte__Group__0 ) ) { - // InternalRos.g:1792:2: ( ( rule__Byte__Group__0 ) ) - // InternalRos.g:1793:3: ( rule__Byte__Group__0 ) + // InternalRosParser.g:1806:2: ( ( rule__Byte__Group__0 ) ) + // InternalRosParser.g:1807:3: ( rule__Byte__Group__0 ) { before(grammarAccess.getByteAccess().getGroup()); - // InternalRos.g:1794:3: ( rule__Byte__Group__0 ) - // InternalRos.g:1794:4: rule__Byte__Group__0 + // InternalRosParser.g:1808:3: ( rule__Byte__Group__0 ) + // InternalRosParser.g:1808:4: rule__Byte__Group__0 { pushFollow(FOLLOW_2); rule__Byte__Group__0(); @@ -5502,11 +5367,11 @@ public final void rulebyte() throws RecognitionException { // $ANTLR start "entryRuletime" - // InternalRos.g:1803:1: entryRuletime : ruletime EOF ; + // InternalRosParser.g:1817:1: entryRuletime : ruletime EOF ; public final void entryRuletime() throws RecognitionException { try { - // InternalRos.g:1804:1: ( ruletime EOF ) - // InternalRos.g:1805:1: ruletime EOF + // InternalRosParser.g:1818:1: ( ruletime EOF ) + // InternalRosParser.g:1819:1: ruletime EOF { before(grammarAccess.getTimeRule()); pushFollow(FOLLOW_1); @@ -5532,21 +5397,21 @@ public final void entryRuletime() throws RecognitionException { // $ANTLR start "ruletime" - // InternalRos.g:1812:1: ruletime : ( ( rule__Time__Group__0 ) ) ; + // InternalRosParser.g:1826:1: ruletime : ( ( rule__Time__Group__0 ) ) ; public final void ruletime() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1816:2: ( ( ( rule__Time__Group__0 ) ) ) - // InternalRos.g:1817:2: ( ( rule__Time__Group__0 ) ) + // InternalRosParser.g:1830:2: ( ( ( rule__Time__Group__0 ) ) ) + // InternalRosParser.g:1831:2: ( ( rule__Time__Group__0 ) ) { - // InternalRos.g:1817:2: ( ( rule__Time__Group__0 ) ) - // InternalRos.g:1818:3: ( rule__Time__Group__0 ) + // InternalRosParser.g:1831:2: ( ( rule__Time__Group__0 ) ) + // InternalRosParser.g:1832:3: ( rule__Time__Group__0 ) { before(grammarAccess.getTimeAccess().getGroup()); - // InternalRos.g:1819:3: ( rule__Time__Group__0 ) - // InternalRos.g:1819:4: rule__Time__Group__0 + // InternalRosParser.g:1833:3: ( rule__Time__Group__0 ) + // InternalRosParser.g:1833:4: rule__Time__Group__0 { pushFollow(FOLLOW_2); rule__Time__Group__0(); @@ -5579,11 +5444,11 @@ public final void ruletime() throws RecognitionException { // $ANTLR start "entryRuleduration" - // InternalRos.g:1828:1: entryRuleduration : ruleduration EOF ; + // InternalRosParser.g:1842:1: entryRuleduration : ruleduration EOF ; public final void entryRuleduration() throws RecognitionException { try { - // InternalRos.g:1829:1: ( ruleduration EOF ) - // InternalRos.g:1830:1: ruleduration EOF + // InternalRosParser.g:1843:1: ( ruleduration EOF ) + // InternalRosParser.g:1844:1: ruleduration EOF { before(grammarAccess.getDurationRule()); pushFollow(FOLLOW_1); @@ -5609,21 +5474,21 @@ public final void entryRuleduration() throws RecognitionException { // $ANTLR start "ruleduration" - // InternalRos.g:1837:1: ruleduration : ( ( rule__Duration__Group__0 ) ) ; + // InternalRosParser.g:1851:1: ruleduration : ( ( rule__Duration__Group__0 ) ) ; public final void ruleduration() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1841:2: ( ( ( rule__Duration__Group__0 ) ) ) - // InternalRos.g:1842:2: ( ( rule__Duration__Group__0 ) ) + // InternalRosParser.g:1855:2: ( ( ( rule__Duration__Group__0 ) ) ) + // InternalRosParser.g:1856:2: ( ( rule__Duration__Group__0 ) ) { - // InternalRos.g:1842:2: ( ( rule__Duration__Group__0 ) ) - // InternalRos.g:1843:3: ( rule__Duration__Group__0 ) + // InternalRosParser.g:1856:2: ( ( rule__Duration__Group__0 ) ) + // InternalRosParser.g:1857:3: ( rule__Duration__Group__0 ) { before(grammarAccess.getDurationAccess().getGroup()); - // InternalRos.g:1844:3: ( rule__Duration__Group__0 ) - // InternalRos.g:1844:4: rule__Duration__Group__0 + // InternalRosParser.g:1858:3: ( rule__Duration__Group__0 ) + // InternalRosParser.g:1858:4: rule__Duration__Group__0 { pushFollow(FOLLOW_2); rule__Duration__Group__0(); @@ -5656,11 +5521,11 @@ public final void ruleduration() throws RecognitionException { // $ANTLR start "entryRuleboolArray" - // InternalRos.g:1853:1: entryRuleboolArray : ruleboolArray EOF ; + // InternalRosParser.g:1867:1: entryRuleboolArray : ruleboolArray EOF ; public final void entryRuleboolArray() throws RecognitionException { try { - // InternalRos.g:1854:1: ( ruleboolArray EOF ) - // InternalRos.g:1855:1: ruleboolArray EOF + // InternalRosParser.g:1868:1: ( ruleboolArray EOF ) + // InternalRosParser.g:1869:1: ruleboolArray EOF { before(grammarAccess.getBoolArrayRule()); pushFollow(FOLLOW_1); @@ -5686,21 +5551,21 @@ public final void entryRuleboolArray() throws RecognitionException { // $ANTLR start "ruleboolArray" - // InternalRos.g:1862:1: ruleboolArray : ( ( rule__BoolArray__Group__0 ) ) ; + // InternalRosParser.g:1876:1: ruleboolArray : ( ( rule__BoolArray__Group__0 ) ) ; public final void ruleboolArray() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1866:2: ( ( ( rule__BoolArray__Group__0 ) ) ) - // InternalRos.g:1867:2: ( ( rule__BoolArray__Group__0 ) ) + // InternalRosParser.g:1880:2: ( ( ( rule__BoolArray__Group__0 ) ) ) + // InternalRosParser.g:1881:2: ( ( rule__BoolArray__Group__0 ) ) { - // InternalRos.g:1867:2: ( ( rule__BoolArray__Group__0 ) ) - // InternalRos.g:1868:3: ( rule__BoolArray__Group__0 ) + // InternalRosParser.g:1881:2: ( ( rule__BoolArray__Group__0 ) ) + // InternalRosParser.g:1882:3: ( rule__BoolArray__Group__0 ) { before(grammarAccess.getBoolArrayAccess().getGroup()); - // InternalRos.g:1869:3: ( rule__BoolArray__Group__0 ) - // InternalRos.g:1869:4: rule__BoolArray__Group__0 + // InternalRosParser.g:1883:3: ( rule__BoolArray__Group__0 ) + // InternalRosParser.g:1883:4: rule__BoolArray__Group__0 { pushFollow(FOLLOW_2); rule__BoolArray__Group__0(); @@ -5733,11 +5598,11 @@ public final void ruleboolArray() throws RecognitionException { // $ANTLR start "entryRuleint8Array" - // InternalRos.g:1878:1: entryRuleint8Array : ruleint8Array EOF ; + // InternalRosParser.g:1892:1: entryRuleint8Array : ruleint8Array EOF ; public final void entryRuleint8Array() throws RecognitionException { try { - // InternalRos.g:1879:1: ( ruleint8Array EOF ) - // InternalRos.g:1880:1: ruleint8Array EOF + // InternalRosParser.g:1893:1: ( ruleint8Array EOF ) + // InternalRosParser.g:1894:1: ruleint8Array EOF { before(grammarAccess.getInt8ArrayRule()); pushFollow(FOLLOW_1); @@ -5763,21 +5628,21 @@ public final void entryRuleint8Array() throws RecognitionException { // $ANTLR start "ruleint8Array" - // InternalRos.g:1887:1: ruleint8Array : ( ( rule__Int8Array__Group__0 ) ) ; + // InternalRosParser.g:1901:1: ruleint8Array : ( ( rule__Int8Array__Group__0 ) ) ; public final void ruleint8Array() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1891:2: ( ( ( rule__Int8Array__Group__0 ) ) ) - // InternalRos.g:1892:2: ( ( rule__Int8Array__Group__0 ) ) + // InternalRosParser.g:1905:2: ( ( ( rule__Int8Array__Group__0 ) ) ) + // InternalRosParser.g:1906:2: ( ( rule__Int8Array__Group__0 ) ) { - // InternalRos.g:1892:2: ( ( rule__Int8Array__Group__0 ) ) - // InternalRos.g:1893:3: ( rule__Int8Array__Group__0 ) + // InternalRosParser.g:1906:2: ( ( rule__Int8Array__Group__0 ) ) + // InternalRosParser.g:1907:3: ( rule__Int8Array__Group__0 ) { before(grammarAccess.getInt8ArrayAccess().getGroup()); - // InternalRos.g:1894:3: ( rule__Int8Array__Group__0 ) - // InternalRos.g:1894:4: rule__Int8Array__Group__0 + // InternalRosParser.g:1908:3: ( rule__Int8Array__Group__0 ) + // InternalRosParser.g:1908:4: rule__Int8Array__Group__0 { pushFollow(FOLLOW_2); rule__Int8Array__Group__0(); @@ -5810,11 +5675,11 @@ public final void ruleint8Array() throws RecognitionException { // $ANTLR start "entryRuleuint8Array" - // InternalRos.g:1903:1: entryRuleuint8Array : ruleuint8Array EOF ; + // InternalRosParser.g:1917:1: entryRuleuint8Array : ruleuint8Array EOF ; public final void entryRuleuint8Array() throws RecognitionException { try { - // InternalRos.g:1904:1: ( ruleuint8Array EOF ) - // InternalRos.g:1905:1: ruleuint8Array EOF + // InternalRosParser.g:1918:1: ( ruleuint8Array EOF ) + // InternalRosParser.g:1919:1: ruleuint8Array EOF { before(grammarAccess.getUint8ArrayRule()); pushFollow(FOLLOW_1); @@ -5840,21 +5705,21 @@ public final void entryRuleuint8Array() throws RecognitionException { // $ANTLR start "ruleuint8Array" - // InternalRos.g:1912:1: ruleuint8Array : ( ( rule__Uint8Array__Group__0 ) ) ; + // InternalRosParser.g:1926:1: ruleuint8Array : ( ( rule__Uint8Array__Group__0 ) ) ; public final void ruleuint8Array() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1916:2: ( ( ( rule__Uint8Array__Group__0 ) ) ) - // InternalRos.g:1917:2: ( ( rule__Uint8Array__Group__0 ) ) + // InternalRosParser.g:1930:2: ( ( ( rule__Uint8Array__Group__0 ) ) ) + // InternalRosParser.g:1931:2: ( ( rule__Uint8Array__Group__0 ) ) { - // InternalRos.g:1917:2: ( ( rule__Uint8Array__Group__0 ) ) - // InternalRos.g:1918:3: ( rule__Uint8Array__Group__0 ) + // InternalRosParser.g:1931:2: ( ( rule__Uint8Array__Group__0 ) ) + // InternalRosParser.g:1932:3: ( rule__Uint8Array__Group__0 ) { before(grammarAccess.getUint8ArrayAccess().getGroup()); - // InternalRos.g:1919:3: ( rule__Uint8Array__Group__0 ) - // InternalRos.g:1919:4: rule__Uint8Array__Group__0 + // InternalRosParser.g:1933:3: ( rule__Uint8Array__Group__0 ) + // InternalRosParser.g:1933:4: rule__Uint8Array__Group__0 { pushFollow(FOLLOW_2); rule__Uint8Array__Group__0(); @@ -5887,11 +5752,11 @@ public final void ruleuint8Array() throws RecognitionException { // $ANTLR start "entryRuleint16Array" - // InternalRos.g:1928:1: entryRuleint16Array : ruleint16Array EOF ; + // InternalRosParser.g:1942:1: entryRuleint16Array : ruleint16Array EOF ; public final void entryRuleint16Array() throws RecognitionException { try { - // InternalRos.g:1929:1: ( ruleint16Array EOF ) - // InternalRos.g:1930:1: ruleint16Array EOF + // InternalRosParser.g:1943:1: ( ruleint16Array EOF ) + // InternalRosParser.g:1944:1: ruleint16Array EOF { before(grammarAccess.getInt16ArrayRule()); pushFollow(FOLLOW_1); @@ -5917,21 +5782,21 @@ public final void entryRuleint16Array() throws RecognitionException { // $ANTLR start "ruleint16Array" - // InternalRos.g:1937:1: ruleint16Array : ( ( rule__Int16Array__Group__0 ) ) ; + // InternalRosParser.g:1951:1: ruleint16Array : ( ( rule__Int16Array__Group__0 ) ) ; public final void ruleint16Array() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1941:2: ( ( ( rule__Int16Array__Group__0 ) ) ) - // InternalRos.g:1942:2: ( ( rule__Int16Array__Group__0 ) ) + // InternalRosParser.g:1955:2: ( ( ( rule__Int16Array__Group__0 ) ) ) + // InternalRosParser.g:1956:2: ( ( rule__Int16Array__Group__0 ) ) { - // InternalRos.g:1942:2: ( ( rule__Int16Array__Group__0 ) ) - // InternalRos.g:1943:3: ( rule__Int16Array__Group__0 ) + // InternalRosParser.g:1956:2: ( ( rule__Int16Array__Group__0 ) ) + // InternalRosParser.g:1957:3: ( rule__Int16Array__Group__0 ) { before(grammarAccess.getInt16ArrayAccess().getGroup()); - // InternalRos.g:1944:3: ( rule__Int16Array__Group__0 ) - // InternalRos.g:1944:4: rule__Int16Array__Group__0 + // InternalRosParser.g:1958:3: ( rule__Int16Array__Group__0 ) + // InternalRosParser.g:1958:4: rule__Int16Array__Group__0 { pushFollow(FOLLOW_2); rule__Int16Array__Group__0(); @@ -5964,11 +5829,11 @@ public final void ruleint16Array() throws RecognitionException { // $ANTLR start "entryRuleuint16Array" - // InternalRos.g:1953:1: entryRuleuint16Array : ruleuint16Array EOF ; + // InternalRosParser.g:1967:1: entryRuleuint16Array : ruleuint16Array EOF ; public final void entryRuleuint16Array() throws RecognitionException { try { - // InternalRos.g:1954:1: ( ruleuint16Array EOF ) - // InternalRos.g:1955:1: ruleuint16Array EOF + // InternalRosParser.g:1968:1: ( ruleuint16Array EOF ) + // InternalRosParser.g:1969:1: ruleuint16Array EOF { before(grammarAccess.getUint16ArrayRule()); pushFollow(FOLLOW_1); @@ -5994,21 +5859,21 @@ public final void entryRuleuint16Array() throws RecognitionException { // $ANTLR start "ruleuint16Array" - // InternalRos.g:1962:1: ruleuint16Array : ( ( rule__Uint16Array__Group__0 ) ) ; + // InternalRosParser.g:1976:1: ruleuint16Array : ( ( rule__Uint16Array__Group__0 ) ) ; public final void ruleuint16Array() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1966:2: ( ( ( rule__Uint16Array__Group__0 ) ) ) - // InternalRos.g:1967:2: ( ( rule__Uint16Array__Group__0 ) ) + // InternalRosParser.g:1980:2: ( ( ( rule__Uint16Array__Group__0 ) ) ) + // InternalRosParser.g:1981:2: ( ( rule__Uint16Array__Group__0 ) ) { - // InternalRos.g:1967:2: ( ( rule__Uint16Array__Group__0 ) ) - // InternalRos.g:1968:3: ( rule__Uint16Array__Group__0 ) + // InternalRosParser.g:1981:2: ( ( rule__Uint16Array__Group__0 ) ) + // InternalRosParser.g:1982:3: ( rule__Uint16Array__Group__0 ) { before(grammarAccess.getUint16ArrayAccess().getGroup()); - // InternalRos.g:1969:3: ( rule__Uint16Array__Group__0 ) - // InternalRos.g:1969:4: rule__Uint16Array__Group__0 + // InternalRosParser.g:1983:3: ( rule__Uint16Array__Group__0 ) + // InternalRosParser.g:1983:4: rule__Uint16Array__Group__0 { pushFollow(FOLLOW_2); rule__Uint16Array__Group__0(); @@ -6041,11 +5906,11 @@ public final void ruleuint16Array() throws RecognitionException { // $ANTLR start "entryRuleint32Array" - // InternalRos.g:1978:1: entryRuleint32Array : ruleint32Array EOF ; + // InternalRosParser.g:1992:1: entryRuleint32Array : ruleint32Array EOF ; public final void entryRuleint32Array() throws RecognitionException { try { - // InternalRos.g:1979:1: ( ruleint32Array EOF ) - // InternalRos.g:1980:1: ruleint32Array EOF + // InternalRosParser.g:1993:1: ( ruleint32Array EOF ) + // InternalRosParser.g:1994:1: ruleint32Array EOF { before(grammarAccess.getInt32ArrayRule()); pushFollow(FOLLOW_1); @@ -6071,21 +5936,21 @@ public final void entryRuleint32Array() throws RecognitionException { // $ANTLR start "ruleint32Array" - // InternalRos.g:1987:1: ruleint32Array : ( ( rule__Int32Array__Group__0 ) ) ; + // InternalRosParser.g:2001:1: ruleint32Array : ( ( rule__Int32Array__Group__0 ) ) ; public final void ruleint32Array() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:1991:2: ( ( ( rule__Int32Array__Group__0 ) ) ) - // InternalRos.g:1992:2: ( ( rule__Int32Array__Group__0 ) ) + // InternalRosParser.g:2005:2: ( ( ( rule__Int32Array__Group__0 ) ) ) + // InternalRosParser.g:2006:2: ( ( rule__Int32Array__Group__0 ) ) { - // InternalRos.g:1992:2: ( ( rule__Int32Array__Group__0 ) ) - // InternalRos.g:1993:3: ( rule__Int32Array__Group__0 ) + // InternalRosParser.g:2006:2: ( ( rule__Int32Array__Group__0 ) ) + // InternalRosParser.g:2007:3: ( rule__Int32Array__Group__0 ) { before(grammarAccess.getInt32ArrayAccess().getGroup()); - // InternalRos.g:1994:3: ( rule__Int32Array__Group__0 ) - // InternalRos.g:1994:4: rule__Int32Array__Group__0 + // InternalRosParser.g:2008:3: ( rule__Int32Array__Group__0 ) + // InternalRosParser.g:2008:4: rule__Int32Array__Group__0 { pushFollow(FOLLOW_2); rule__Int32Array__Group__0(); @@ -6118,11 +5983,11 @@ public final void ruleint32Array() throws RecognitionException { // $ANTLR start "entryRuleuint32Array" - // InternalRos.g:2003:1: entryRuleuint32Array : ruleuint32Array EOF ; + // InternalRosParser.g:2017:1: entryRuleuint32Array : ruleuint32Array EOF ; public final void entryRuleuint32Array() throws RecognitionException { try { - // InternalRos.g:2004:1: ( ruleuint32Array EOF ) - // InternalRos.g:2005:1: ruleuint32Array EOF + // InternalRosParser.g:2018:1: ( ruleuint32Array EOF ) + // InternalRosParser.g:2019:1: ruleuint32Array EOF { before(grammarAccess.getUint32ArrayRule()); pushFollow(FOLLOW_1); @@ -6148,21 +6013,21 @@ public final void entryRuleuint32Array() throws RecognitionException { // $ANTLR start "ruleuint32Array" - // InternalRos.g:2012:1: ruleuint32Array : ( ( rule__Uint32Array__Group__0 ) ) ; + // InternalRosParser.g:2026:1: ruleuint32Array : ( ( rule__Uint32Array__Group__0 ) ) ; public final void ruleuint32Array() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2016:2: ( ( ( rule__Uint32Array__Group__0 ) ) ) - // InternalRos.g:2017:2: ( ( rule__Uint32Array__Group__0 ) ) + // InternalRosParser.g:2030:2: ( ( ( rule__Uint32Array__Group__0 ) ) ) + // InternalRosParser.g:2031:2: ( ( rule__Uint32Array__Group__0 ) ) { - // InternalRos.g:2017:2: ( ( rule__Uint32Array__Group__0 ) ) - // InternalRos.g:2018:3: ( rule__Uint32Array__Group__0 ) + // InternalRosParser.g:2031:2: ( ( rule__Uint32Array__Group__0 ) ) + // InternalRosParser.g:2032:3: ( rule__Uint32Array__Group__0 ) { before(grammarAccess.getUint32ArrayAccess().getGroup()); - // InternalRos.g:2019:3: ( rule__Uint32Array__Group__0 ) - // InternalRos.g:2019:4: rule__Uint32Array__Group__0 + // InternalRosParser.g:2033:3: ( rule__Uint32Array__Group__0 ) + // InternalRosParser.g:2033:4: rule__Uint32Array__Group__0 { pushFollow(FOLLOW_2); rule__Uint32Array__Group__0(); @@ -6195,11 +6060,11 @@ public final void ruleuint32Array() throws RecognitionException { // $ANTLR start "entryRuleint64Array" - // InternalRos.g:2028:1: entryRuleint64Array : ruleint64Array EOF ; + // InternalRosParser.g:2042:1: entryRuleint64Array : ruleint64Array EOF ; public final void entryRuleint64Array() throws RecognitionException { try { - // InternalRos.g:2029:1: ( ruleint64Array EOF ) - // InternalRos.g:2030:1: ruleint64Array EOF + // InternalRosParser.g:2043:1: ( ruleint64Array EOF ) + // InternalRosParser.g:2044:1: ruleint64Array EOF { before(grammarAccess.getInt64ArrayRule()); pushFollow(FOLLOW_1); @@ -6225,21 +6090,21 @@ public final void entryRuleint64Array() throws RecognitionException { // $ANTLR start "ruleint64Array" - // InternalRos.g:2037:1: ruleint64Array : ( ( rule__Int64Array__Group__0 ) ) ; + // InternalRosParser.g:2051:1: ruleint64Array : ( ( rule__Int64Array__Group__0 ) ) ; public final void ruleint64Array() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2041:2: ( ( ( rule__Int64Array__Group__0 ) ) ) - // InternalRos.g:2042:2: ( ( rule__Int64Array__Group__0 ) ) + // InternalRosParser.g:2055:2: ( ( ( rule__Int64Array__Group__0 ) ) ) + // InternalRosParser.g:2056:2: ( ( rule__Int64Array__Group__0 ) ) { - // InternalRos.g:2042:2: ( ( rule__Int64Array__Group__0 ) ) - // InternalRos.g:2043:3: ( rule__Int64Array__Group__0 ) + // InternalRosParser.g:2056:2: ( ( rule__Int64Array__Group__0 ) ) + // InternalRosParser.g:2057:3: ( rule__Int64Array__Group__0 ) { before(grammarAccess.getInt64ArrayAccess().getGroup()); - // InternalRos.g:2044:3: ( rule__Int64Array__Group__0 ) - // InternalRos.g:2044:4: rule__Int64Array__Group__0 + // InternalRosParser.g:2058:3: ( rule__Int64Array__Group__0 ) + // InternalRosParser.g:2058:4: rule__Int64Array__Group__0 { pushFollow(FOLLOW_2); rule__Int64Array__Group__0(); @@ -6272,11 +6137,11 @@ public final void ruleint64Array() throws RecognitionException { // $ANTLR start "entryRuleuint64Array" - // InternalRos.g:2053:1: entryRuleuint64Array : ruleuint64Array EOF ; + // InternalRosParser.g:2067:1: entryRuleuint64Array : ruleuint64Array EOF ; public final void entryRuleuint64Array() throws RecognitionException { try { - // InternalRos.g:2054:1: ( ruleuint64Array EOF ) - // InternalRos.g:2055:1: ruleuint64Array EOF + // InternalRosParser.g:2068:1: ( ruleuint64Array EOF ) + // InternalRosParser.g:2069:1: ruleuint64Array EOF { before(grammarAccess.getUint64ArrayRule()); pushFollow(FOLLOW_1); @@ -6302,21 +6167,21 @@ public final void entryRuleuint64Array() throws RecognitionException { // $ANTLR start "ruleuint64Array" - // InternalRos.g:2062:1: ruleuint64Array : ( ( rule__Uint64Array__Group__0 ) ) ; + // InternalRosParser.g:2076:1: ruleuint64Array : ( ( rule__Uint64Array__Group__0 ) ) ; public final void ruleuint64Array() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2066:2: ( ( ( rule__Uint64Array__Group__0 ) ) ) - // InternalRos.g:2067:2: ( ( rule__Uint64Array__Group__0 ) ) + // InternalRosParser.g:2080:2: ( ( ( rule__Uint64Array__Group__0 ) ) ) + // InternalRosParser.g:2081:2: ( ( rule__Uint64Array__Group__0 ) ) { - // InternalRos.g:2067:2: ( ( rule__Uint64Array__Group__0 ) ) - // InternalRos.g:2068:3: ( rule__Uint64Array__Group__0 ) + // InternalRosParser.g:2081:2: ( ( rule__Uint64Array__Group__0 ) ) + // InternalRosParser.g:2082:3: ( rule__Uint64Array__Group__0 ) { before(grammarAccess.getUint64ArrayAccess().getGroup()); - // InternalRos.g:2069:3: ( rule__Uint64Array__Group__0 ) - // InternalRos.g:2069:4: rule__Uint64Array__Group__0 + // InternalRosParser.g:2083:3: ( rule__Uint64Array__Group__0 ) + // InternalRosParser.g:2083:4: rule__Uint64Array__Group__0 { pushFollow(FOLLOW_2); rule__Uint64Array__Group__0(); @@ -6349,11 +6214,11 @@ public final void ruleuint64Array() throws RecognitionException { // $ANTLR start "entryRulefloat32Array" - // InternalRos.g:2078:1: entryRulefloat32Array : rulefloat32Array EOF ; + // InternalRosParser.g:2092:1: entryRulefloat32Array : rulefloat32Array EOF ; public final void entryRulefloat32Array() throws RecognitionException { try { - // InternalRos.g:2079:1: ( rulefloat32Array EOF ) - // InternalRos.g:2080:1: rulefloat32Array EOF + // InternalRosParser.g:2093:1: ( rulefloat32Array EOF ) + // InternalRosParser.g:2094:1: rulefloat32Array EOF { before(grammarAccess.getFloat32ArrayRule()); pushFollow(FOLLOW_1); @@ -6379,21 +6244,21 @@ public final void entryRulefloat32Array() throws RecognitionException { // $ANTLR start "rulefloat32Array" - // InternalRos.g:2087:1: rulefloat32Array : ( ( rule__Float32Array__Group__0 ) ) ; + // InternalRosParser.g:2101:1: rulefloat32Array : ( ( rule__Float32Array__Group__0 ) ) ; public final void rulefloat32Array() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2091:2: ( ( ( rule__Float32Array__Group__0 ) ) ) - // InternalRos.g:2092:2: ( ( rule__Float32Array__Group__0 ) ) + // InternalRosParser.g:2105:2: ( ( ( rule__Float32Array__Group__0 ) ) ) + // InternalRosParser.g:2106:2: ( ( rule__Float32Array__Group__0 ) ) { - // InternalRos.g:2092:2: ( ( rule__Float32Array__Group__0 ) ) - // InternalRos.g:2093:3: ( rule__Float32Array__Group__0 ) + // InternalRosParser.g:2106:2: ( ( rule__Float32Array__Group__0 ) ) + // InternalRosParser.g:2107:3: ( rule__Float32Array__Group__0 ) { before(grammarAccess.getFloat32ArrayAccess().getGroup()); - // InternalRos.g:2094:3: ( rule__Float32Array__Group__0 ) - // InternalRos.g:2094:4: rule__Float32Array__Group__0 + // InternalRosParser.g:2108:3: ( rule__Float32Array__Group__0 ) + // InternalRosParser.g:2108:4: rule__Float32Array__Group__0 { pushFollow(FOLLOW_2); rule__Float32Array__Group__0(); @@ -6426,11 +6291,11 @@ public final void rulefloat32Array() throws RecognitionException { // $ANTLR start "entryRulefloat64Array" - // InternalRos.g:2103:1: entryRulefloat64Array : rulefloat64Array EOF ; + // InternalRosParser.g:2117:1: entryRulefloat64Array : rulefloat64Array EOF ; public final void entryRulefloat64Array() throws RecognitionException { try { - // InternalRos.g:2104:1: ( rulefloat64Array EOF ) - // InternalRos.g:2105:1: rulefloat64Array EOF + // InternalRosParser.g:2118:1: ( rulefloat64Array EOF ) + // InternalRosParser.g:2119:1: rulefloat64Array EOF { before(grammarAccess.getFloat64ArrayRule()); pushFollow(FOLLOW_1); @@ -6456,21 +6321,21 @@ public final void entryRulefloat64Array() throws RecognitionException { // $ANTLR start "rulefloat64Array" - // InternalRos.g:2112:1: rulefloat64Array : ( ( rule__Float64Array__Group__0 ) ) ; + // InternalRosParser.g:2126:1: rulefloat64Array : ( ( rule__Float64Array__Group__0 ) ) ; public final void rulefloat64Array() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2116:2: ( ( ( rule__Float64Array__Group__0 ) ) ) - // InternalRos.g:2117:2: ( ( rule__Float64Array__Group__0 ) ) + // InternalRosParser.g:2130:2: ( ( ( rule__Float64Array__Group__0 ) ) ) + // InternalRosParser.g:2131:2: ( ( rule__Float64Array__Group__0 ) ) { - // InternalRos.g:2117:2: ( ( rule__Float64Array__Group__0 ) ) - // InternalRos.g:2118:3: ( rule__Float64Array__Group__0 ) + // InternalRosParser.g:2131:2: ( ( rule__Float64Array__Group__0 ) ) + // InternalRosParser.g:2132:3: ( rule__Float64Array__Group__0 ) { before(grammarAccess.getFloat64ArrayAccess().getGroup()); - // InternalRos.g:2119:3: ( rule__Float64Array__Group__0 ) - // InternalRos.g:2119:4: rule__Float64Array__Group__0 + // InternalRosParser.g:2133:3: ( rule__Float64Array__Group__0 ) + // InternalRosParser.g:2133:4: rule__Float64Array__Group__0 { pushFollow(FOLLOW_2); rule__Float64Array__Group__0(); @@ -6503,11 +6368,11 @@ public final void rulefloat64Array() throws RecognitionException { // $ANTLR start "entryRulestring0Array" - // InternalRos.g:2128:1: entryRulestring0Array : rulestring0Array EOF ; + // InternalRosParser.g:2142:1: entryRulestring0Array : rulestring0Array EOF ; public final void entryRulestring0Array() throws RecognitionException { try { - // InternalRos.g:2129:1: ( rulestring0Array EOF ) - // InternalRos.g:2130:1: rulestring0Array EOF + // InternalRosParser.g:2143:1: ( rulestring0Array EOF ) + // InternalRosParser.g:2144:1: rulestring0Array EOF { before(grammarAccess.getString0ArrayRule()); pushFollow(FOLLOW_1); @@ -6533,21 +6398,21 @@ public final void entryRulestring0Array() throws RecognitionException { // $ANTLR start "rulestring0Array" - // InternalRos.g:2137:1: rulestring0Array : ( ( rule__String0Array__Group__0 ) ) ; + // InternalRosParser.g:2151:1: rulestring0Array : ( ( rule__String0Array__Group__0 ) ) ; public final void rulestring0Array() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2141:2: ( ( ( rule__String0Array__Group__0 ) ) ) - // InternalRos.g:2142:2: ( ( rule__String0Array__Group__0 ) ) + // InternalRosParser.g:2155:2: ( ( ( rule__String0Array__Group__0 ) ) ) + // InternalRosParser.g:2156:2: ( ( rule__String0Array__Group__0 ) ) { - // InternalRos.g:2142:2: ( ( rule__String0Array__Group__0 ) ) - // InternalRos.g:2143:3: ( rule__String0Array__Group__0 ) + // InternalRosParser.g:2156:2: ( ( rule__String0Array__Group__0 ) ) + // InternalRosParser.g:2157:3: ( rule__String0Array__Group__0 ) { before(grammarAccess.getString0ArrayAccess().getGroup()); - // InternalRos.g:2144:3: ( rule__String0Array__Group__0 ) - // InternalRos.g:2144:4: rule__String0Array__Group__0 + // InternalRosParser.g:2158:3: ( rule__String0Array__Group__0 ) + // InternalRosParser.g:2158:4: rule__String0Array__Group__0 { pushFollow(FOLLOW_2); rule__String0Array__Group__0(); @@ -6580,11 +6445,11 @@ public final void rulestring0Array() throws RecognitionException { // $ANTLR start "entryRulebyteArray" - // InternalRos.g:2153:1: entryRulebyteArray : rulebyteArray EOF ; + // InternalRosParser.g:2167:1: entryRulebyteArray : rulebyteArray EOF ; public final void entryRulebyteArray() throws RecognitionException { try { - // InternalRos.g:2154:1: ( rulebyteArray EOF ) - // InternalRos.g:2155:1: rulebyteArray EOF + // InternalRosParser.g:2168:1: ( rulebyteArray EOF ) + // InternalRosParser.g:2169:1: rulebyteArray EOF { before(grammarAccess.getByteArrayRule()); pushFollow(FOLLOW_1); @@ -6610,21 +6475,21 @@ public final void entryRulebyteArray() throws RecognitionException { // $ANTLR start "rulebyteArray" - // InternalRos.g:2162:1: rulebyteArray : ( ( rule__ByteArray__Group__0 ) ) ; + // InternalRosParser.g:2176:1: rulebyteArray : ( ( rule__ByteArray__Group__0 ) ) ; public final void rulebyteArray() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2166:2: ( ( ( rule__ByteArray__Group__0 ) ) ) - // InternalRos.g:2167:2: ( ( rule__ByteArray__Group__0 ) ) + // InternalRosParser.g:2180:2: ( ( ( rule__ByteArray__Group__0 ) ) ) + // InternalRosParser.g:2181:2: ( ( rule__ByteArray__Group__0 ) ) { - // InternalRos.g:2167:2: ( ( rule__ByteArray__Group__0 ) ) - // InternalRos.g:2168:3: ( rule__ByteArray__Group__0 ) + // InternalRosParser.g:2181:2: ( ( rule__ByteArray__Group__0 ) ) + // InternalRosParser.g:2182:3: ( rule__ByteArray__Group__0 ) { before(grammarAccess.getByteArrayAccess().getGroup()); - // InternalRos.g:2169:3: ( rule__ByteArray__Group__0 ) - // InternalRos.g:2169:4: rule__ByteArray__Group__0 + // InternalRosParser.g:2183:3: ( rule__ByteArray__Group__0 ) + // InternalRosParser.g:2183:4: rule__ByteArray__Group__0 { pushFollow(FOLLOW_2); rule__ByteArray__Group__0(); @@ -6657,11 +6522,11 @@ public final void rulebyteArray() throws RecognitionException { // $ANTLR start "entryRuleHeader" - // InternalRos.g:2178:1: entryRuleHeader : ruleHeader EOF ; + // InternalRosParser.g:2192:1: entryRuleHeader : ruleHeader EOF ; public final void entryRuleHeader() throws RecognitionException { try { - // InternalRos.g:2179:1: ( ruleHeader EOF ) - // InternalRos.g:2180:1: ruleHeader EOF + // InternalRosParser.g:2193:1: ( ruleHeader EOF ) + // InternalRosParser.g:2194:1: ruleHeader EOF { before(grammarAccess.getHeaderRule()); pushFollow(FOLLOW_1); @@ -6687,21 +6552,21 @@ public final void entryRuleHeader() throws RecognitionException { // $ANTLR start "ruleHeader" - // InternalRos.g:2187:1: ruleHeader : ( ( rule__Header__Group__0 ) ) ; + // InternalRosParser.g:2201:1: ruleHeader : ( ( rule__Header__Group__0 ) ) ; public final void ruleHeader() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2191:2: ( ( ( rule__Header__Group__0 ) ) ) - // InternalRos.g:2192:2: ( ( rule__Header__Group__0 ) ) + // InternalRosParser.g:2205:2: ( ( ( rule__Header__Group__0 ) ) ) + // InternalRosParser.g:2206:2: ( ( rule__Header__Group__0 ) ) { - // InternalRos.g:2192:2: ( ( rule__Header__Group__0 ) ) - // InternalRos.g:2193:3: ( rule__Header__Group__0 ) + // InternalRosParser.g:2206:2: ( ( rule__Header__Group__0 ) ) + // InternalRosParser.g:2207:3: ( rule__Header__Group__0 ) { before(grammarAccess.getHeaderAccess().getGroup()); - // InternalRos.g:2194:3: ( rule__Header__Group__0 ) - // InternalRos.g:2194:4: rule__Header__Group__0 + // InternalRosParser.g:2208:3: ( rule__Header__Group__0 ) + // InternalRosParser.g:2208:4: rule__Header__Group__0 { pushFollow(FOLLOW_2); rule__Header__Group__0(); @@ -6734,11 +6599,11 @@ public final void ruleHeader() throws RecognitionException { // $ANTLR start "entryRuleTopicSpecRef" - // InternalRos.g:2203:1: entryRuleTopicSpecRef : ruleTopicSpecRef EOF ; + // InternalRosParser.g:2217:1: entryRuleTopicSpecRef : ruleTopicSpecRef EOF ; public final void entryRuleTopicSpecRef() throws RecognitionException { try { - // InternalRos.g:2204:1: ( ruleTopicSpecRef EOF ) - // InternalRos.g:2205:1: ruleTopicSpecRef EOF + // InternalRosParser.g:2218:1: ( ruleTopicSpecRef EOF ) + // InternalRosParser.g:2219:1: ruleTopicSpecRef EOF { before(grammarAccess.getTopicSpecRefRule()); pushFollow(FOLLOW_1); @@ -6764,21 +6629,21 @@ public final void entryRuleTopicSpecRef() throws RecognitionException { // $ANTLR start "ruleTopicSpecRef" - // InternalRos.g:2212:1: ruleTopicSpecRef : ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) ; + // InternalRosParser.g:2226:1: ruleTopicSpecRef : ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) ; public final void ruleTopicSpecRef() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2216:2: ( ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) ) - // InternalRos.g:2217:2: ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) + // InternalRosParser.g:2230:2: ( ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) ) + // InternalRosParser.g:2231:2: ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) { - // InternalRos.g:2217:2: ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) - // InternalRos.g:2218:3: ( rule__TopicSpecRef__TopicSpecAssignment ) + // InternalRosParser.g:2231:2: ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) + // InternalRosParser.g:2232:3: ( rule__TopicSpecRef__TopicSpecAssignment ) { before(grammarAccess.getTopicSpecRefAccess().getTopicSpecAssignment()); - // InternalRos.g:2219:3: ( rule__TopicSpecRef__TopicSpecAssignment ) - // InternalRos.g:2219:4: rule__TopicSpecRef__TopicSpecAssignment + // InternalRosParser.g:2233:3: ( rule__TopicSpecRef__TopicSpecAssignment ) + // InternalRosParser.g:2233:4: rule__TopicSpecRef__TopicSpecAssignment { pushFollow(FOLLOW_2); rule__TopicSpecRef__TopicSpecAssignment(); @@ -6811,11 +6676,11 @@ public final void ruleTopicSpecRef() throws RecognitionException { // $ANTLR start "entryRuleArrayTopicSpecRef" - // InternalRos.g:2228:1: entryRuleArrayTopicSpecRef : ruleArrayTopicSpecRef EOF ; + // InternalRosParser.g:2242:1: entryRuleArrayTopicSpecRef : ruleArrayTopicSpecRef EOF ; public final void entryRuleArrayTopicSpecRef() throws RecognitionException { try { - // InternalRos.g:2229:1: ( ruleArrayTopicSpecRef EOF ) - // InternalRos.g:2230:1: ruleArrayTopicSpecRef EOF + // InternalRosParser.g:2243:1: ( ruleArrayTopicSpecRef EOF ) + // InternalRosParser.g:2244:1: ruleArrayTopicSpecRef EOF { before(grammarAccess.getArrayTopicSpecRefRule()); pushFollow(FOLLOW_1); @@ -6841,21 +6706,21 @@ public final void entryRuleArrayTopicSpecRef() throws RecognitionException { // $ANTLR start "ruleArrayTopicSpecRef" - // InternalRos.g:2237:1: ruleArrayTopicSpecRef : ( ( rule__ArrayTopicSpecRef__Group__0 ) ) ; + // InternalRosParser.g:2251:1: ruleArrayTopicSpecRef : ( ( rule__ArrayTopicSpecRef__Group__0 ) ) ; public final void ruleArrayTopicSpecRef() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2241:2: ( ( ( rule__ArrayTopicSpecRef__Group__0 ) ) ) - // InternalRos.g:2242:2: ( ( rule__ArrayTopicSpecRef__Group__0 ) ) + // InternalRosParser.g:2255:2: ( ( ( rule__ArrayTopicSpecRef__Group__0 ) ) ) + // InternalRosParser.g:2256:2: ( ( rule__ArrayTopicSpecRef__Group__0 ) ) { - // InternalRos.g:2242:2: ( ( rule__ArrayTopicSpecRef__Group__0 ) ) - // InternalRos.g:2243:3: ( rule__ArrayTopicSpecRef__Group__0 ) + // InternalRosParser.g:2256:2: ( ( rule__ArrayTopicSpecRef__Group__0 ) ) + // InternalRosParser.g:2257:3: ( rule__ArrayTopicSpecRef__Group__0 ) { before(grammarAccess.getArrayTopicSpecRefAccess().getGroup()); - // InternalRos.g:2244:3: ( rule__ArrayTopicSpecRef__Group__0 ) - // InternalRos.g:2244:4: rule__ArrayTopicSpecRef__Group__0 + // InternalRosParser.g:2258:3: ( rule__ArrayTopicSpecRef__Group__0 ) + // InternalRosParser.g:2258:4: rule__ArrayTopicSpecRef__Group__0 { pushFollow(FOLLOW_2); rule__ArrayTopicSpecRef__Group__0(); @@ -6888,11 +6753,11 @@ public final void ruleArrayTopicSpecRef() throws RecognitionException { // $ANTLR start "entryRuleKEYWORD" - // InternalRos.g:2253:1: entryRuleKEYWORD : ruleKEYWORD EOF ; + // InternalRosParser.g:2267:1: entryRuleKEYWORD : ruleKEYWORD EOF ; public final void entryRuleKEYWORD() throws RecognitionException { try { - // InternalRos.g:2254:1: ( ruleKEYWORD EOF ) - // InternalRos.g:2255:1: ruleKEYWORD EOF + // InternalRosParser.g:2268:1: ( ruleKEYWORD EOF ) + // InternalRosParser.g:2269:1: ruleKEYWORD EOF { before(grammarAccess.getKEYWORDRule()); pushFollow(FOLLOW_1); @@ -6918,21 +6783,21 @@ public final void entryRuleKEYWORD() throws RecognitionException { // $ANTLR start "ruleKEYWORD" - // InternalRos.g:2262:1: ruleKEYWORD : ( ( rule__KEYWORD__Alternatives ) ) ; + // InternalRosParser.g:2276:1: ruleKEYWORD : ( ( rule__KEYWORD__Alternatives ) ) ; public final void ruleKEYWORD() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2266:2: ( ( ( rule__KEYWORD__Alternatives ) ) ) - // InternalRos.g:2267:2: ( ( rule__KEYWORD__Alternatives ) ) + // InternalRosParser.g:2280:2: ( ( ( rule__KEYWORD__Alternatives ) ) ) + // InternalRosParser.g:2281:2: ( ( rule__KEYWORD__Alternatives ) ) { - // InternalRos.g:2267:2: ( ( rule__KEYWORD__Alternatives ) ) - // InternalRos.g:2268:3: ( rule__KEYWORD__Alternatives ) + // InternalRosParser.g:2281:2: ( ( rule__KEYWORD__Alternatives ) ) + // InternalRosParser.g:2282:3: ( rule__KEYWORD__Alternatives ) { before(grammarAccess.getKEYWORDAccess().getAlternatives()); - // InternalRos.g:2269:3: ( rule__KEYWORD__Alternatives ) - // InternalRos.g:2269:4: rule__KEYWORD__Alternatives + // InternalRosParser.g:2283:3: ( rule__KEYWORD__Alternatives ) + // InternalRosParser.g:2283:4: rule__KEYWORD__Alternatives { pushFollow(FOLLOW_2); rule__KEYWORD__Alternatives(); @@ -6964,52 +6829,119 @@ public final void ruleKEYWORD() throws RecognitionException { // $ANTLR end "ruleKEYWORD" - // $ANTLR start "rule__Package__Alternatives" - // InternalRos.g:2277:1: rule__Package__Alternatives : ( ( rulePackage_Impl ) | ( ruleCatkinPackage ) | ( ruleAmentPackage ) ); - public final void rule__Package__Alternatives() throws RecognitionException { + // $ANTLR start "rule__EString__Alternatives" + // InternalRosParser.g:2291:1: rule__EString__Alternatives : ( ( RULE_STRING ) | ( RULE_ID ) ); + public final void rule__EString__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2281:1: ( ( rulePackage_Impl ) | ( ruleCatkinPackage ) | ( ruleAmentPackage ) ) - int alt1=3; + // InternalRosParser.g:2295:1: ( ( RULE_STRING ) | ( RULE_ID ) ) + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0==RULE_STRING) ) { + alt1=1; + } + else if ( (LA1_0==RULE_ID) ) { + alt1=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 1, 0, input); + + throw nvae; + } + switch (alt1) { + case 1 : + // InternalRosParser.g:2296:2: ( RULE_STRING ) + { + // InternalRosParser.g:2296:2: ( RULE_STRING ) + // InternalRosParser.g:2297:3: RULE_STRING + { + before(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + match(input,RULE_STRING,FOLLOW_2); + after(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRosParser.g:2302:2: ( RULE_ID ) + { + // InternalRosParser.g:2302:2: ( RULE_ID ) + // InternalRosParser.g:2303: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__RosNames__Alternatives" + // InternalRosParser.g:2312:1: rule__RosNames__Alternatives : ( ( RULE_ROS_CONVENTION_A ) | ( RULE_ID ) | ( Node ) ); + public final void rule__RosNames__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:2316:1: ( ( RULE_ROS_CONVENTION_A ) | ( RULE_ID ) | ( Node ) ) + int alt2=3; switch ( input.LA(1) ) { - case 44: + case RULE_ROS_CONVENTION_A: { - alt1=1; + alt2=1; } break; - case 48: + case RULE_ID: { - alt1=2; + alt2=2; } break; - case 50: + case Node: { - alt1=3; + alt2=3; } break; default: NoViableAltException nvae = - new NoViableAltException("", 1, 0, input); + new NoViableAltException("", 2, 0, input); throw nvae; } - switch (alt1) { + switch (alt2) { case 1 : - // InternalRos.g:2282:2: ( rulePackage_Impl ) + // InternalRosParser.g:2317:2: ( RULE_ROS_CONVENTION_A ) { - // InternalRos.g:2282:2: ( rulePackage_Impl ) - // InternalRos.g:2283:3: rulePackage_Impl + // InternalRosParser.g:2317:2: ( RULE_ROS_CONVENTION_A ) + // InternalRosParser.g:2318:3: RULE_ROS_CONVENTION_A { - before(grammarAccess.getPackageAccess().getPackage_ImplParserRuleCall_0()); - pushFollow(FOLLOW_2); - rulePackage_Impl(); - - state._fsp--; - - after(grammarAccess.getPackageAccess().getPackage_ImplParserRuleCall_0()); + before(grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); + match(input,RULE_ROS_CONVENTION_A,FOLLOW_2); + after(grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); } @@ -7017,18 +6949,14 @@ public final void rule__Package__Alternatives() throws RecognitionException { } break; case 2 : - // InternalRos.g:2288:2: ( ruleCatkinPackage ) + // InternalRosParser.g:2323:2: ( RULE_ID ) { - // InternalRos.g:2288:2: ( ruleCatkinPackage ) - // InternalRos.g:2289:3: ruleCatkinPackage + // InternalRosParser.g:2323:2: ( RULE_ID ) + // InternalRosParser.g:2324:3: RULE_ID { - before(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall_1()); - pushFollow(FOLLOW_2); - ruleCatkinPackage(); - - state._fsp--; - - after(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall_1()); + before(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); + match(input,RULE_ID,FOLLOW_2); + after(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); } @@ -7036,18 +6964,14 @@ public final void rule__Package__Alternatives() throws RecognitionException { } break; case 3 : - // InternalRos.g:2294:2: ( ruleAmentPackage ) + // InternalRosParser.g:2329:2: ( Node ) { - // InternalRos.g:2294:2: ( ruleAmentPackage ) - // InternalRos.g:2295:3: ruleAmentPackage + // InternalRosParser.g:2329:2: ( Node ) + // InternalRosParser.g:2330:3: Node { - before(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall_2()); - pushFollow(FOLLOW_2); - ruleAmentPackage(); - - state._fsp--; - - after(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall_2()); + before(grammarAccess.getRosNamesAccess().getNodeKeyword_2()); + match(input,Node,FOLLOW_2); + after(grammarAccess.getRosNamesAccess().getNodeKeyword_2()); } @@ -7068,55 +6992,81 @@ public final void rule__Package__Alternatives() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package__Alternatives" + // $ANTLR end "rule__RosNames__Alternatives" - // $ANTLR start "rule__SpecBase__Alternatives" - // InternalRos.g:2304:1: rule__SpecBase__Alternatives : ( ( ruleServiceSpec ) | ( ruleTopicSpec ) | ( ruleActionSpec ) ); - public final void rule__SpecBase__Alternatives() throws RecognitionException { + // $ANTLR start "rule__Node__Alternatives_3" + // InternalRosParser.g:2339:1: rule__Node__Alternatives_3 : ( ( ( rule__Node__Group_3_0__0 ) ) | ( ( rule__Node__Group_3_1__0 ) ) | ( ( rule__Node__Group_3_2__0 ) ) | ( ( rule__Node__Group_3_3__0 ) ) | ( ( rule__Node__Group_3_4__0 ) ) | ( ( rule__Node__Group_3_5__0 ) ) | ( ( rule__Node__Group_3_6__0 ) ) ); + public final void rule__Node__Alternatives_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2308:1: ( ( ruleServiceSpec ) | ( ruleTopicSpec ) | ( ruleActionSpec ) ) - int alt2=3; + // InternalRosParser.g:2343:1: ( ( ( rule__Node__Group_3_0__0 ) ) | ( ( rule__Node__Group_3_1__0 ) ) | ( ( rule__Node__Group_3_2__0 ) ) | ( ( rule__Node__Group_3_3__0 ) ) | ( ( rule__Node__Group_3_4__0 ) ) | ( ( rule__Node__Group_3_5__0 ) ) | ( ( rule__Node__Group_3_6__0 ) ) ) + int alt3=7; switch ( input.LA(1) ) { - case 51: + case Publishers: { - alt2=1; + alt3=1; } break; - case 54: + case Subscribers: { - alt2=2; + alt3=2; } break; - case 55: + case Serviceserver: { - alt2=3; + alt3=3; + } + break; + case Serviceclient: + { + alt3=4; + } + break; + case Actionserver: + { + alt3=5; + } + break; + case Actionclient: + { + alt3=6; + } + break; + case Parameters: + { + alt3=7; } break; default: NoViableAltException nvae = - new NoViableAltException("", 2, 0, input); + new NoViableAltException("", 3, 0, input); throw nvae; } - switch (alt2) { + switch (alt3) { case 1 : - // InternalRos.g:2309:2: ( ruleServiceSpec ) + // InternalRosParser.g:2344:2: ( ( rule__Node__Group_3_0__0 ) ) + { + // InternalRosParser.g:2344:2: ( ( rule__Node__Group_3_0__0 ) ) + // InternalRosParser.g:2345:3: ( rule__Node__Group_3_0__0 ) { - // InternalRos.g:2309:2: ( ruleServiceSpec ) - // InternalRos.g:2310:3: ruleServiceSpec + before(grammarAccess.getNodeAccess().getGroup_3_0()); + // InternalRosParser.g:2346:3: ( rule__Node__Group_3_0__0 ) + // InternalRosParser.g:2346:4: rule__Node__Group_3_0__0 { - before(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_0()); pushFollow(FOLLOW_2); - ruleServiceSpec(); + rule__Node__Group_3_0__0(); state._fsp--; - after(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_0()); + + } + + after(grammarAccess.getNodeAccess().getGroup_3_0()); } @@ -7124,18 +7074,24 @@ public final void rule__SpecBase__Alternatives() throws RecognitionException { } break; case 2 : - // InternalRos.g:2315:2: ( ruleTopicSpec ) + // InternalRosParser.g:2350:2: ( ( rule__Node__Group_3_1__0 ) ) + { + // InternalRosParser.g:2350:2: ( ( rule__Node__Group_3_1__0 ) ) + // InternalRosParser.g:2351:3: ( rule__Node__Group_3_1__0 ) { - // InternalRos.g:2315:2: ( ruleTopicSpec ) - // InternalRos.g:2316:3: ruleTopicSpec + before(grammarAccess.getNodeAccess().getGroup_3_1()); + // InternalRosParser.g:2352:3: ( rule__Node__Group_3_1__0 ) + // InternalRosParser.g:2352:4: rule__Node__Group_3_1__0 { - before(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_1()); pushFollow(FOLLOW_2); - ruleTopicSpec(); + rule__Node__Group_3_1__0(); state._fsp--; - after(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_1()); + + } + + after(grammarAccess.getNodeAccess().getGroup_3_1()); } @@ -7143,97 +7099,124 @@ public final void rule__SpecBase__Alternatives() throws RecognitionException { } break; case 3 : - // InternalRos.g:2321:2: ( ruleActionSpec ) + // InternalRosParser.g:2356:2: ( ( rule__Node__Group_3_2__0 ) ) { - // InternalRos.g:2321:2: ( ruleActionSpec ) - // InternalRos.g:2322:3: ruleActionSpec + // InternalRosParser.g:2356:2: ( ( rule__Node__Group_3_2__0 ) ) + // InternalRosParser.g:2357:3: ( rule__Node__Group_3_2__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_2()); + // InternalRosParser.g:2358:3: ( rule__Node__Group_3_2__0 ) + // InternalRosParser.g:2358:4: rule__Node__Group_3_2__0 { - before(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); pushFollow(FOLLOW_2); - ruleActionSpec(); + rule__Node__Group_3_2__0(); state._fsp--; - after(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); + + } + + after(grammarAccess.getNodeAccess().getGroup_3_2()); } } break; + case 4 : + // InternalRosParser.g:2362:2: ( ( rule__Node__Group_3_3__0 ) ) + { + // InternalRosParser.g:2362:2: ( ( rule__Node__Group_3_3__0 ) ) + // InternalRosParser.g:2363:3: ( rule__Node__Group_3_3__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_3()); + // InternalRosParser.g:2364:3: ( rule__Node__Group_3_3__0 ) + // InternalRosParser.g:2364:4: rule__Node__Group_3_3__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_3__0(); - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__SpecBase__Alternatives" + } + after(grammarAccess.getNodeAccess().getGroup_3_3()); - // $ANTLR start "rule__Dependency__Alternatives" - // InternalRos.g:2331:1: rule__Dependency__Alternatives : ( ( rulePackageDependency ) | ( ruleExternalDependency ) ); - public final void rule__Dependency__Alternatives() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalRos.g:2335:1: ( ( rulePackageDependency ) | ( ruleExternalDependency ) ) - int alt3=2; - int LA3_0 = input.LA(1); - if ( ((LA3_0>=RULE_STRING && LA3_0<=RULE_ID)) ) { - alt3=1; - } - else if ( (LA3_0==71) ) { - alt3=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 3, 0, input); + } + break; + case 5 : + // InternalRosParser.g:2368:2: ( ( rule__Node__Group_3_4__0 ) ) + { + // InternalRosParser.g:2368:2: ( ( rule__Node__Group_3_4__0 ) ) + // InternalRosParser.g:2369:3: ( rule__Node__Group_3_4__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_4()); + // InternalRosParser.g:2370:3: ( rule__Node__Group_3_4__0 ) + // InternalRosParser.g:2370:4: rule__Node__Group_3_4__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_4__0(); - throw nvae; - } - switch (alt3) { - case 1 : - // InternalRos.g:2336:2: ( rulePackageDependency ) + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_4()); + + } + + + } + break; + case 6 : + // InternalRosParser.g:2374:2: ( ( rule__Node__Group_3_5__0 ) ) { - // InternalRos.g:2336:2: ( rulePackageDependency ) - // InternalRos.g:2337:3: rulePackageDependency + // InternalRosParser.g:2374:2: ( ( rule__Node__Group_3_5__0 ) ) + // InternalRosParser.g:2375:3: ( rule__Node__Group_3_5__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_5()); + // InternalRosParser.g:2376:3: ( rule__Node__Group_3_5__0 ) + // InternalRosParser.g:2376:4: rule__Node__Group_3_5__0 { - before(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); pushFollow(FOLLOW_2); - rulePackageDependency(); + rule__Node__Group_3_5__0(); state._fsp--; - after(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + + } + + after(grammarAccess.getNodeAccess().getGroup_3_5()); } } break; - case 2 : - // InternalRos.g:2342:2: ( ruleExternalDependency ) + case 7 : + // InternalRosParser.g:2380:2: ( ( rule__Node__Group_3_6__0 ) ) { - // InternalRos.g:2342:2: ( ruleExternalDependency ) - // InternalRos.g:2343:3: ruleExternalDependency + // InternalRosParser.g:2380:2: ( ( rule__Node__Group_3_6__0 ) ) + // InternalRosParser.g:2381:3: ( rule__Node__Group_3_6__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_6()); + // InternalRosParser.g:2382:3: ( rule__Node__Group_3_6__0 ) + // InternalRosParser.g:2382:4: rule__Node__Group_3_6__0 { - before(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); pushFollow(FOLLOW_2); - ruleExternalDependency(); + rule__Node__Group_3_6__0(); state._fsp--; - after(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); + + } + + after(grammarAccess.getNodeAccess().getGroup_3_6()); } @@ -7254,30 +7237,30 @@ else if ( (LA3_0==71) ) { } return ; } - // $ANTLR end "rule__Dependency__Alternatives" + // $ANTLR end "rule__Node__Alternatives_3" - // $ANTLR start "rule__Namespace__Alternatives" - // InternalRos.g:2352:1: rule__Namespace__Alternatives : ( ( ruleGlobalNamespace ) | ( ruleRelativeNamespace_Impl ) | ( rulePrivateNamespace ) ); - public final void rule__Namespace__Alternatives() throws RecognitionException { + // $ANTLR start "rule__SpecBase__Alternatives" + // InternalRosParser.g:2390:1: rule__SpecBase__Alternatives : ( ( ruleTopicSpec ) | ( ruleServiceSpec ) | ( ruleActionSpec ) ); + public final void rule__SpecBase__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2356:1: ( ( ruleGlobalNamespace ) | ( ruleRelativeNamespace_Impl ) | ( rulePrivateNamespace ) ) + // InternalRosParser.g:2394:1: ( ( ruleTopicSpec ) | ( ruleServiceSpec ) | ( ruleActionSpec ) ) int alt4=3; switch ( input.LA(1) ) { - case 72: + case Msg: { alt4=1; } break; - case 74: + case Srv: { alt4=2; } break; - case 75: + case Action_1: { alt4=3; } @@ -7291,18 +7274,18 @@ public final void rule__Namespace__Alternatives() throws RecognitionException { switch (alt4) { case 1 : - // InternalRos.g:2357:2: ( ruleGlobalNamespace ) + // InternalRosParser.g:2395:2: ( ruleTopicSpec ) { - // InternalRos.g:2357:2: ( ruleGlobalNamespace ) - // InternalRos.g:2358:3: ruleGlobalNamespace + // InternalRosParser.g:2395:2: ( ruleTopicSpec ) + // InternalRosParser.g:2396:3: ruleTopicSpec { - before(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + before(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); pushFollow(FOLLOW_2); - ruleGlobalNamespace(); + ruleTopicSpec(); state._fsp--; - after(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + after(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); } @@ -7310,18 +7293,18 @@ public final void rule__Namespace__Alternatives() throws RecognitionException { } break; case 2 : - // InternalRos.g:2363:2: ( ruleRelativeNamespace_Impl ) + // InternalRosParser.g:2401:2: ( ruleServiceSpec ) { - // InternalRos.g:2363:2: ( ruleRelativeNamespace_Impl ) - // InternalRos.g:2364:3: ruleRelativeNamespace_Impl + // InternalRosParser.g:2401:2: ( ruleServiceSpec ) + // InternalRosParser.g:2402:3: ruleServiceSpec { - before(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + before(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); pushFollow(FOLLOW_2); - ruleRelativeNamespace_Impl(); + ruleServiceSpec(); state._fsp--; - after(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + after(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); } @@ -7329,18 +7312,18 @@ public final void rule__Namespace__Alternatives() throws RecognitionException { } break; case 3 : - // InternalRos.g:2369:2: ( rulePrivateNamespace ) + // InternalRosParser.g:2407:2: ( ruleActionSpec ) { - // InternalRos.g:2369:2: ( rulePrivateNamespace ) - // InternalRos.g:2370:3: rulePrivateNamespace + // InternalRosParser.g:2407:2: ( ruleActionSpec ) + // InternalRosParser.g:2408:3: ruleActionSpec { - before(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + before(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); pushFollow(FOLLOW_2); - rulePrivateNamespace(); + ruleActionSpec(); state._fsp--; - after(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + after(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); } @@ -7361,42 +7344,56 @@ public final void rule__Namespace__Alternatives() throws RecognitionException { } return ; } - // $ANTLR end "rule__Namespace__Alternatives" + // $ANTLR end "rule__SpecBase__Alternatives" - // $ANTLR start "rule__EString__Alternatives" - // InternalRos.g:2379:1: rule__EString__Alternatives : ( ( RULE_STRING ) | ( RULE_ID ) ); - public final void rule__EString__Alternatives() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__NameAlternatives_2_0" + // InternalRosParser.g:2417:1: rule__TopicSpec__NameAlternatives_2_0 : ( ( ruleEString ) | ( Header ) | ( String ) ); + public final void rule__TopicSpec__NameAlternatives_2_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2383:1: ( ( RULE_STRING ) | ( RULE_ID ) ) - int alt5=2; - int LA5_0 = input.LA(1); - - if ( (LA5_0==RULE_STRING) ) { + // InternalRosParser.g:2421:1: ( ( ruleEString ) | ( Header ) | ( String ) ) + int alt5=3; + switch ( input.LA(1) ) { + case RULE_ID: + case RULE_STRING: + { alt5=1; - } - else if ( (LA5_0==RULE_ID) ) { + } + break; + case Header: + { alt5=2; - } - else { + } + break; + case String: + { + alt5=3; + } + break; + default: NoViableAltException nvae = new NoViableAltException("", 5, 0, input); throw nvae; } + switch (alt5) { case 1 : - // InternalRos.g:2384:2: ( RULE_STRING ) + // InternalRosParser.g:2422:2: ( ruleEString ) { - // InternalRos.g:2384:2: ( RULE_STRING ) - // InternalRos.g:2385:3: RULE_STRING + // InternalRosParser.g:2422:2: ( ruleEString ) + // InternalRosParser.g:2423:3: ruleEString { - before(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); - match(input,RULE_STRING,FOLLOW_2); - after(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + before(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); } @@ -7404,14 +7401,29 @@ else if ( (LA5_0==RULE_ID) ) { } break; case 2 : - // InternalRos.g:2390:2: ( RULE_ID ) + // InternalRosParser.g:2428:2: ( Header ) { - // InternalRos.g:2390:2: ( RULE_ID ) - // InternalRos.g:2391:3: RULE_ID + // InternalRosParser.g:2428:2: ( Header ) + // InternalRosParser.g:2429:3: Header { - before(grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); - match(input,RULE_ID,FOLLOW_2); - after(grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); + before(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); + match(input,Header,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); + + } + + + } + break; + case 3 : + // InternalRosParser.g:2434:2: ( String ) + { + // InternalRosParser.g:2434:2: ( String ) + // InternalRosParser.g:2435:3: String + { + before(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); + match(input,String,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); } @@ -7432,51 +7444,46 @@ else if ( (LA5_0==RULE_ID) ) { } return ; } - // $ANTLR end "rule__EString__Alternatives" + // $ANTLR end "rule__TopicSpec__NameAlternatives_2_0" - // $ANTLR start "rule__RosNames__Alternatives" - // InternalRos.g:2400:1: rule__RosNames__Alternatives : ( ( RULE_ROS_CONVENTION_A ) | ( RULE_ID ) | ( 'node' ) ); - public final void rule__RosNames__Alternatives() throws RecognitionException { + // $ANTLR start "rule__Dependency__Alternatives" + // InternalRosParser.g:2444:1: rule__Dependency__Alternatives : ( ( rulePackageDependency ) | ( ruleExternalDependency ) ); + public final void rule__Dependency__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2404:1: ( ( RULE_ROS_CONVENTION_A ) | ( RULE_ID ) | ( 'node' ) ) - int alt6=3; - switch ( input.LA(1) ) { - case RULE_ROS_CONVENTION_A: - { + // InternalRosParser.g:2448:1: ( ( rulePackageDependency ) | ( ruleExternalDependency ) ) + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==RULE_ID||LA6_0==RULE_STRING) ) { alt6=1; - } - break; - case RULE_ID: - { + } + else if ( (LA6_0==ExternalDependency) ) { alt6=2; - } - break; - case 26: - { - alt6=3; - } - break; - default: + } + else { NoViableAltException nvae = new NoViableAltException("", 6, 0, input); throw nvae; } - switch (alt6) { case 1 : - // InternalRos.g:2405:2: ( RULE_ROS_CONVENTION_A ) + // InternalRosParser.g:2449:2: ( rulePackageDependency ) { - // InternalRos.g:2405:2: ( RULE_ROS_CONVENTION_A ) - // InternalRos.g:2406:3: RULE_ROS_CONVENTION_A + // InternalRosParser.g:2449:2: ( rulePackageDependency ) + // InternalRosParser.g:2450:3: rulePackageDependency { - before(grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); - match(input,RULE_ROS_CONVENTION_A,FOLLOW_2); - after(grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); + before(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + pushFollow(FOLLOW_2); + rulePackageDependency(); + + state._fsp--; + + after(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); } @@ -7484,29 +7491,18 @@ public final void rule__RosNames__Alternatives() throws RecognitionException { } break; case 2 : - // InternalRos.g:2411:2: ( RULE_ID ) + // InternalRosParser.g:2455:2: ( ruleExternalDependency ) { - // InternalRos.g:2411:2: ( RULE_ID ) - // InternalRos.g:2412:3: RULE_ID + // InternalRosParser.g:2455:2: ( ruleExternalDependency ) + // InternalRosParser.g:2456:3: ruleExternalDependency { - before(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); - match(input,RULE_ID,FOLLOW_2); - after(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); - - } + before(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleExternalDependency(); + state._fsp--; - } - break; - case 3 : - // InternalRos.g:2417:2: ( 'node' ) - { - // InternalRos.g:2417:2: ( 'node' ) - // InternalRos.g:2418:3: 'node' - { - before(grammarAccess.getRosNamesAccess().getNodeKeyword_2()); - match(input,26,FOLLOW_2); - after(grammarAccess.getRosNamesAccess().getNodeKeyword_2()); + after(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); } @@ -7527,31 +7523,30 @@ public final void rule__RosNames__Alternatives() throws RecognitionException { } return ; } - // $ANTLR end "rule__RosNames__Alternatives" + // $ANTLR end "rule__Dependency__Alternatives" - // $ANTLR start "rule__TopicSpec__NameAlternatives_2_0" - // InternalRos.g:2427:1: rule__TopicSpec__NameAlternatives_2_0 : ( ( ruleEString ) | ( 'Header' ) | ( 'String' ) ); - public final void rule__TopicSpec__NameAlternatives_2_0() throws RecognitionException { + // $ANTLR start "rule__Namespace__Alternatives" + // InternalRosParser.g:2465:1: rule__Namespace__Alternatives : ( ( ruleGlobalNamespace ) | ( ruleRelativeNamespace_Impl ) | ( rulePrivateNamespace ) ); + public final void rule__Namespace__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2431:1: ( ( ruleEString ) | ( 'Header' ) | ( 'String' ) ) + // InternalRosParser.g:2469:1: ( ( ruleGlobalNamespace ) | ( ruleRelativeNamespace_Impl ) | ( rulePrivateNamespace ) ) int alt7=3; switch ( input.LA(1) ) { - case RULE_STRING: - case RULE_ID: + case GlobalNamespace: { alt7=1; } break; - case 27: + case RelativeNamespace: { alt7=2; } break; - case 28: + case PrivateNamespace: { alt7=3; } @@ -7565,18 +7560,18 @@ public final void rule__TopicSpec__NameAlternatives_2_0() throws RecognitionExce switch (alt7) { case 1 : - // InternalRos.g:2432:2: ( ruleEString ) + // InternalRosParser.g:2470:2: ( ruleGlobalNamespace ) { - // InternalRos.g:2432:2: ( ruleEString ) - // InternalRos.g:2433:3: ruleEString + // InternalRosParser.g:2470:2: ( ruleGlobalNamespace ) + // InternalRosParser.g:2471:3: ruleGlobalNamespace { - before(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + before(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); pushFollow(FOLLOW_2); - ruleEString(); + ruleGlobalNamespace(); state._fsp--; - after(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + after(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); } @@ -7584,14 +7579,18 @@ public final void rule__TopicSpec__NameAlternatives_2_0() throws RecognitionExce } break; case 2 : - // InternalRos.g:2438:2: ( 'Header' ) + // InternalRosParser.g:2476:2: ( ruleRelativeNamespace_Impl ) { - // InternalRos.g:2438:2: ( 'Header' ) - // InternalRos.g:2439:3: 'Header' + // InternalRosParser.g:2476:2: ( ruleRelativeNamespace_Impl ) + // InternalRosParser.g:2477:3: ruleRelativeNamespace_Impl { - before(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); - match(input,27,FOLLOW_2); - after(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); + before(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleRelativeNamespace_Impl(); + + state._fsp--; + + after(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); } @@ -7599,14 +7598,18 @@ public final void rule__TopicSpec__NameAlternatives_2_0() throws RecognitionExce } break; case 3 : - // InternalRos.g:2444:2: ( 'String' ) + // InternalRosParser.g:2482:2: ( rulePrivateNamespace ) { - // InternalRos.g:2444:2: ( 'String' ) - // InternalRos.g:2445:3: 'String' + // InternalRosParser.g:2482:2: ( rulePrivateNamespace ) + // InternalRosParser.g:2483:3: rulePrivateNamespace { - before(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); - match(input,28,FOLLOW_2); - after(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); + before(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + pushFollow(FOLLOW_2); + rulePrivateNamespace(); + + state._fsp--; + + after(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); } @@ -7627,55 +7630,55 @@ public final void rule__TopicSpec__NameAlternatives_2_0() throws RecognitionExce } return ; } - // $ANTLR end "rule__TopicSpec__NameAlternatives_2_0" + // $ANTLR end "rule__Namespace__Alternatives" // $ANTLR start "rule__ParameterType__Alternatives" - // InternalRos.g:2454:1: rule__ParameterType__Alternatives : ( ( ruleParameterListType ) | ( ruleParameterStructType ) | ( ruleParameterIntegerType ) | ( ruleParameterStringType ) | ( ruleParameterDoubleType ) | ( ruleParameterBooleanType ) | ( ruleParameterBase64Type ) | ( ruleParameterArrayType ) ); + // InternalRosParser.g:2492:1: rule__ParameterType__Alternatives : ( ( ruleParameterListType ) | ( ruleParameterStructType ) | ( ruleParameterIntegerType ) | ( ruleParameterStringType ) | ( ruleParameterDoubleType ) | ( ruleParameterBooleanType ) | ( ruleParameterBase64Type ) | ( ruleParameterArrayType ) ); public final void rule__ParameterType__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2458:1: ( ( ruleParameterListType ) | ( ruleParameterStructType ) | ( ruleParameterIntegerType ) | ( ruleParameterStringType ) | ( ruleParameterDoubleType ) | ( ruleParameterBooleanType ) | ( ruleParameterBase64Type ) | ( ruleParameterArrayType ) ) + // InternalRosParser.g:2496:1: ( ( ruleParameterListType ) | ( ruleParameterStructType ) | ( ruleParameterIntegerType ) | ( ruleParameterStringType ) | ( ruleParameterDoubleType ) | ( ruleParameterBooleanType ) | ( ruleParameterBase64Type ) | ( ruleParameterArrayType ) ) int alt8=8; switch ( input.LA(1) ) { - case 77: + case List: { alt8=1; } break; - case 78: + case Struct: { alt8=2; } break; - case 79: + case Integer: { alt8=3; } break; - case 28: + case String: { alt8=4; } break; - case 81: + case Double: { alt8=5; } break; - case 82: + case Boolean: { alt8=6; } break; - case 83: + case Base64: { alt8=7; } break; - case 84: + case Array: { alt8=8; } @@ -7689,10 +7692,10 @@ public final void rule__ParameterType__Alternatives() throws RecognitionExceptio switch (alt8) { case 1 : - // InternalRos.g:2459:2: ( ruleParameterListType ) + // InternalRosParser.g:2497:2: ( ruleParameterListType ) { - // InternalRos.g:2459:2: ( ruleParameterListType ) - // InternalRos.g:2460:3: ruleParameterListType + // InternalRosParser.g:2497:2: ( ruleParameterListType ) + // InternalRosParser.g:2498:3: ruleParameterListType { before(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); pushFollow(FOLLOW_2); @@ -7708,10 +7711,10 @@ public final void rule__ParameterType__Alternatives() throws RecognitionExceptio } break; case 2 : - // InternalRos.g:2465:2: ( ruleParameterStructType ) + // InternalRosParser.g:2503:2: ( ruleParameterStructType ) { - // InternalRos.g:2465:2: ( ruleParameterStructType ) - // InternalRos.g:2466:3: ruleParameterStructType + // InternalRosParser.g:2503:2: ( ruleParameterStructType ) + // InternalRosParser.g:2504:3: ruleParameterStructType { before(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); pushFollow(FOLLOW_2); @@ -7727,10 +7730,10 @@ public final void rule__ParameterType__Alternatives() throws RecognitionExceptio } break; case 3 : - // InternalRos.g:2471:2: ( ruleParameterIntegerType ) + // InternalRosParser.g:2509:2: ( ruleParameterIntegerType ) { - // InternalRos.g:2471:2: ( ruleParameterIntegerType ) - // InternalRos.g:2472:3: ruleParameterIntegerType + // InternalRosParser.g:2509:2: ( ruleParameterIntegerType ) + // InternalRosParser.g:2510:3: ruleParameterIntegerType { before(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); pushFollow(FOLLOW_2); @@ -7746,10 +7749,10 @@ public final void rule__ParameterType__Alternatives() throws RecognitionExceptio } break; case 4 : - // InternalRos.g:2477:2: ( ruleParameterStringType ) + // InternalRosParser.g:2515:2: ( ruleParameterStringType ) { - // InternalRos.g:2477:2: ( ruleParameterStringType ) - // InternalRos.g:2478:3: ruleParameterStringType + // InternalRosParser.g:2515:2: ( ruleParameterStringType ) + // InternalRosParser.g:2516:3: ruleParameterStringType { before(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); pushFollow(FOLLOW_2); @@ -7765,10 +7768,10 @@ public final void rule__ParameterType__Alternatives() throws RecognitionExceptio } break; case 5 : - // InternalRos.g:2483:2: ( ruleParameterDoubleType ) + // InternalRosParser.g:2521:2: ( ruleParameterDoubleType ) { - // InternalRos.g:2483:2: ( ruleParameterDoubleType ) - // InternalRos.g:2484:3: ruleParameterDoubleType + // InternalRosParser.g:2521:2: ( ruleParameterDoubleType ) + // InternalRosParser.g:2522:3: ruleParameterDoubleType { before(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); pushFollow(FOLLOW_2); @@ -7784,10 +7787,10 @@ public final void rule__ParameterType__Alternatives() throws RecognitionExceptio } break; case 6 : - // InternalRos.g:2489:2: ( ruleParameterBooleanType ) + // InternalRosParser.g:2527:2: ( ruleParameterBooleanType ) { - // InternalRos.g:2489:2: ( ruleParameterBooleanType ) - // InternalRos.g:2490:3: ruleParameterBooleanType + // InternalRosParser.g:2527:2: ( ruleParameterBooleanType ) + // InternalRosParser.g:2528:3: ruleParameterBooleanType { before(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); pushFollow(FOLLOW_2); @@ -7803,10 +7806,10 @@ public final void rule__ParameterType__Alternatives() throws RecognitionExceptio } break; case 7 : - // InternalRos.g:2495:2: ( ruleParameterBase64Type ) + // InternalRosParser.g:2533:2: ( ruleParameterBase64Type ) { - // InternalRos.g:2495:2: ( ruleParameterBase64Type ) - // InternalRos.g:2496:3: ruleParameterBase64Type + // InternalRosParser.g:2533:2: ( ruleParameterBase64Type ) + // InternalRosParser.g:2534:3: ruleParameterBase64Type { before(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); pushFollow(FOLLOW_2); @@ -7822,10 +7825,10 @@ public final void rule__ParameterType__Alternatives() throws RecognitionExceptio } break; case 8 : - // InternalRos.g:2501:2: ( ruleParameterArrayType ) + // InternalRosParser.g:2539:2: ( ruleParameterArrayType ) { - // InternalRos.g:2501:2: ( ruleParameterArrayType ) - // InternalRos.g:2502:3: ruleParameterArrayType + // InternalRosParser.g:2539:2: ( ruleParameterArrayType ) + // InternalRosParser.g:2540:3: ruleParameterArrayType { before(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); pushFollow(FOLLOW_2); @@ -7858,17 +7861,17 @@ public final void rule__ParameterType__Alternatives() throws RecognitionExceptio // $ANTLR start "rule__ParameterValue__Alternatives" - // InternalRos.g:2511:1: rule__ParameterValue__Alternatives : ( ( ruleParameterString ) | ( ruleParameterBase64 ) | ( ruleParameterInteger ) | ( ruleParameterDouble ) | ( ruleParameterBoolean ) | ( ruleParameterList ) | ( ruleParameterStruct ) ); + // InternalRosParser.g:2549:1: rule__ParameterValue__Alternatives : ( ( ruleParameterString ) | ( ruleParameterBase64 ) | ( ruleParameterInteger ) | ( ruleParameterDouble ) | ( ruleParameterBoolean ) | ( ruleParameterList ) | ( ruleParameterStruct ) ); public final void rule__ParameterValue__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2515:1: ( ( ruleParameterString ) | ( ruleParameterBase64 ) | ( ruleParameterInteger ) | ( ruleParameterDouble ) | ( ruleParameterBoolean ) | ( ruleParameterList ) | ( ruleParameterStruct ) ) + // InternalRosParser.g:2553:1: ( ( ruleParameterString ) | ( ruleParameterBase64 ) | ( ruleParameterInteger ) | ( ruleParameterDouble ) | ( ruleParameterBoolean ) | ( ruleParameterList ) | ( ruleParameterStruct ) ) int alt9=7; switch ( input.LA(1) ) { - case RULE_STRING: case RULE_ID: + case RULE_STRING: { alt9=1; } @@ -7893,16 +7896,16 @@ public final void rule__ParameterValue__Alternatives() throws RecognitionExcepti alt9=5; } break; - case 41: + case LeftSquareBracket: { int LA9_6 = input.LA(2); - if ( (LA9_6==86) ) { - alt9=7; - } - else if ( ((LA9_6>=RULE_BINARY && LA9_6<=RULE_DECINT)||(LA9_6>=RULE_STRING && LA9_6<=RULE_ID)||(LA9_6>=41 && LA9_6<=43)) ) { + if ( (LA9_6==Comma||(LA9_6>=LeftSquareBracket && LA9_6<=RightSquareBracket)||LA9_6==RULE_ID||LA9_6==RULE_STRING||(LA9_6>=RULE_BINARY && LA9_6<=RULE_DOUBLE)) ) { alt9=6; } + else if ( (LA9_6==ParameterStructMember) ) { + alt9=7; + } else { NoViableAltException nvae = new NoViableAltException("", 9, 6, input); @@ -7912,8 +7915,9 @@ else if ( ((LA9_6>=RULE_BINARY && LA9_6<=RULE_DECINT)||(LA9_6>=RULE_STRING && LA } break; case EOF: - case 42: - case 43: + case Comma: + case RightSquareBracket: + case RULE_END: { alt9=7; } @@ -7927,10 +7931,10 @@ else if ( ((LA9_6>=RULE_BINARY && LA9_6<=RULE_DECINT)||(LA9_6>=RULE_STRING && LA switch (alt9) { case 1 : - // InternalRos.g:2516:2: ( ruleParameterString ) + // InternalRosParser.g:2554:2: ( ruleParameterString ) { - // InternalRos.g:2516:2: ( ruleParameterString ) - // InternalRos.g:2517:3: ruleParameterString + // InternalRosParser.g:2554:2: ( ruleParameterString ) + // InternalRosParser.g:2555:3: ruleParameterString { before(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); pushFollow(FOLLOW_2); @@ -7946,10 +7950,10 @@ else if ( ((LA9_6>=RULE_BINARY && LA9_6<=RULE_DECINT)||(LA9_6>=RULE_STRING && LA } break; case 2 : - // InternalRos.g:2522:2: ( ruleParameterBase64 ) + // InternalRosParser.g:2560:2: ( ruleParameterBase64 ) { - // InternalRos.g:2522:2: ( ruleParameterBase64 ) - // InternalRos.g:2523:3: ruleParameterBase64 + // InternalRosParser.g:2560:2: ( ruleParameterBase64 ) + // InternalRosParser.g:2561:3: ruleParameterBase64 { before(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); pushFollow(FOLLOW_2); @@ -7965,10 +7969,10 @@ else if ( ((LA9_6>=RULE_BINARY && LA9_6<=RULE_DECINT)||(LA9_6>=RULE_STRING && LA } break; case 3 : - // InternalRos.g:2528:2: ( ruleParameterInteger ) + // InternalRosParser.g:2566:2: ( ruleParameterInteger ) { - // InternalRos.g:2528:2: ( ruleParameterInteger ) - // InternalRos.g:2529:3: ruleParameterInteger + // InternalRosParser.g:2566:2: ( ruleParameterInteger ) + // InternalRosParser.g:2567:3: ruleParameterInteger { before(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); pushFollow(FOLLOW_2); @@ -7984,10 +7988,10 @@ else if ( ((LA9_6>=RULE_BINARY && LA9_6<=RULE_DECINT)||(LA9_6>=RULE_STRING && LA } break; case 4 : - // InternalRos.g:2534:2: ( ruleParameterDouble ) + // InternalRosParser.g:2572:2: ( ruleParameterDouble ) { - // InternalRos.g:2534:2: ( ruleParameterDouble ) - // InternalRos.g:2535:3: ruleParameterDouble + // InternalRosParser.g:2572:2: ( ruleParameterDouble ) + // InternalRosParser.g:2573:3: ruleParameterDouble { before(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); pushFollow(FOLLOW_2); @@ -8003,10 +8007,10 @@ else if ( ((LA9_6>=RULE_BINARY && LA9_6<=RULE_DECINT)||(LA9_6>=RULE_STRING && LA } break; case 5 : - // InternalRos.g:2540:2: ( ruleParameterBoolean ) + // InternalRosParser.g:2578:2: ( ruleParameterBoolean ) { - // InternalRos.g:2540:2: ( ruleParameterBoolean ) - // InternalRos.g:2541:3: ruleParameterBoolean + // InternalRosParser.g:2578:2: ( ruleParameterBoolean ) + // InternalRosParser.g:2579:3: ruleParameterBoolean { before(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); pushFollow(FOLLOW_2); @@ -8022,10 +8026,10 @@ else if ( ((LA9_6>=RULE_BINARY && LA9_6<=RULE_DECINT)||(LA9_6>=RULE_STRING && LA } break; case 6 : - // InternalRos.g:2546:2: ( ruleParameterList ) + // InternalRosParser.g:2584:2: ( ruleParameterList ) { - // InternalRos.g:2546:2: ( ruleParameterList ) - // InternalRos.g:2547:3: ruleParameterList + // InternalRosParser.g:2584:2: ( ruleParameterList ) + // InternalRosParser.g:2585:3: ruleParameterList { before(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); pushFollow(FOLLOW_2); @@ -8041,10 +8045,10 @@ else if ( ((LA9_6>=RULE_BINARY && LA9_6<=RULE_DECINT)||(LA9_6>=RULE_STRING && LA } break; case 7 : - // InternalRos.g:2552:2: ( ruleParameterStruct ) + // InternalRosParser.g:2590:2: ( ruleParameterStruct ) { - // InternalRos.g:2552:2: ( ruleParameterStruct ) - // InternalRos.g:2553:3: ruleParameterStruct + // InternalRosParser.g:2590:2: ( ruleParameterStruct ) + // InternalRosParser.g:2591:3: ruleParameterStruct { before(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); pushFollow(FOLLOW_2); @@ -8077,26 +8081,26 @@ else if ( ((LA9_6>=RULE_BINARY && LA9_6<=RULE_DECINT)||(LA9_6>=RULE_STRING && LA // $ANTLR start "rule__MessagePart__DataAlternatives_1_0" - // InternalRos.g:2562:1: rule__MessagePart__DataAlternatives_1_0 : ( ( ruleKEYWORD ) | ( RULE_MESSAGE_ASIGMENT ) | ( ruleEString ) ); + // InternalRosParser.g:2600:1: rule__MessagePart__DataAlternatives_1_0 : ( ( ruleKEYWORD ) | ( RULE_MESSAGE_ASIGMENT ) | ( ruleEString ) ); public final void rule__MessagePart__DataAlternatives_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2566:1: ( ( ruleKEYWORD ) | ( RULE_MESSAGE_ASIGMENT ) | ( ruleEString ) ) + // InternalRosParser.g:2604:1: ( ( ruleKEYWORD ) | ( RULE_MESSAGE_ASIGMENT ) | ( ruleEString ) ) int alt10=3; switch ( input.LA(1) ) { - case 29: - case 30: - case 31: - case 32: - case 33: - case 34: - case 35: - case 36: - case 37: - case 38: - case 39: + case Duration: + case Feedback: + case Message: + case Service: + case Action: + case Result: + case Value: + case Goal: + case Name: + case Time: + case Type: { alt10=1; } @@ -8106,8 +8110,8 @@ public final void rule__MessagePart__DataAlternatives_1_0() throws RecognitionEx alt10=2; } break; - case RULE_STRING: case RULE_ID: + case RULE_STRING: { alt10=3; } @@ -8121,10 +8125,10 @@ public final void rule__MessagePart__DataAlternatives_1_0() throws RecognitionEx switch (alt10) { case 1 : - // InternalRos.g:2567:2: ( ruleKEYWORD ) + // InternalRosParser.g:2605:2: ( ruleKEYWORD ) { - // InternalRos.g:2567:2: ( ruleKEYWORD ) - // InternalRos.g:2568:3: ruleKEYWORD + // InternalRosParser.g:2605:2: ( ruleKEYWORD ) + // InternalRosParser.g:2606:3: ruleKEYWORD { before(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); pushFollow(FOLLOW_2); @@ -8140,10 +8144,10 @@ public final void rule__MessagePart__DataAlternatives_1_0() throws RecognitionEx } break; case 2 : - // InternalRos.g:2573:2: ( RULE_MESSAGE_ASIGMENT ) + // InternalRosParser.g:2611:2: ( RULE_MESSAGE_ASIGMENT ) { - // InternalRos.g:2573:2: ( RULE_MESSAGE_ASIGMENT ) - // InternalRos.g:2574:3: RULE_MESSAGE_ASIGMENT + // InternalRosParser.g:2611:2: ( RULE_MESSAGE_ASIGMENT ) + // InternalRosParser.g:2612:3: RULE_MESSAGE_ASIGMENT { before(grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); match(input,RULE_MESSAGE_ASIGMENT,FOLLOW_2); @@ -8155,10 +8159,10 @@ public final void rule__MessagePart__DataAlternatives_1_0() throws RecognitionEx } break; case 3 : - // InternalRos.g:2579:2: ( ruleEString ) + // InternalRosParser.g:2617:2: ( ruleEString ) { - // InternalRos.g:2579:2: ( ruleEString ) - // InternalRos.g:2580:3: ruleEString + // InternalRosParser.g:2617:2: ( ruleEString ) + // InternalRosParser.g:2618:3: ruleEString { before(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); pushFollow(FOLLOW_2); @@ -8191,21 +8195,21 @@ public final void rule__MessagePart__DataAlternatives_1_0() throws RecognitionEx // $ANTLR start "rule__AbstractType__Alternatives" - // InternalRos.g:2589:1: rule__AbstractType__Alternatives : ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) ); + // InternalRosParser.g:2627:1: rule__AbstractType__Alternatives : ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) ); public final void rule__AbstractType__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2593:1: ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) ) + // InternalRosParser.g:2631:1: ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) ) int alt11=31; alt11 = dfa11.predict(input); switch (alt11) { case 1 : - // InternalRos.g:2594:2: ( rulebool ) + // InternalRosParser.g:2632:2: ( rulebool ) { - // InternalRos.g:2594:2: ( rulebool ) - // InternalRos.g:2595:3: rulebool + // InternalRosParser.g:2632:2: ( rulebool ) + // InternalRosParser.g:2633:3: rulebool { before(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); pushFollow(FOLLOW_2); @@ -8221,10 +8225,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 2 : - // InternalRos.g:2600:2: ( ruleint8 ) + // InternalRosParser.g:2638:2: ( ruleint8 ) { - // InternalRos.g:2600:2: ( ruleint8 ) - // InternalRos.g:2601:3: ruleint8 + // InternalRosParser.g:2638:2: ( ruleint8 ) + // InternalRosParser.g:2639:3: ruleint8 { before(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); pushFollow(FOLLOW_2); @@ -8240,10 +8244,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 3 : - // InternalRos.g:2606:2: ( ruleuint8 ) + // InternalRosParser.g:2644:2: ( ruleuint8 ) { - // InternalRos.g:2606:2: ( ruleuint8 ) - // InternalRos.g:2607:3: ruleuint8 + // InternalRosParser.g:2644:2: ( ruleuint8 ) + // InternalRosParser.g:2645:3: ruleuint8 { before(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); pushFollow(FOLLOW_2); @@ -8259,10 +8263,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 4 : - // InternalRos.g:2612:2: ( ruleint16 ) + // InternalRosParser.g:2650:2: ( ruleint16 ) { - // InternalRos.g:2612:2: ( ruleint16 ) - // InternalRos.g:2613:3: ruleint16 + // InternalRosParser.g:2650:2: ( ruleint16 ) + // InternalRosParser.g:2651:3: ruleint16 { before(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); pushFollow(FOLLOW_2); @@ -8278,10 +8282,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 5 : - // InternalRos.g:2618:2: ( ruleuint16 ) + // InternalRosParser.g:2656:2: ( ruleuint16 ) { - // InternalRos.g:2618:2: ( ruleuint16 ) - // InternalRos.g:2619:3: ruleuint16 + // InternalRosParser.g:2656:2: ( ruleuint16 ) + // InternalRosParser.g:2657:3: ruleuint16 { before(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); pushFollow(FOLLOW_2); @@ -8297,10 +8301,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 6 : - // InternalRos.g:2624:2: ( ruleint32 ) + // InternalRosParser.g:2662:2: ( ruleint32 ) { - // InternalRos.g:2624:2: ( ruleint32 ) - // InternalRos.g:2625:3: ruleint32 + // InternalRosParser.g:2662:2: ( ruleint32 ) + // InternalRosParser.g:2663:3: ruleint32 { before(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); pushFollow(FOLLOW_2); @@ -8316,10 +8320,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 7 : - // InternalRos.g:2630:2: ( ruleuint32 ) + // InternalRosParser.g:2668:2: ( ruleuint32 ) { - // InternalRos.g:2630:2: ( ruleuint32 ) - // InternalRos.g:2631:3: ruleuint32 + // InternalRosParser.g:2668:2: ( ruleuint32 ) + // InternalRosParser.g:2669:3: ruleuint32 { before(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); pushFollow(FOLLOW_2); @@ -8335,10 +8339,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 8 : - // InternalRos.g:2636:2: ( ruleint64 ) + // InternalRosParser.g:2674:2: ( ruleint64 ) { - // InternalRos.g:2636:2: ( ruleint64 ) - // InternalRos.g:2637:3: ruleint64 + // InternalRosParser.g:2674:2: ( ruleint64 ) + // InternalRosParser.g:2675:3: ruleint64 { before(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); pushFollow(FOLLOW_2); @@ -8354,10 +8358,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 9 : - // InternalRos.g:2642:2: ( ruleuint64 ) + // InternalRosParser.g:2680:2: ( ruleuint64 ) { - // InternalRos.g:2642:2: ( ruleuint64 ) - // InternalRos.g:2643:3: ruleuint64 + // InternalRosParser.g:2680:2: ( ruleuint64 ) + // InternalRosParser.g:2681:3: ruleuint64 { before(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); pushFollow(FOLLOW_2); @@ -8373,10 +8377,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 10 : - // InternalRos.g:2648:2: ( rulefloat32 ) + // InternalRosParser.g:2686:2: ( rulefloat32 ) { - // InternalRos.g:2648:2: ( rulefloat32 ) - // InternalRos.g:2649:3: rulefloat32 + // InternalRosParser.g:2686:2: ( rulefloat32 ) + // InternalRosParser.g:2687:3: rulefloat32 { before(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); pushFollow(FOLLOW_2); @@ -8392,10 +8396,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 11 : - // InternalRos.g:2654:2: ( rulefloat64 ) + // InternalRosParser.g:2692:2: ( rulefloat64 ) { - // InternalRos.g:2654:2: ( rulefloat64 ) - // InternalRos.g:2655:3: rulefloat64 + // InternalRosParser.g:2692:2: ( rulefloat64 ) + // InternalRosParser.g:2693:3: rulefloat64 { before(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); pushFollow(FOLLOW_2); @@ -8411,10 +8415,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 12 : - // InternalRos.g:2660:2: ( rulestring0 ) + // InternalRosParser.g:2698:2: ( rulestring0 ) { - // InternalRos.g:2660:2: ( rulestring0 ) - // InternalRos.g:2661:3: rulestring0 + // InternalRosParser.g:2698:2: ( rulestring0 ) + // InternalRosParser.g:2699:3: rulestring0 { before(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); pushFollow(FOLLOW_2); @@ -8430,10 +8434,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 13 : - // InternalRos.g:2666:2: ( rulebyte ) + // InternalRosParser.g:2704:2: ( rulebyte ) { - // InternalRos.g:2666:2: ( rulebyte ) - // InternalRos.g:2667:3: rulebyte + // InternalRosParser.g:2704:2: ( rulebyte ) + // InternalRosParser.g:2705:3: rulebyte { before(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); pushFollow(FOLLOW_2); @@ -8449,10 +8453,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 14 : - // InternalRos.g:2672:2: ( ruletime ) + // InternalRosParser.g:2710:2: ( ruletime ) { - // InternalRos.g:2672:2: ( ruletime ) - // InternalRos.g:2673:3: ruletime + // InternalRosParser.g:2710:2: ( ruletime ) + // InternalRosParser.g:2711:3: ruletime { before(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); pushFollow(FOLLOW_2); @@ -8468,10 +8472,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 15 : - // InternalRos.g:2678:2: ( ruleduration ) + // InternalRosParser.g:2716:2: ( ruleduration ) { - // InternalRos.g:2678:2: ( ruleduration ) - // InternalRos.g:2679:3: ruleduration + // InternalRosParser.g:2716:2: ( ruleduration ) + // InternalRosParser.g:2717:3: ruleduration { before(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); pushFollow(FOLLOW_2); @@ -8487,10 +8491,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 16 : - // InternalRos.g:2684:2: ( ruleHeader ) + // InternalRosParser.g:2722:2: ( ruleHeader ) { - // InternalRos.g:2684:2: ( ruleHeader ) - // InternalRos.g:2685:3: ruleHeader + // InternalRosParser.g:2722:2: ( ruleHeader ) + // InternalRosParser.g:2723:3: ruleHeader { before(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); pushFollow(FOLLOW_2); @@ -8506,10 +8510,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 17 : - // InternalRos.g:2690:2: ( ruleboolArray ) + // InternalRosParser.g:2728:2: ( ruleboolArray ) { - // InternalRos.g:2690:2: ( ruleboolArray ) - // InternalRos.g:2691:3: ruleboolArray + // InternalRosParser.g:2728:2: ( ruleboolArray ) + // InternalRosParser.g:2729:3: ruleboolArray { before(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); pushFollow(FOLLOW_2); @@ -8525,10 +8529,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 18 : - // InternalRos.g:2696:2: ( ruleint8Array ) + // InternalRosParser.g:2734:2: ( ruleint8Array ) { - // InternalRos.g:2696:2: ( ruleint8Array ) - // InternalRos.g:2697:3: ruleint8Array + // InternalRosParser.g:2734:2: ( ruleint8Array ) + // InternalRosParser.g:2735:3: ruleint8Array { before(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); pushFollow(FOLLOW_2); @@ -8544,10 +8548,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 19 : - // InternalRos.g:2702:2: ( ruleuint8Array ) + // InternalRosParser.g:2740:2: ( ruleuint8Array ) { - // InternalRos.g:2702:2: ( ruleuint8Array ) - // InternalRos.g:2703:3: ruleuint8Array + // InternalRosParser.g:2740:2: ( ruleuint8Array ) + // InternalRosParser.g:2741:3: ruleuint8Array { before(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); pushFollow(FOLLOW_2); @@ -8563,10 +8567,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 20 : - // InternalRos.g:2708:2: ( ruleint16Array ) + // InternalRosParser.g:2746:2: ( ruleint16Array ) { - // InternalRos.g:2708:2: ( ruleint16Array ) - // InternalRos.g:2709:3: ruleint16Array + // InternalRosParser.g:2746:2: ( ruleint16Array ) + // InternalRosParser.g:2747:3: ruleint16Array { before(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); pushFollow(FOLLOW_2); @@ -8582,10 +8586,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 21 : - // InternalRos.g:2714:2: ( ruleuint16Array ) + // InternalRosParser.g:2752:2: ( ruleuint16Array ) { - // InternalRos.g:2714:2: ( ruleuint16Array ) - // InternalRos.g:2715:3: ruleuint16Array + // InternalRosParser.g:2752:2: ( ruleuint16Array ) + // InternalRosParser.g:2753:3: ruleuint16Array { before(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); pushFollow(FOLLOW_2); @@ -8601,10 +8605,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 22 : - // InternalRos.g:2720:2: ( ruleint32Array ) + // InternalRosParser.g:2758:2: ( ruleint32Array ) { - // InternalRos.g:2720:2: ( ruleint32Array ) - // InternalRos.g:2721:3: ruleint32Array + // InternalRosParser.g:2758:2: ( ruleint32Array ) + // InternalRosParser.g:2759:3: ruleint32Array { before(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); pushFollow(FOLLOW_2); @@ -8620,10 +8624,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 23 : - // InternalRos.g:2726:2: ( ruleuint32Array ) + // InternalRosParser.g:2764:2: ( ruleuint32Array ) { - // InternalRos.g:2726:2: ( ruleuint32Array ) - // InternalRos.g:2727:3: ruleuint32Array + // InternalRosParser.g:2764:2: ( ruleuint32Array ) + // InternalRosParser.g:2765:3: ruleuint32Array { before(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); pushFollow(FOLLOW_2); @@ -8639,10 +8643,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 24 : - // InternalRos.g:2732:2: ( ruleint64Array ) + // InternalRosParser.g:2770:2: ( ruleint64Array ) { - // InternalRos.g:2732:2: ( ruleint64Array ) - // InternalRos.g:2733:3: ruleint64Array + // InternalRosParser.g:2770:2: ( ruleint64Array ) + // InternalRosParser.g:2771:3: ruleint64Array { before(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); pushFollow(FOLLOW_2); @@ -8658,10 +8662,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 25 : - // InternalRos.g:2738:2: ( ruleuint64Array ) + // InternalRosParser.g:2776:2: ( ruleuint64Array ) { - // InternalRos.g:2738:2: ( ruleuint64Array ) - // InternalRos.g:2739:3: ruleuint64Array + // InternalRosParser.g:2776:2: ( ruleuint64Array ) + // InternalRosParser.g:2777:3: ruleuint64Array { before(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); pushFollow(FOLLOW_2); @@ -8677,10 +8681,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 26 : - // InternalRos.g:2744:2: ( rulefloat32Array ) + // InternalRosParser.g:2782:2: ( rulefloat32Array ) { - // InternalRos.g:2744:2: ( rulefloat32Array ) - // InternalRos.g:2745:3: rulefloat32Array + // InternalRosParser.g:2782:2: ( rulefloat32Array ) + // InternalRosParser.g:2783:3: rulefloat32Array { before(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); pushFollow(FOLLOW_2); @@ -8696,10 +8700,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 27 : - // InternalRos.g:2750:2: ( rulefloat64Array ) + // InternalRosParser.g:2788:2: ( rulefloat64Array ) { - // InternalRos.g:2750:2: ( rulefloat64Array ) - // InternalRos.g:2751:3: rulefloat64Array + // InternalRosParser.g:2788:2: ( rulefloat64Array ) + // InternalRosParser.g:2789:3: rulefloat64Array { before(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); pushFollow(FOLLOW_2); @@ -8715,10 +8719,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 28 : - // InternalRos.g:2756:2: ( rulestring0Array ) + // InternalRosParser.g:2794:2: ( rulestring0Array ) { - // InternalRos.g:2756:2: ( rulestring0Array ) - // InternalRos.g:2757:3: rulestring0Array + // InternalRosParser.g:2794:2: ( rulestring0Array ) + // InternalRosParser.g:2795:3: rulestring0Array { before(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); pushFollow(FOLLOW_2); @@ -8734,10 +8738,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 29 : - // InternalRos.g:2762:2: ( rulebyteArray ) + // InternalRosParser.g:2800:2: ( rulebyteArray ) { - // InternalRos.g:2762:2: ( rulebyteArray ) - // InternalRos.g:2763:3: rulebyteArray + // InternalRosParser.g:2800:2: ( rulebyteArray ) + // InternalRosParser.g:2801:3: rulebyteArray { before(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); pushFollow(FOLLOW_2); @@ -8753,10 +8757,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 30 : - // InternalRos.g:2768:2: ( ruleTopicSpecRef ) + // InternalRosParser.g:2806:2: ( ruleTopicSpecRef ) { - // InternalRos.g:2768:2: ( ruleTopicSpecRef ) - // InternalRos.g:2769:3: ruleTopicSpecRef + // InternalRosParser.g:2806:2: ( ruleTopicSpecRef ) + // InternalRosParser.g:2807:3: ruleTopicSpecRef { before(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); pushFollow(FOLLOW_2); @@ -8772,10 +8776,10 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException } break; case 31 : - // InternalRos.g:2774:2: ( ruleArrayTopicSpecRef ) + // InternalRosParser.g:2812:2: ( ruleArrayTopicSpecRef ) { - // InternalRos.g:2774:2: ( ruleArrayTopicSpecRef ) - // InternalRos.g:2775:3: ruleArrayTopicSpecRef + // InternalRosParser.g:2812:2: ( ruleArrayTopicSpecRef ) + // InternalRosParser.g:2813:3: ruleArrayTopicSpecRef { before(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); pushFollow(FOLLOW_2); @@ -8808,66 +8812,66 @@ public final void rule__AbstractType__Alternatives() throws RecognitionException // $ANTLR start "rule__KEYWORD__Alternatives" - // InternalRos.g:2784:1: rule__KEYWORD__Alternatives : ( ( 'goal' ) | ( 'message' ) | ( 'result' ) | ( 'feedback' ) | ( 'name' ) | ( 'value' ) | ( 'service' ) | ( 'type' ) | ( 'action' ) | ( 'duration' ) | ( 'time' ) ); + // InternalRosParser.g:2822:1: rule__KEYWORD__Alternatives : ( ( Goal ) | ( Message ) | ( Result ) | ( Feedback ) | ( Name ) | ( Value ) | ( Service ) | ( Type ) | ( Action ) | ( Duration ) | ( Time ) ); public final void rule__KEYWORD__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2788:1: ( ( 'goal' ) | ( 'message' ) | ( 'result' ) | ( 'feedback' ) | ( 'name' ) | ( 'value' ) | ( 'service' ) | ( 'type' ) | ( 'action' ) | ( 'duration' ) | ( 'time' ) ) + // InternalRosParser.g:2826:1: ( ( Goal ) | ( Message ) | ( Result ) | ( Feedback ) | ( Name ) | ( Value ) | ( Service ) | ( Type ) | ( Action ) | ( Duration ) | ( Time ) ) int alt12=11; switch ( input.LA(1) ) { - case 29: + case Goal: { alt12=1; } break; - case 30: + case Message: { alt12=2; } break; - case 31: + case Result: { alt12=3; } break; - case 32: + case Feedback: { alt12=4; } break; - case 33: + case Name: { alt12=5; } break; - case 34: + case Value: { alt12=6; } break; - case 35: + case Service: { alt12=7; } break; - case 36: + case Type: { alt12=8; } break; - case 37: + case Action: { alt12=9; } break; - case 38: + case Duration: { alt12=10; } break; - case 39: + case Time: { alt12=11; } @@ -8881,13 +8885,13 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { switch (alt12) { case 1 : - // InternalRos.g:2789:2: ( 'goal' ) + // InternalRosParser.g:2827:2: ( Goal ) { - // InternalRos.g:2789:2: ( 'goal' ) - // InternalRos.g:2790:3: 'goal' + // InternalRosParser.g:2827:2: ( Goal ) + // InternalRosParser.g:2828:3: Goal { before(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); - match(input,29,FOLLOW_2); + match(input,Goal,FOLLOW_2); after(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); } @@ -8896,13 +8900,13 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { } break; case 2 : - // InternalRos.g:2795:2: ( 'message' ) + // InternalRosParser.g:2833:2: ( Message ) { - // InternalRos.g:2795:2: ( 'message' ) - // InternalRos.g:2796:3: 'message' + // InternalRosParser.g:2833:2: ( Message ) + // InternalRosParser.g:2834:3: Message { before(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); - match(input,30,FOLLOW_2); + match(input,Message,FOLLOW_2); after(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); } @@ -8911,13 +8915,13 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { } break; case 3 : - // InternalRos.g:2801:2: ( 'result' ) + // InternalRosParser.g:2839:2: ( Result ) { - // InternalRos.g:2801:2: ( 'result' ) - // InternalRos.g:2802:3: 'result' + // InternalRosParser.g:2839:2: ( Result ) + // InternalRosParser.g:2840:3: Result { before(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); - match(input,31,FOLLOW_2); + match(input,Result,FOLLOW_2); after(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); } @@ -8926,13 +8930,13 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { } break; case 4 : - // InternalRos.g:2807:2: ( 'feedback' ) + // InternalRosParser.g:2845:2: ( Feedback ) { - // InternalRos.g:2807:2: ( 'feedback' ) - // InternalRos.g:2808:3: 'feedback' + // InternalRosParser.g:2845:2: ( Feedback ) + // InternalRosParser.g:2846:3: Feedback { before(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); - match(input,32,FOLLOW_2); + match(input,Feedback,FOLLOW_2); after(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); } @@ -8941,13 +8945,13 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { } break; case 5 : - // InternalRos.g:2813:2: ( 'name' ) + // InternalRosParser.g:2851:2: ( Name ) { - // InternalRos.g:2813:2: ( 'name' ) - // InternalRos.g:2814:3: 'name' + // InternalRosParser.g:2851:2: ( Name ) + // InternalRosParser.g:2852:3: Name { before(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); - match(input,33,FOLLOW_2); + match(input,Name,FOLLOW_2); after(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); } @@ -8956,13 +8960,13 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { } break; case 6 : - // InternalRos.g:2819:2: ( 'value' ) + // InternalRosParser.g:2857:2: ( Value ) { - // InternalRos.g:2819:2: ( 'value' ) - // InternalRos.g:2820:3: 'value' + // InternalRosParser.g:2857:2: ( Value ) + // InternalRosParser.g:2858:3: Value { before(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); - match(input,34,FOLLOW_2); + match(input,Value,FOLLOW_2); after(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); } @@ -8971,13 +8975,13 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { } break; case 7 : - // InternalRos.g:2825:2: ( 'service' ) + // InternalRosParser.g:2863:2: ( Service ) { - // InternalRos.g:2825:2: ( 'service' ) - // InternalRos.g:2826:3: 'service' + // InternalRosParser.g:2863:2: ( Service ) + // InternalRosParser.g:2864:3: Service { before(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); - match(input,35,FOLLOW_2); + match(input,Service,FOLLOW_2); after(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); } @@ -8986,13 +8990,13 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { } break; case 8 : - // InternalRos.g:2831:2: ( 'type' ) + // InternalRosParser.g:2869:2: ( Type ) { - // InternalRos.g:2831:2: ( 'type' ) - // InternalRos.g:2832:3: 'type' + // InternalRosParser.g:2869:2: ( Type ) + // InternalRosParser.g:2870:3: Type { before(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); - match(input,36,FOLLOW_2); + match(input,Type,FOLLOW_2); after(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); } @@ -9001,13 +9005,13 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { } break; case 9 : - // InternalRos.g:2837:2: ( 'action' ) + // InternalRosParser.g:2875:2: ( Action ) { - // InternalRos.g:2837:2: ( 'action' ) - // InternalRos.g:2838:3: 'action' + // InternalRosParser.g:2875:2: ( Action ) + // InternalRosParser.g:2876:3: Action { before(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); - match(input,37,FOLLOW_2); + match(input,Action,FOLLOW_2); after(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); } @@ -9016,13 +9020,13 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { } break; case 10 : - // InternalRos.g:2843:2: ( 'duration' ) + // InternalRosParser.g:2881:2: ( Duration ) { - // InternalRos.g:2843:2: ( 'duration' ) - // InternalRos.g:2844:3: 'duration' + // InternalRosParser.g:2881:2: ( Duration ) + // InternalRosParser.g:2882:3: Duration { before(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); - match(input,38,FOLLOW_2); + match(input,Duration,FOLLOW_2); after(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); } @@ -9031,13 +9035,13 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { } break; case 11 : - // InternalRos.g:2849:2: ( 'time' ) + // InternalRosParser.g:2887:2: ( Time ) { - // InternalRos.g:2849:2: ( 'time' ) - // InternalRos.g:2850:3: 'time' + // InternalRosParser.g:2887:2: ( Time ) + // InternalRosParser.g:2888:3: Time { before(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); - match(input,39,FOLLOW_2); + match(input,Time,FOLLOW_2); after(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); } @@ -9063,14 +9067,14 @@ public final void rule__KEYWORD__Alternatives() throws RecognitionException { // $ANTLR start "rule__PackageSet__Group__0" - // InternalRos.g:2859:1: rule__PackageSet__Group__0 : rule__PackageSet__Group__0__Impl rule__PackageSet__Group__1 ; + // InternalRosParser.g:2897:1: rule__PackageSet__Group__0 : rule__PackageSet__Group__0__Impl rule__PackageSet__Group__1 ; public final void rule__PackageSet__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2863:1: ( rule__PackageSet__Group__0__Impl rule__PackageSet__Group__1 ) - // InternalRos.g:2864:2: rule__PackageSet__Group__0__Impl rule__PackageSet__Group__1 + // InternalRosParser.g:2901:1: ( rule__PackageSet__Group__0__Impl rule__PackageSet__Group__1 ) + // InternalRosParser.g:2902:2: rule__PackageSet__Group__0__Impl rule__PackageSet__Group__1 { pushFollow(FOLLOW_3); rule__PackageSet__Group__0__Impl(); @@ -9101,21 +9105,21 @@ public final void rule__PackageSet__Group__0() throws RecognitionException { // $ANTLR start "rule__PackageSet__Group__0__Impl" - // InternalRos.g:2871:1: rule__PackageSet__Group__0__Impl : ( () ) ; + // InternalRosParser.g:2909:1: rule__PackageSet__Group__0__Impl : ( () ) ; public final void rule__PackageSet__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2875:1: ( ( () ) ) - // InternalRos.g:2876:1: ( () ) + // InternalRosParser.g:2913:1: ( ( () ) ) + // InternalRosParser.g:2914:1: ( () ) { - // InternalRos.g:2876:1: ( () ) - // InternalRos.g:2877:2: () + // InternalRosParser.g:2914:1: ( () ) + // InternalRosParser.g:2915:2: () { before(grammarAccess.getPackageSetAccess().getPackageSetAction_0()); - // InternalRos.g:2878:2: () - // InternalRos.g:2878:3: + // InternalRosParser.g:2916:2: () + // InternalRosParser.g:2916:3: { } @@ -9138,22 +9142,17 @@ public final void rule__PackageSet__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__PackageSet__Group__1" - // InternalRos.g:2886:1: rule__PackageSet__Group__1 : rule__PackageSet__Group__1__Impl rule__PackageSet__Group__2 ; + // InternalRosParser.g:2924:1: rule__PackageSet__Group__1 : rule__PackageSet__Group__1__Impl ; public final void rule__PackageSet__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2890:1: ( rule__PackageSet__Group__1__Impl rule__PackageSet__Group__2 ) - // InternalRos.g:2891:2: rule__PackageSet__Group__1__Impl rule__PackageSet__Group__2 + // InternalRosParser.g:2928:1: ( rule__PackageSet__Group__1__Impl ) + // InternalRosParser.g:2929:2: rule__PackageSet__Group__1__Impl { - pushFollow(FOLLOW_4); - rule__PackageSet__Group__1__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__PackageSet__Group__2(); + rule__PackageSet__Group__1__Impl(); state._fsp--; @@ -9176,21 +9175,49 @@ public final void rule__PackageSet__Group__1() throws RecognitionException { // $ANTLR start "rule__PackageSet__Group__1__Impl" - // InternalRos.g:2898:1: rule__PackageSet__Group__1__Impl : ( 'PackageSet' ) ; + // InternalRosParser.g:2935:1: rule__PackageSet__Group__1__Impl : ( ( rule__PackageSet__PackageAssignment_1 )* ) ; public final void rule__PackageSet__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2902:1: ( ( 'PackageSet' ) ) - // InternalRos.g:2903:1: ( 'PackageSet' ) + // InternalRosParser.g:2939:1: ( ( ( rule__PackageSet__PackageAssignment_1 )* ) ) + // InternalRosParser.g:2940:1: ( ( rule__PackageSet__PackageAssignment_1 )* ) { - // InternalRos.g:2903:1: ( 'PackageSet' ) - // InternalRos.g:2904:2: 'PackageSet' + // InternalRosParser.g:2940:1: ( ( rule__PackageSet__PackageAssignment_1 )* ) + // InternalRosParser.g:2941:2: ( rule__PackageSet__PackageAssignment_1 )* { - before(grammarAccess.getPackageSetAccess().getPackageSetKeyword_1()); - match(input,40,FOLLOW_2); - after(grammarAccess.getPackageSetAccess().getPackageSetKeyword_1()); + before(grammarAccess.getPackageSetAccess().getPackageAssignment_1()); + // InternalRosParser.g:2942:2: ( rule__PackageSet__PackageAssignment_1 )* + loop13: + do { + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==Node||(LA13_0>=RULE_ID && LA13_0<=RULE_ROS_CONVENTION_A)) ) { + alt13=1; + } + + + switch (alt13) { + case 1 : + // InternalRosParser.g:2942:3: rule__PackageSet__PackageAssignment_1 + { + pushFollow(FOLLOW_4); + rule__PackageSet__PackageAssignment_1(); + + state._fsp--; + + + } + break; + + default : + break loop13; + } + } while (true); + + after(grammarAccess.getPackageSetAccess().getPackageAssignment_1()); } @@ -9212,23 +9239,23 @@ public final void rule__PackageSet__Group__1__Impl() throws RecognitionException // $ANTLR end "rule__PackageSet__Group__1__Impl" - // $ANTLR start "rule__PackageSet__Group__2" - // InternalRos.g:2913:1: rule__PackageSet__Group__2 : rule__PackageSet__Group__2__Impl rule__PackageSet__Group__3 ; - public final void rule__PackageSet__Group__2() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__0" + // InternalRosParser.g:2951:1: rule__Package_Impl__Group__0 : rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 ; + public final void rule__Package_Impl__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2917:1: ( rule__PackageSet__Group__2__Impl rule__PackageSet__Group__3 ) - // InternalRos.g:2918:2: rule__PackageSet__Group__2__Impl rule__PackageSet__Group__3 + // InternalRosParser.g:2955:1: ( rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 ) + // InternalRosParser.g:2956:2: rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 { - pushFollow(FOLLOW_5); - rule__PackageSet__Group__2__Impl(); + pushFollow(FOLLOW_3); + rule__Package_Impl__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__PackageSet__Group__3(); + rule__Package_Impl__Group__1(); state._fsp--; @@ -9247,25 +9274,29 @@ public final void rule__PackageSet__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__PackageSet__Group__2" + // $ANTLR end "rule__Package_Impl__Group__0" - // $ANTLR start "rule__PackageSet__Group__2__Impl" - // InternalRos.g:2925:1: rule__PackageSet__Group__2__Impl : ( '{' ) ; - public final void rule__PackageSet__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__0__Impl" + // InternalRosParser.g:2963:1: rule__Package_Impl__Group__0__Impl : ( () ) ; + public final void rule__Package_Impl__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2929:1: ( ( '{' ) ) - // InternalRos.g:2930:1: ( '{' ) + // InternalRosParser.g:2967:1: ( ( () ) ) + // InternalRosParser.g:2968:1: ( () ) { - // InternalRos.g:2930:1: ( '{' ) - // InternalRos.g:2931:2: '{' + // InternalRosParser.g:2968:1: ( () ) + // InternalRosParser.g:2969:2: () { - before(grammarAccess.getPackageSetAccess().getLeftCurlyBracketKeyword_2()); - match(input,41,FOLLOW_2); - after(grammarAccess.getPackageSetAccess().getLeftCurlyBracketKeyword_2()); + before(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); + // InternalRosParser.g:2970:2: () + // InternalRosParser.g:2970:3: + { + } + + after(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); } @@ -9273,10 +9304,6 @@ public final void rule__PackageSet__Group__2__Impl() throws RecognitionException } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -9284,26 +9311,26 @@ public final void rule__PackageSet__Group__2__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__PackageSet__Group__2__Impl" + // $ANTLR end "rule__Package_Impl__Group__0__Impl" - // $ANTLR start "rule__PackageSet__Group__3" - // InternalRos.g:2940:1: rule__PackageSet__Group__3 : rule__PackageSet__Group__3__Impl rule__PackageSet__Group__4 ; - public final void rule__PackageSet__Group__3() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__1" + // InternalRosParser.g:2978:1: rule__Package_Impl__Group__1 : rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 ; + public final void rule__Package_Impl__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2944:1: ( rule__PackageSet__Group__3__Impl rule__PackageSet__Group__4 ) - // InternalRos.g:2945:2: rule__PackageSet__Group__3__Impl rule__PackageSet__Group__4 + // InternalRosParser.g:2982:1: ( rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 ) + // InternalRosParser.g:2983:2: rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 { pushFollow(FOLLOW_5); - rule__PackageSet__Group__3__Impl(); + rule__Package_Impl__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__PackageSet__Group__4(); + rule__Package_Impl__Group__2(); state._fsp--; @@ -9322,46 +9349,110 @@ public final void rule__PackageSet__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__PackageSet__Group__3" + // $ANTLR end "rule__Package_Impl__Group__1" - // $ANTLR start "rule__PackageSet__Group__3__Impl" - // InternalRos.g:2952:1: rule__PackageSet__Group__3__Impl : ( ( rule__PackageSet__Group_3__0 )? ) ; - public final void rule__PackageSet__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__1__Impl" + // InternalRosParser.g:2990:1: rule__Package_Impl__Group__1__Impl : ( ( rule__Package_Impl__NameAssignment_1 ) ) ; + public final void rule__Package_Impl__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2956:1: ( ( ( rule__PackageSet__Group_3__0 )? ) ) - // InternalRos.g:2957:1: ( ( rule__PackageSet__Group_3__0 )? ) + // InternalRosParser.g:2994:1: ( ( ( rule__Package_Impl__NameAssignment_1 ) ) ) + // InternalRosParser.g:2995:1: ( ( rule__Package_Impl__NameAssignment_1 ) ) + { + // InternalRosParser.g:2995:1: ( ( rule__Package_Impl__NameAssignment_1 ) ) + // InternalRosParser.g:2996:2: ( rule__Package_Impl__NameAssignment_1 ) { - // InternalRos.g:2957:1: ( ( rule__PackageSet__Group_3__0 )? ) - // InternalRos.g:2958:2: ( rule__PackageSet__Group_3__0 )? + before(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); + // InternalRosParser.g:2997:2: ( rule__Package_Impl__NameAssignment_1 ) + // InternalRosParser.g:2997:3: rule__Package_Impl__NameAssignment_1 { - before(grammarAccess.getPackageSetAccess().getGroup_3()); - // InternalRos.g:2959:2: ( rule__PackageSet__Group_3__0 )? - int alt13=2; - int LA13_0 = input.LA(1); + pushFollow(FOLLOW_2); + rule__Package_Impl__NameAssignment_1(); + + state._fsp--; + - if ( (LA13_0==44||LA13_0==48||LA13_0==50) ) { - alt13=1; } - switch (alt13) { - case 1 : - // InternalRos.g:2959:3: rule__PackageSet__Group_3__0 - { - pushFollow(FOLLOW_2); - rule__PackageSet__Group_3__0(); - state._fsp--; + after(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); + } - } - break; } - after(grammarAccess.getPackageSetAccess().getGroup_3()); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__1__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__2" + // InternalRosParser.g:3005:1: rule__Package_Impl__Group__2 : rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 ; + public final void rule__Package_Impl__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:3009:1: ( rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 ) + // InternalRosParser.g:3010:2: rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 + { + pushFollow(FOLLOW_6); + rule__Package_Impl__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__2" + + + // $ANTLR start "rule__Package_Impl__Group__2__Impl" + // InternalRosParser.g:3017:1: rule__Package_Impl__Group__2__Impl : ( Colon ) ; + public final void rule__Package_Impl__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:3021:1: ( ( Colon ) ) + // InternalRosParser.g:3022:1: ( Colon ) + { + // InternalRosParser.g:3022:1: ( Colon ) + // InternalRosParser.g:3023:2: Colon + { + before(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); } @@ -9380,21 +9471,26 @@ public final void rule__PackageSet__Group__3__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__PackageSet__Group__3__Impl" + // $ANTLR end "rule__Package_Impl__Group__2__Impl" - // $ANTLR start "rule__PackageSet__Group__4" - // InternalRos.g:2967:1: rule__PackageSet__Group__4 : rule__PackageSet__Group__4__Impl ; - public final void rule__PackageSet__Group__4() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__3" + // InternalRosParser.g:3032:1: rule__Package_Impl__Group__3 : rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 ; + public final void rule__Package_Impl__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2971:1: ( rule__PackageSet__Group__4__Impl ) - // InternalRos.g:2972:2: rule__PackageSet__Group__4__Impl + // InternalRosParser.g:3036:1: ( rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 ) + // InternalRosParser.g:3037:2: rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 { + pushFollow(FOLLOW_7); + rule__Package_Impl__Group__3__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__PackageSet__Group__4__Impl(); + rule__Package_Impl__Group__4(); state._fsp--; @@ -9413,25 +9509,25 @@ public final void rule__PackageSet__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__PackageSet__Group__4" + // $ANTLR end "rule__Package_Impl__Group__3" - // $ANTLR start "rule__PackageSet__Group__4__Impl" - // InternalRos.g:2978:1: rule__PackageSet__Group__4__Impl : ( '}' ) ; - public final void rule__PackageSet__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__3__Impl" + // InternalRosParser.g:3044:1: rule__Package_Impl__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Package_Impl__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2982:1: ( ( '}' ) ) - // InternalRos.g:2983:1: ( '}' ) + // InternalRosParser.g:3048:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:3049:1: ( RULE_BEGIN ) { - // InternalRos.g:2983:1: ( '}' ) - // InternalRos.g:2984:2: '}' + // InternalRosParser.g:3049:1: ( RULE_BEGIN ) + // InternalRosParser.g:3050:2: RULE_BEGIN { - before(grammarAccess.getPackageSetAccess().getRightCurlyBracketKeyword_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getPackageSetAccess().getRightCurlyBracketKeyword_4()); + before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); } @@ -9450,26 +9546,26 @@ public final void rule__PackageSet__Group__4__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__PackageSet__Group__4__Impl" + // $ANTLR end "rule__Package_Impl__Group__3__Impl" - // $ANTLR start "rule__PackageSet__Group_3__0" - // InternalRos.g:2994:1: rule__PackageSet__Group_3__0 : rule__PackageSet__Group_3__0__Impl rule__PackageSet__Group_3__1 ; - public final void rule__PackageSet__Group_3__0() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__4" + // InternalRosParser.g:3059:1: rule__Package_Impl__Group__4 : rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 ; + public final void rule__Package_Impl__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:2998:1: ( rule__PackageSet__Group_3__0__Impl rule__PackageSet__Group_3__1 ) - // InternalRos.g:2999:2: rule__PackageSet__Group_3__0__Impl rule__PackageSet__Group_3__1 + // InternalRosParser.g:3063:1: ( rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 ) + // InternalRosParser.g:3064:2: rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 { - pushFollow(FOLLOW_6); - rule__PackageSet__Group_3__0__Impl(); + pushFollow(FOLLOW_7); + rule__Package_Impl__Group__4__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__PackageSet__Group_3__1(); + rule__Package_Impl__Group__5(); state._fsp--; @@ -9488,35 +9584,46 @@ public final void rule__PackageSet__Group_3__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__PackageSet__Group_3__0" + // $ANTLR end "rule__Package_Impl__Group__4" - // $ANTLR start "rule__PackageSet__Group_3__0__Impl" - // InternalRos.g:3006:1: rule__PackageSet__Group_3__0__Impl : ( ( rule__PackageSet__PackageAssignment_3_0 ) ) ; - public final void rule__PackageSet__Group_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__4__Impl" + // InternalRosParser.g:3071:1: rule__Package_Impl__Group__4__Impl : ( ( rule__Package_Impl__Group_4__0 )? ) ; + public final void rule__Package_Impl__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3010:1: ( ( ( rule__PackageSet__PackageAssignment_3_0 ) ) ) - // InternalRos.g:3011:1: ( ( rule__PackageSet__PackageAssignment_3_0 ) ) + // InternalRosParser.g:3075:1: ( ( ( rule__Package_Impl__Group_4__0 )? ) ) + // InternalRosParser.g:3076:1: ( ( rule__Package_Impl__Group_4__0 )? ) { - // InternalRos.g:3011:1: ( ( rule__PackageSet__PackageAssignment_3_0 ) ) - // InternalRos.g:3012:2: ( rule__PackageSet__PackageAssignment_3_0 ) + // InternalRosParser.g:3076:1: ( ( rule__Package_Impl__Group_4__0 )? ) + // InternalRosParser.g:3077:2: ( rule__Package_Impl__Group_4__0 )? { - before(grammarAccess.getPackageSetAccess().getPackageAssignment_3_0()); - // InternalRos.g:3013:2: ( rule__PackageSet__PackageAssignment_3_0 ) - // InternalRos.g:3013:3: rule__PackageSet__PackageAssignment_3_0 - { - pushFollow(FOLLOW_2); - rule__PackageSet__PackageAssignment_3_0(); + before(grammarAccess.getPackage_ImplAccess().getGroup_4()); + // InternalRosParser.g:3078:2: ( rule__Package_Impl__Group_4__0 )? + int alt14=2; + int LA14_0 = input.LA(1); - state._fsp--; + if ( (LA14_0==FromGitRepo) ) { + alt14=1; + } + switch (alt14) { + case 1 : + // InternalRosParser.g:3078:3: rule__Package_Impl__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_4__0(); + + state._fsp--; + } + break; + } - after(grammarAccess.getPackageSetAccess().getPackageAssignment_3_0()); + after(grammarAccess.getPackage_ImplAccess().getGroup_4()); } @@ -9535,21 +9642,26 @@ public final void rule__PackageSet__Group_3__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__PackageSet__Group_3__0__Impl" + // $ANTLR end "rule__Package_Impl__Group__4__Impl" - // $ANTLR start "rule__PackageSet__Group_3__1" - // InternalRos.g:3021:1: rule__PackageSet__Group_3__1 : rule__PackageSet__Group_3__1__Impl ; - public final void rule__PackageSet__Group_3__1() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__5" + // InternalRosParser.g:3086:1: rule__Package_Impl__Group__5 : rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 ; + public final void rule__Package_Impl__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3025:1: ( rule__PackageSet__Group_3__1__Impl ) - // InternalRos.g:3026:2: rule__PackageSet__Group_3__1__Impl + // InternalRosParser.g:3090:1: ( rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 ) + // InternalRosParser.g:3091:2: rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 { + pushFollow(FOLLOW_7); + rule__Package_Impl__Group__5__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__PackageSet__Group_3__1__Impl(); + rule__Package_Impl__Group__6(); state._fsp--; @@ -9568,53 +9680,46 @@ public final void rule__PackageSet__Group_3__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__PackageSet__Group_3__1" + // $ANTLR end "rule__Package_Impl__Group__5" - // $ANTLR start "rule__PackageSet__Group_3__1__Impl" - // InternalRos.g:3032:1: rule__PackageSet__Group_3__1__Impl : ( ( rule__PackageSet__Group_3_1__0 )* ) ; - public final void rule__PackageSet__Group_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__5__Impl" + // InternalRosParser.g:3098:1: rule__Package_Impl__Group__5__Impl : ( ( rule__Package_Impl__Group_5__0 )? ) ; + public final void rule__Package_Impl__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3036:1: ( ( ( rule__PackageSet__Group_3_1__0 )* ) ) - // InternalRos.g:3037:1: ( ( rule__PackageSet__Group_3_1__0 )* ) + // InternalRosParser.g:3102:1: ( ( ( rule__Package_Impl__Group_5__0 )? ) ) + // InternalRosParser.g:3103:1: ( ( rule__Package_Impl__Group_5__0 )? ) { - // InternalRos.g:3037:1: ( ( rule__PackageSet__Group_3_1__0 )* ) - // InternalRos.g:3038:2: ( rule__PackageSet__Group_3_1__0 )* + // InternalRosParser.g:3103:1: ( ( rule__Package_Impl__Group_5__0 )? ) + // InternalRosParser.g:3104:2: ( rule__Package_Impl__Group_5__0 )? { - before(grammarAccess.getPackageSetAccess().getGroup_3_1()); - // InternalRos.g:3039:2: ( rule__PackageSet__Group_3_1__0 )* - loop14: - do { - int alt14=2; - int LA14_0 = input.LA(1); - - if ( (LA14_0==43) ) { - alt14=1; - } - + before(grammarAccess.getPackage_ImplAccess().getGroup_5()); + // InternalRosParser.g:3105:2: ( rule__Package_Impl__Group_5__0 )? + int alt15=2; + int LA15_0 = input.LA(1); - switch (alt14) { - case 1 : - // InternalRos.g:3039:3: rule__PackageSet__Group_3_1__0 - { - pushFollow(FOLLOW_7); - rule__PackageSet__Group_3_1__0(); + if ( (LA15_0==Specs) ) { + alt15=1; + } + switch (alt15) { + case 1 : + // InternalRosParser.g:3105:3: rule__Package_Impl__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_5__0(); - state._fsp--; + state._fsp--; - } - break; + } + break; - default : - break loop14; - } - } while (true); + } - after(grammarAccess.getPackageSetAccess().getGroup_3_1()); + after(grammarAccess.getPackage_ImplAccess().getGroup_5()); } @@ -9633,26 +9738,26 @@ public final void rule__PackageSet__Group_3__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__PackageSet__Group_3__1__Impl" + // $ANTLR end "rule__Package_Impl__Group__5__Impl" - // $ANTLR start "rule__PackageSet__Group_3_1__0" - // InternalRos.g:3048:1: rule__PackageSet__Group_3_1__0 : rule__PackageSet__Group_3_1__0__Impl rule__PackageSet__Group_3_1__1 ; - public final void rule__PackageSet__Group_3_1__0() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__6" + // InternalRosParser.g:3113:1: rule__Package_Impl__Group__6 : rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 ; + public final void rule__Package_Impl__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3052:1: ( rule__PackageSet__Group_3_1__0__Impl rule__PackageSet__Group_3_1__1 ) - // InternalRos.g:3053:2: rule__PackageSet__Group_3_1__0__Impl rule__PackageSet__Group_3_1__1 + // InternalRosParser.g:3117:1: ( rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 ) + // InternalRosParser.g:3118:2: rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 { - pushFollow(FOLLOW_8); - rule__PackageSet__Group_3_1__0__Impl(); + pushFollow(FOLLOW_7); + rule__Package_Impl__Group__6__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__PackageSet__Group_3_1__1(); + rule__Package_Impl__Group__7(); state._fsp--; @@ -9671,25 +9776,46 @@ public final void rule__PackageSet__Group_3_1__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__PackageSet__Group_3_1__0" + // $ANTLR end "rule__Package_Impl__Group__6" - // $ANTLR start "rule__PackageSet__Group_3_1__0__Impl" - // InternalRos.g:3060:1: rule__PackageSet__Group_3_1__0__Impl : ( ',' ) ; - public final void rule__PackageSet__Group_3_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__6__Impl" + // InternalRosParser.g:3125:1: rule__Package_Impl__Group__6__Impl : ( ( rule__Package_Impl__Group_6__0 )? ) ; + public final void rule__Package_Impl__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3064:1: ( ( ',' ) ) - // InternalRos.g:3065:1: ( ',' ) + // InternalRosParser.g:3129:1: ( ( ( rule__Package_Impl__Group_6__0 )? ) ) + // InternalRosParser.g:3130:1: ( ( rule__Package_Impl__Group_6__0 )? ) { - // InternalRos.g:3065:1: ( ',' ) - // InternalRos.g:3066:2: ',' + // InternalRosParser.g:3130:1: ( ( rule__Package_Impl__Group_6__0 )? ) + // InternalRosParser.g:3131:2: ( rule__Package_Impl__Group_6__0 )? { - before(grammarAccess.getPackageSetAccess().getCommaKeyword_3_1_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getPackageSetAccess().getCommaKeyword_3_1_0()); + before(grammarAccess.getPackage_ImplAccess().getGroup_6()); + // InternalRosParser.g:3132:2: ( rule__Package_Impl__Group_6__0 )? + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0==Dependencies) ) { + alt16=1; + } + switch (alt16) { + case 1 : + // InternalRosParser.g:3132:3: rule__Package_Impl__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPackage_ImplAccess().getGroup_6()); } @@ -9708,21 +9834,21 @@ public final void rule__PackageSet__Group_3_1__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__PackageSet__Group_3_1__0__Impl" + // $ANTLR end "rule__Package_Impl__Group__6__Impl" - // $ANTLR start "rule__PackageSet__Group_3_1__1" - // InternalRos.g:3075:1: rule__PackageSet__Group_3_1__1 : rule__PackageSet__Group_3_1__1__Impl ; - public final void rule__PackageSet__Group_3_1__1() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__7" + // InternalRosParser.g:3140:1: rule__Package_Impl__Group__7 : rule__Package_Impl__Group__7__Impl ; + public final void rule__Package_Impl__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3079:1: ( rule__PackageSet__Group_3_1__1__Impl ) - // InternalRos.g:3080:2: rule__PackageSet__Group_3_1__1__Impl + // InternalRosParser.g:3144:1: ( rule__Package_Impl__Group__7__Impl ) + // InternalRosParser.g:3145:2: rule__Package_Impl__Group__7__Impl { pushFollow(FOLLOW_2); - rule__PackageSet__Group_3_1__1__Impl(); + rule__Package_Impl__Group__7__Impl(); state._fsp--; @@ -9741,35 +9867,25 @@ public final void rule__PackageSet__Group_3_1__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__PackageSet__Group_3_1__1" + // $ANTLR end "rule__Package_Impl__Group__7" - // $ANTLR start "rule__PackageSet__Group_3_1__1__Impl" - // InternalRos.g:3086:1: rule__PackageSet__Group_3_1__1__Impl : ( ( rule__PackageSet__PackageAssignment_3_1_1 ) ) ; - public final void rule__PackageSet__Group_3_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group__7__Impl" + // InternalRosParser.g:3151:1: rule__Package_Impl__Group__7__Impl : ( RULE_END ) ; + public final void rule__Package_Impl__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3090:1: ( ( ( rule__PackageSet__PackageAssignment_3_1_1 ) ) ) - // InternalRos.g:3091:1: ( ( rule__PackageSet__PackageAssignment_3_1_1 ) ) - { - // InternalRos.g:3091:1: ( ( rule__PackageSet__PackageAssignment_3_1_1 ) ) - // InternalRos.g:3092:2: ( rule__PackageSet__PackageAssignment_3_1_1 ) + // InternalRosParser.g:3155:1: ( ( RULE_END ) ) + // InternalRosParser.g:3156:1: ( RULE_END ) { - before(grammarAccess.getPackageSetAccess().getPackageAssignment_3_1_1()); - // InternalRos.g:3093:2: ( rule__PackageSet__PackageAssignment_3_1_1 ) - // InternalRos.g:3093:3: rule__PackageSet__PackageAssignment_3_1_1 + // InternalRosParser.g:3156:1: ( RULE_END ) + // InternalRosParser.g:3157:2: RULE_END { - pushFollow(FOLLOW_2); - rule__PackageSet__PackageAssignment_3_1_1(); - - state._fsp--; - - - } - - after(grammarAccess.getPackageSetAccess().getPackageAssignment_3_1_1()); + before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); } @@ -9788,26 +9904,26 @@ public final void rule__PackageSet__Group_3_1__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__PackageSet__Group_3_1__1__Impl" + // $ANTLR end "rule__Package_Impl__Group__7__Impl" - // $ANTLR start "rule__Package_Impl__Group__0" - // InternalRos.g:3102:1: rule__Package_Impl__Group__0 : rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 ; - public final void rule__Package_Impl__Group__0() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_4__0" + // InternalRosParser.g:3167:1: rule__Package_Impl__Group_4__0 : rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 ; + public final void rule__Package_Impl__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3106:1: ( rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 ) - // InternalRos.g:3107:2: rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 + // InternalRosParser.g:3171:1: ( rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 ) + // InternalRosParser.g:3172:2: rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 { - pushFollow(FOLLOW_9); - rule__Package_Impl__Group__0__Impl(); + pushFollow(FOLLOW_8); + rule__Package_Impl__Group_4__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Package_Impl__Group__1(); + rule__Package_Impl__Group_4__1(); state._fsp--; @@ -9826,29 +9942,25 @@ public final void rule__Package_Impl__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group__0" + // $ANTLR end "rule__Package_Impl__Group_4__0" - // $ANTLR start "rule__Package_Impl__Group__0__Impl" - // InternalRos.g:3114:1: rule__Package_Impl__Group__0__Impl : ( () ) ; - public final void rule__Package_Impl__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_4__0__Impl" + // InternalRosParser.g:3179:1: rule__Package_Impl__Group_4__0__Impl : ( FromGitRepo ) ; + public final void rule__Package_Impl__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3118:1: ( ( () ) ) - // InternalRos.g:3119:1: ( () ) - { - // InternalRos.g:3119:1: ( () ) - // InternalRos.g:3120:2: () + // InternalRosParser.g:3183:1: ( ( FromGitRepo ) ) + // InternalRosParser.g:3184:1: ( FromGitRepo ) { - before(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); - // InternalRos.g:3121:2: () - // InternalRos.g:3121:3: + // InternalRosParser.g:3184:1: ( FromGitRepo ) + // InternalRosParser.g:3185:2: FromGitRepo { - } - - after(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); + before(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); + match(input,FromGitRepo,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); } @@ -9856,6 +9968,10 @@ public final void rule__Package_Impl__Group__0__Impl() throws RecognitionExcepti } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -9863,26 +9979,21 @@ public final void rule__Package_Impl__Group__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Package_Impl__Group__0__Impl" + // $ANTLR end "rule__Package_Impl__Group_4__0__Impl" - // $ANTLR start "rule__Package_Impl__Group__1" - // InternalRos.g:3129:1: rule__Package_Impl__Group__1 : rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 ; - public final void rule__Package_Impl__Group__1() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_4__1" + // InternalRosParser.g:3194:1: rule__Package_Impl__Group_4__1 : rule__Package_Impl__Group_4__1__Impl ; + public final void rule__Package_Impl__Group_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3133:1: ( rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 ) - // InternalRos.g:3134:2: rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 + // InternalRosParser.g:3198:1: ( rule__Package_Impl__Group_4__1__Impl ) + // InternalRosParser.g:3199:2: rule__Package_Impl__Group_4__1__Impl { - pushFollow(FOLLOW_10); - rule__Package_Impl__Group__1__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Package_Impl__Group__2(); + rule__Package_Impl__Group_4__1__Impl(); state._fsp--; @@ -9901,25 +10012,35 @@ public final void rule__Package_Impl__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group__1" + // $ANTLR end "rule__Package_Impl__Group_4__1" - // $ANTLR start "rule__Package_Impl__Group__1__Impl" - // InternalRos.g:3141:1: rule__Package_Impl__Group__1__Impl : ( 'Package' ) ; - public final void rule__Package_Impl__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_4__1__Impl" + // InternalRosParser.g:3205:1: rule__Package_Impl__Group_4__1__Impl : ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) ; + public final void rule__Package_Impl__Group_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3145:1: ( ( 'Package' ) ) - // InternalRos.g:3146:1: ( 'Package' ) + // InternalRosParser.g:3209:1: ( ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) ) + // InternalRosParser.g:3210:1: ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) { - // InternalRos.g:3146:1: ( 'Package' ) - // InternalRos.g:3147:2: 'Package' + // InternalRosParser.g:3210:1: ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) + // InternalRosParser.g:3211:2: ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) { - before(grammarAccess.getPackage_ImplAccess().getPackageKeyword_1()); - match(input,44,FOLLOW_2); - after(grammarAccess.getPackage_ImplAccess().getPackageKeyword_1()); + before(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); + // InternalRosParser.g:3212:2: ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) + // InternalRosParser.g:3212:3: rule__Package_Impl__FromGitRepoAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__FromGitRepoAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); } @@ -9938,26 +10059,26 @@ public final void rule__Package_Impl__Group__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Package_Impl__Group__1__Impl" + // $ANTLR end "rule__Package_Impl__Group_4__1__Impl" - // $ANTLR start "rule__Package_Impl__Group__2" - // InternalRos.g:3156:1: rule__Package_Impl__Group__2 : rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 ; - public final void rule__Package_Impl__Group__2() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_5__0" + // InternalRosParser.g:3221:1: rule__Package_Impl__Group_5__0 : rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 ; + public final void rule__Package_Impl__Group_5__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3160:1: ( rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 ) - // InternalRos.g:3161:2: rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 + // InternalRosParser.g:3225:1: ( rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 ) + // InternalRosParser.g:3226:2: rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 { - pushFollow(FOLLOW_4); - rule__Package_Impl__Group__2__Impl(); + pushFollow(FOLLOW_6); + rule__Package_Impl__Group_5__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Package_Impl__Group__3(); + rule__Package_Impl__Group_5__1(); state._fsp--; @@ -9976,35 +10097,25 @@ public final void rule__Package_Impl__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group__2" + // $ANTLR end "rule__Package_Impl__Group_5__0" - // $ANTLR start "rule__Package_Impl__Group__2__Impl" - // InternalRos.g:3168:1: rule__Package_Impl__Group__2__Impl : ( ( rule__Package_Impl__NameAssignment_2 ) ) ; - public final void rule__Package_Impl__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_5__0__Impl" + // InternalRosParser.g:3233:1: rule__Package_Impl__Group_5__0__Impl : ( Specs ) ; + public final void rule__Package_Impl__Group_5__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3172:1: ( ( ( rule__Package_Impl__NameAssignment_2 ) ) ) - // InternalRos.g:3173:1: ( ( rule__Package_Impl__NameAssignment_2 ) ) - { - // InternalRos.g:3173:1: ( ( rule__Package_Impl__NameAssignment_2 ) ) - // InternalRos.g:3174:2: ( rule__Package_Impl__NameAssignment_2 ) + // InternalRosParser.g:3237:1: ( ( Specs ) ) + // InternalRosParser.g:3238:1: ( Specs ) { - before(grammarAccess.getPackage_ImplAccess().getNameAssignment_2()); - // InternalRos.g:3175:2: ( rule__Package_Impl__NameAssignment_2 ) - // InternalRos.g:3175:3: rule__Package_Impl__NameAssignment_2 + // InternalRosParser.g:3238:1: ( Specs ) + // InternalRosParser.g:3239:2: Specs { - pushFollow(FOLLOW_2); - rule__Package_Impl__NameAssignment_2(); - - state._fsp--; - - - } - - after(grammarAccess.getPackage_ImplAccess().getNameAssignment_2()); + before(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + match(input,Specs,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); } @@ -10023,26 +10134,26 @@ public final void rule__Package_Impl__Group__2__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Package_Impl__Group__2__Impl" + // $ANTLR end "rule__Package_Impl__Group_5__0__Impl" - // $ANTLR start "rule__Package_Impl__Group__3" - // InternalRos.g:3183:1: rule__Package_Impl__Group__3 : rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 ; - public final void rule__Package_Impl__Group__3() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_5__1" + // InternalRosParser.g:3248:1: rule__Package_Impl__Group_5__1 : rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 ; + public final void rule__Package_Impl__Group_5__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3187:1: ( rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 ) - // InternalRos.g:3188:2: rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 + // InternalRosParser.g:3252:1: ( rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 ) + // InternalRosParser.g:3253:2: rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 { - pushFollow(FOLLOW_11); - rule__Package_Impl__Group__3__Impl(); + pushFollow(FOLLOW_9); + rule__Package_Impl__Group_5__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Package_Impl__Group__4(); + rule__Package_Impl__Group_5__2(); state._fsp--; @@ -10061,25 +10172,25 @@ public final void rule__Package_Impl__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group__3" + // $ANTLR end "rule__Package_Impl__Group_5__1" - // $ANTLR start "rule__Package_Impl__Group__3__Impl" - // InternalRos.g:3195:1: rule__Package_Impl__Group__3__Impl : ( '{' ) ; - public final void rule__Package_Impl__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_5__1__Impl" + // InternalRosParser.g:3260:1: rule__Package_Impl__Group_5__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Package_Impl__Group_5__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3199:1: ( ( '{' ) ) - // InternalRos.g:3200:1: ( '{' ) + // InternalRosParser.g:3264:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:3265:1: ( RULE_BEGIN ) { - // InternalRos.g:3200:1: ( '{' ) - // InternalRos.g:3201:2: '{' + // InternalRosParser.g:3265:1: ( RULE_BEGIN ) + // InternalRosParser.g:3266:2: RULE_BEGIN { - before(grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_3()); - match(input,41,FOLLOW_2); - after(grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_3()); + before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); } @@ -10098,26 +10209,26 @@ public final void rule__Package_Impl__Group__3__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Package_Impl__Group__3__Impl" + // $ANTLR end "rule__Package_Impl__Group_5__1__Impl" - // $ANTLR start "rule__Package_Impl__Group__4" - // InternalRos.g:3210:1: rule__Package_Impl__Group__4 : rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 ; - public final void rule__Package_Impl__Group__4() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_5__2" + // InternalRosParser.g:3275:1: rule__Package_Impl__Group_5__2 : rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 ; + public final void rule__Package_Impl__Group_5__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3214:1: ( rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 ) - // InternalRos.g:3215:2: rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 + // InternalRosParser.g:3279:1: ( rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 ) + // InternalRosParser.g:3280:2: rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 { - pushFollow(FOLLOW_11); - rule__Package_Impl__Group__4__Impl(); + pushFollow(FOLLOW_9); + rule__Package_Impl__Group_5__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Package_Impl__Group__5(); + rule__Package_Impl__Group_5__3(); state._fsp--; @@ -10136,46 +10247,53 @@ public final void rule__Package_Impl__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group__4" + // $ANTLR end "rule__Package_Impl__Group_5__2" - // $ANTLR start "rule__Package_Impl__Group__4__Impl" - // InternalRos.g:3222:1: rule__Package_Impl__Group__4__Impl : ( ( rule__Package_Impl__Group_4__0 )? ) ; - public final void rule__Package_Impl__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_5__2__Impl" + // InternalRosParser.g:3287:1: rule__Package_Impl__Group_5__2__Impl : ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) ; + public final void rule__Package_Impl__Group_5__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3226:1: ( ( ( rule__Package_Impl__Group_4__0 )? ) ) - // InternalRos.g:3227:1: ( ( rule__Package_Impl__Group_4__0 )? ) + // InternalRosParser.g:3291:1: ( ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) ) + // InternalRosParser.g:3292:1: ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) { - // InternalRos.g:3227:1: ( ( rule__Package_Impl__Group_4__0 )? ) - // InternalRos.g:3228:2: ( rule__Package_Impl__Group_4__0 )? + // InternalRosParser.g:3292:1: ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) + // InternalRosParser.g:3293:2: ( rule__Package_Impl__SpecAssignment_5_2 )* { - before(grammarAccess.getPackage_ImplAccess().getGroup_4()); - // InternalRos.g:3229:2: ( rule__Package_Impl__Group_4__0 )? - int alt15=2; - int LA15_0 = input.LA(1); + before(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); + // InternalRosParser.g:3294:2: ( rule__Package_Impl__SpecAssignment_5_2 )* + loop17: + do { + int alt17=2; + int LA17_0 = input.LA(1); - if ( (LA15_0==45) ) { - alt15=1; - } - switch (alt15) { - case 1 : - // InternalRos.g:3229:3: rule__Package_Impl__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__Package_Impl__Group_4__0(); + if ( (LA17_0==Action_1||LA17_0==Msg||LA17_0==Srv) ) { + alt17=1; + } - state._fsp--; + switch (alt17) { + case 1 : + // InternalRosParser.g:3294:3: rule__Package_Impl__SpecAssignment_5_2 + { + pushFollow(FOLLOW_10); + rule__Package_Impl__SpecAssignment_5_2(); - } - break; + state._fsp--; - } - after(grammarAccess.getPackage_ImplAccess().getGroup_4()); + } + break; + + default : + break loop17; + } + } while (true); + + after(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); } @@ -10194,26 +10312,21 @@ public final void rule__Package_Impl__Group__4__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Package_Impl__Group__4__Impl" + // $ANTLR end "rule__Package_Impl__Group_5__2__Impl" - // $ANTLR start "rule__Package_Impl__Group__5" - // InternalRos.g:3237:1: rule__Package_Impl__Group__5 : rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 ; - public final void rule__Package_Impl__Group__5() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_5__3" + // InternalRosParser.g:3302:1: rule__Package_Impl__Group_5__3 : rule__Package_Impl__Group_5__3__Impl ; + public final void rule__Package_Impl__Group_5__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3241:1: ( rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 ) - // InternalRos.g:3242:2: rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 + // InternalRosParser.g:3306:1: ( rule__Package_Impl__Group_5__3__Impl ) + // InternalRosParser.g:3307:2: rule__Package_Impl__Group_5__3__Impl { - pushFollow(FOLLOW_11); - rule__Package_Impl__Group__5__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Package_Impl__Group__6(); + rule__Package_Impl__Group_5__3__Impl(); state._fsp--; @@ -10232,46 +10345,25 @@ public final void rule__Package_Impl__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group__5" + // $ANTLR end "rule__Package_Impl__Group_5__3" - // $ANTLR start "rule__Package_Impl__Group__5__Impl" - // InternalRos.g:3249:1: rule__Package_Impl__Group__5__Impl : ( ( rule__Package_Impl__Group_5__0 )? ) ; - public final void rule__Package_Impl__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_5__3__Impl" + // InternalRosParser.g:3313:1: rule__Package_Impl__Group_5__3__Impl : ( RULE_END ) ; + public final void rule__Package_Impl__Group_5__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3253:1: ( ( ( rule__Package_Impl__Group_5__0 )? ) ) - // InternalRos.g:3254:1: ( ( rule__Package_Impl__Group_5__0 )? ) + // InternalRosParser.g:3317:1: ( ( RULE_END ) ) + // InternalRosParser.g:3318:1: ( RULE_END ) { - // InternalRos.g:3254:1: ( ( rule__Package_Impl__Group_5__0 )? ) - // InternalRos.g:3255:2: ( rule__Package_Impl__Group_5__0 )? + // InternalRosParser.g:3318:1: ( RULE_END ) + // InternalRosParser.g:3319:2: RULE_END { - before(grammarAccess.getPackage_ImplAccess().getGroup_5()); - // InternalRos.g:3256:2: ( rule__Package_Impl__Group_5__0 )? - int alt16=2; - int LA16_0 = input.LA(1); - - if ( (LA16_0==46) ) { - alt16=1; - } - switch (alt16) { - case 1 : - // InternalRos.g:3256:3: rule__Package_Impl__Group_5__0 - { - pushFollow(FOLLOW_2); - rule__Package_Impl__Group_5__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getPackage_ImplAccess().getGroup_5()); + before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); } @@ -10290,26 +10382,26 @@ public final void rule__Package_Impl__Group__5__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Package_Impl__Group__5__Impl" + // $ANTLR end "rule__Package_Impl__Group_5__3__Impl" - // $ANTLR start "rule__Package_Impl__Group__6" - // InternalRos.g:3264:1: rule__Package_Impl__Group__6 : rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 ; - public final void rule__Package_Impl__Group__6() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6__0" + // InternalRosParser.g:3329:1: rule__Package_Impl__Group_6__0 : rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 ; + public final void rule__Package_Impl__Group_6__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3268:1: ( rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 ) - // InternalRos.g:3269:2: rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 + // InternalRosParser.g:3333:1: ( rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 ) + // InternalRosParser.g:3334:2: rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 { pushFollow(FOLLOW_11); - rule__Package_Impl__Group__6__Impl(); + rule__Package_Impl__Group_6__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Package_Impl__Group__7(); + rule__Package_Impl__Group_6__1(); state._fsp--; @@ -10328,46 +10420,25 @@ public final void rule__Package_Impl__Group__6() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group__6" + // $ANTLR end "rule__Package_Impl__Group_6__0" - // $ANTLR start "rule__Package_Impl__Group__6__Impl" - // InternalRos.g:3276:1: rule__Package_Impl__Group__6__Impl : ( ( rule__Package_Impl__Group_6__0 )? ) ; - public final void rule__Package_Impl__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6__0__Impl" + // InternalRosParser.g:3341:1: rule__Package_Impl__Group_6__0__Impl : ( Dependencies ) ; + public final void rule__Package_Impl__Group_6__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3280:1: ( ( ( rule__Package_Impl__Group_6__0 )? ) ) - // InternalRos.g:3281:1: ( ( rule__Package_Impl__Group_6__0 )? ) + // InternalRosParser.g:3345:1: ( ( Dependencies ) ) + // InternalRosParser.g:3346:1: ( Dependencies ) { - // InternalRos.g:3281:1: ( ( rule__Package_Impl__Group_6__0 )? ) - // InternalRos.g:3282:2: ( rule__Package_Impl__Group_6__0 )? + // InternalRosParser.g:3346:1: ( Dependencies ) + // InternalRosParser.g:3347:2: Dependencies { - before(grammarAccess.getPackage_ImplAccess().getGroup_6()); - // InternalRos.g:3283:2: ( rule__Package_Impl__Group_6__0 )? - int alt17=2; - int LA17_0 = input.LA(1); - - if ( (LA17_0==47) ) { - alt17=1; - } - switch (alt17) { - case 1 : - // InternalRos.g:3283:3: rule__Package_Impl__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__Package_Impl__Group_6__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getPackage_ImplAccess().getGroup_6()); + before(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); + match(input,Dependencies,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); } @@ -10386,21 +10457,26 @@ public final void rule__Package_Impl__Group__6__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Package_Impl__Group__6__Impl" + // $ANTLR end "rule__Package_Impl__Group_6__0__Impl" - // $ANTLR start "rule__Package_Impl__Group__7" - // InternalRos.g:3291:1: rule__Package_Impl__Group__7 : rule__Package_Impl__Group__7__Impl ; - public final void rule__Package_Impl__Group__7() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6__1" + // InternalRosParser.g:3356:1: rule__Package_Impl__Group_6__1 : rule__Package_Impl__Group_6__1__Impl rule__Package_Impl__Group_6__2 ; + public final void rule__Package_Impl__Group_6__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3295:1: ( rule__Package_Impl__Group__7__Impl ) - // InternalRos.g:3296:2: rule__Package_Impl__Group__7__Impl + // InternalRosParser.g:3360:1: ( rule__Package_Impl__Group_6__1__Impl rule__Package_Impl__Group_6__2 ) + // InternalRosParser.g:3361:2: rule__Package_Impl__Group_6__1__Impl rule__Package_Impl__Group_6__2 { + pushFollow(FOLLOW_12); + rule__Package_Impl__Group_6__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Package_Impl__Group__7__Impl(); + rule__Package_Impl__Group_6__2(); state._fsp--; @@ -10419,25 +10495,25 @@ public final void rule__Package_Impl__Group__7() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group__7" + // $ANTLR end "rule__Package_Impl__Group_6__1" - // $ANTLR start "rule__Package_Impl__Group__7__Impl" - // InternalRos.g:3302:1: rule__Package_Impl__Group__7__Impl : ( '}' ) ; - public final void rule__Package_Impl__Group__7__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6__1__Impl" + // InternalRosParser.g:3368:1: rule__Package_Impl__Group_6__1__Impl : ( LeftSquareBracket ) ; + public final void rule__Package_Impl__Group_6__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3306:1: ( ( '}' ) ) - // InternalRos.g:3307:1: ( '}' ) + // InternalRosParser.g:3372:1: ( ( LeftSquareBracket ) ) + // InternalRosParser.g:3373:1: ( LeftSquareBracket ) { - // InternalRos.g:3307:1: ( '}' ) - // InternalRos.g:3308:2: '}' + // InternalRosParser.g:3373:1: ( LeftSquareBracket ) + // InternalRosParser.g:3374:2: LeftSquareBracket { - before(grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_7()); - match(input,42,FOLLOW_2); - after(grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_7()); + before(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); } @@ -10456,26 +10532,26 @@ public final void rule__Package_Impl__Group__7__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Package_Impl__Group__7__Impl" + // $ANTLR end "rule__Package_Impl__Group_6__1__Impl" - // $ANTLR start "rule__Package_Impl__Group_4__0" - // InternalRos.g:3318:1: rule__Package_Impl__Group_4__0 : rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 ; - public final void rule__Package_Impl__Group_4__0() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6__2" + // InternalRosParser.g:3383:1: rule__Package_Impl__Group_6__2 : rule__Package_Impl__Group_6__2__Impl rule__Package_Impl__Group_6__3 ; + public final void rule__Package_Impl__Group_6__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3322:1: ( rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 ) - // InternalRos.g:3323:2: rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 + // InternalRosParser.g:3387:1: ( rule__Package_Impl__Group_6__2__Impl rule__Package_Impl__Group_6__3 ) + // InternalRosParser.g:3388:2: rule__Package_Impl__Group_6__2__Impl rule__Package_Impl__Group_6__3 { - pushFollow(FOLLOW_10); - rule__Package_Impl__Group_4__0__Impl(); + pushFollow(FOLLOW_13); + rule__Package_Impl__Group_6__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Package_Impl__Group_4__1(); + rule__Package_Impl__Group_6__3(); state._fsp--; @@ -10494,25 +10570,35 @@ public final void rule__Package_Impl__Group_4__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group_4__0" + // $ANTLR end "rule__Package_Impl__Group_6__2" - // $ANTLR start "rule__Package_Impl__Group_4__0__Impl" - // InternalRos.g:3330:1: rule__Package_Impl__Group_4__0__Impl : ( 'FromGitRepo' ) ; - public final void rule__Package_Impl__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6__2__Impl" + // InternalRosParser.g:3395:1: rule__Package_Impl__Group_6__2__Impl : ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) ; + public final void rule__Package_Impl__Group_6__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3334:1: ( ( 'FromGitRepo' ) ) - // InternalRos.g:3335:1: ( 'FromGitRepo' ) + // InternalRosParser.g:3399:1: ( ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) ) + // InternalRosParser.g:3400:1: ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) { - // InternalRos.g:3335:1: ( 'FromGitRepo' ) - // InternalRos.g:3336:2: 'FromGitRepo' + // InternalRosParser.g:3400:1: ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) + // InternalRosParser.g:3401:2: ( rule__Package_Impl__DependencyAssignment_6_2 ) { - before(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); - match(input,45,FOLLOW_2); - after(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); + before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); + // InternalRosParser.g:3402:2: ( rule__Package_Impl__DependencyAssignment_6_2 ) + // InternalRosParser.g:3402:3: rule__Package_Impl__DependencyAssignment_6_2 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__DependencyAssignment_6_2(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); } @@ -10531,21 +10617,26 @@ public final void rule__Package_Impl__Group_4__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Package_Impl__Group_4__0__Impl" + // $ANTLR end "rule__Package_Impl__Group_6__2__Impl" - // $ANTLR start "rule__Package_Impl__Group_4__1" - // InternalRos.g:3345:1: rule__Package_Impl__Group_4__1 : rule__Package_Impl__Group_4__1__Impl ; - public final void rule__Package_Impl__Group_4__1() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6__3" + // InternalRosParser.g:3410:1: rule__Package_Impl__Group_6__3 : rule__Package_Impl__Group_6__3__Impl rule__Package_Impl__Group_6__4 ; + public final void rule__Package_Impl__Group_6__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3349:1: ( rule__Package_Impl__Group_4__1__Impl ) - // InternalRos.g:3350:2: rule__Package_Impl__Group_4__1__Impl + // InternalRosParser.g:3414:1: ( rule__Package_Impl__Group_6__3__Impl rule__Package_Impl__Group_6__4 ) + // InternalRosParser.g:3415:2: rule__Package_Impl__Group_6__3__Impl rule__Package_Impl__Group_6__4 { + pushFollow(FOLLOW_13); + rule__Package_Impl__Group_6__3__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Package_Impl__Group_4__1__Impl(); + rule__Package_Impl__Group_6__4(); state._fsp--; @@ -10564,35 +10655,53 @@ public final void rule__Package_Impl__Group_4__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group_4__1" + // $ANTLR end "rule__Package_Impl__Group_6__3" - // $ANTLR start "rule__Package_Impl__Group_4__1__Impl" - // InternalRos.g:3356:1: rule__Package_Impl__Group_4__1__Impl : ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) ; - public final void rule__Package_Impl__Group_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6__3__Impl" + // InternalRosParser.g:3422:1: rule__Package_Impl__Group_6__3__Impl : ( ( rule__Package_Impl__Group_6_3__0 )* ) ; + public final void rule__Package_Impl__Group_6__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3360:1: ( ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) ) - // InternalRos.g:3361:1: ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) + // InternalRosParser.g:3426:1: ( ( ( rule__Package_Impl__Group_6_3__0 )* ) ) + // InternalRosParser.g:3427:1: ( ( rule__Package_Impl__Group_6_3__0 )* ) { - // InternalRos.g:3361:1: ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) - // InternalRos.g:3362:2: ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) + // InternalRosParser.g:3427:1: ( ( rule__Package_Impl__Group_6_3__0 )* ) + // InternalRosParser.g:3428:2: ( rule__Package_Impl__Group_6_3__0 )* { - before(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); - // InternalRos.g:3363:2: ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) - // InternalRos.g:3363:3: rule__Package_Impl__FromGitRepoAssignment_4_1 - { - pushFollow(FOLLOW_2); - rule__Package_Impl__FromGitRepoAssignment_4_1(); + before(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); + // InternalRosParser.g:3429:2: ( rule__Package_Impl__Group_6_3__0 )* + loop18: + do { + int alt18=2; + int LA18_0 = input.LA(1); - state._fsp--; + if ( (LA18_0==Comma) ) { + alt18=1; + } - } + switch (alt18) { + case 1 : + // InternalRosParser.g:3429:3: rule__Package_Impl__Group_6_3__0 + { + pushFollow(FOLLOW_14); + rule__Package_Impl__Group_6_3__0(); + + state._fsp--; - after(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); + + } + break; + + default : + break loop18; + } + } while (true); + + after(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); } @@ -10611,26 +10720,21 @@ public final void rule__Package_Impl__Group_4__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Package_Impl__Group_4__1__Impl" + // $ANTLR end "rule__Package_Impl__Group_6__3__Impl" - // $ANTLR start "rule__Package_Impl__Group_5__0" - // InternalRos.g:3372:1: rule__Package_Impl__Group_5__0 : rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 ; - public final void rule__Package_Impl__Group_5__0() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6__4" + // InternalRosParser.g:3437:1: rule__Package_Impl__Group_6__4 : rule__Package_Impl__Group_6__4__Impl ; + public final void rule__Package_Impl__Group_6__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3376:1: ( rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 ) - // InternalRos.g:3377:2: rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 + // InternalRosParser.g:3441:1: ( rule__Package_Impl__Group_6__4__Impl ) + // InternalRosParser.g:3442:2: rule__Package_Impl__Group_6__4__Impl { - pushFollow(FOLLOW_4); - rule__Package_Impl__Group_5__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Package_Impl__Group_5__1(); + rule__Package_Impl__Group_6__4__Impl(); state._fsp--; @@ -10649,25 +10753,25 @@ public final void rule__Package_Impl__Group_5__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group_5__0" + // $ANTLR end "rule__Package_Impl__Group_6__4" - // $ANTLR start "rule__Package_Impl__Group_5__0__Impl" - // InternalRos.g:3384:1: rule__Package_Impl__Group_5__0__Impl : ( 'Specs' ) ; - public final void rule__Package_Impl__Group_5__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6__4__Impl" + // InternalRosParser.g:3448:1: rule__Package_Impl__Group_6__4__Impl : ( RightSquareBracket ) ; + public final void rule__Package_Impl__Group_6__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3388:1: ( ( 'Specs' ) ) - // InternalRos.g:3389:1: ( 'Specs' ) + // InternalRosParser.g:3452:1: ( ( RightSquareBracket ) ) + // InternalRosParser.g:3453:1: ( RightSquareBracket ) { - // InternalRos.g:3389:1: ( 'Specs' ) - // InternalRos.g:3390:2: 'Specs' + // InternalRosParser.g:3453:1: ( RightSquareBracket ) + // InternalRosParser.g:3454:2: RightSquareBracket { - before(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); - match(input,46,FOLLOW_2); - after(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + before(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); } @@ -10686,26 +10790,26 @@ public final void rule__Package_Impl__Group_5__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Package_Impl__Group_5__0__Impl" + // $ANTLR end "rule__Package_Impl__Group_6__4__Impl" - // $ANTLR start "rule__Package_Impl__Group_5__1" - // InternalRos.g:3399:1: rule__Package_Impl__Group_5__1 : rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 ; - public final void rule__Package_Impl__Group_5__1() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6_3__0" + // InternalRosParser.g:3464:1: rule__Package_Impl__Group_6_3__0 : rule__Package_Impl__Group_6_3__0__Impl rule__Package_Impl__Group_6_3__1 ; + public final void rule__Package_Impl__Group_6_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3403:1: ( rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 ) - // InternalRos.g:3404:2: rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 + // InternalRosParser.g:3468:1: ( rule__Package_Impl__Group_6_3__0__Impl rule__Package_Impl__Group_6_3__1 ) + // InternalRosParser.g:3469:2: rule__Package_Impl__Group_6_3__0__Impl rule__Package_Impl__Group_6_3__1 { pushFollow(FOLLOW_12); - rule__Package_Impl__Group_5__1__Impl(); + rule__Package_Impl__Group_6_3__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Package_Impl__Group_5__2(); + rule__Package_Impl__Group_6_3__1(); state._fsp--; @@ -10724,25 +10828,25 @@ public final void rule__Package_Impl__Group_5__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group_5__1" + // $ANTLR end "rule__Package_Impl__Group_6_3__0" - // $ANTLR start "rule__Package_Impl__Group_5__1__Impl" - // InternalRos.g:3411:1: rule__Package_Impl__Group_5__1__Impl : ( '{' ) ; - public final void rule__Package_Impl__Group_5__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6_3__0__Impl" + // InternalRosParser.g:3476:1: rule__Package_Impl__Group_6_3__0__Impl : ( Comma ) ; + public final void rule__Package_Impl__Group_6_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3415:1: ( ( '{' ) ) - // InternalRos.g:3416:1: ( '{' ) + // InternalRosParser.g:3480:1: ( ( Comma ) ) + // InternalRosParser.g:3481:1: ( Comma ) { - // InternalRos.g:3416:1: ( '{' ) - // InternalRos.g:3417:2: '{' + // InternalRosParser.g:3481:1: ( Comma ) + // InternalRosParser.g:3482:2: Comma { - before(grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_5_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_5_1()); + before(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); } @@ -10761,26 +10865,21 @@ public final void rule__Package_Impl__Group_5__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Package_Impl__Group_5__1__Impl" + // $ANTLR end "rule__Package_Impl__Group_6_3__0__Impl" - // $ANTLR start "rule__Package_Impl__Group_5__2" - // InternalRos.g:3426:1: rule__Package_Impl__Group_5__2 : rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 ; - public final void rule__Package_Impl__Group_5__2() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6_3__1" + // InternalRosParser.g:3491:1: rule__Package_Impl__Group_6_3__1 : rule__Package_Impl__Group_6_3__1__Impl ; + public final void rule__Package_Impl__Group_6_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3430:1: ( rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 ) - // InternalRos.g:3431:2: rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 + // InternalRosParser.g:3495:1: ( rule__Package_Impl__Group_6_3__1__Impl ) + // InternalRosParser.g:3496:2: rule__Package_Impl__Group_6_3__1__Impl { - pushFollow(FOLLOW_13); - rule__Package_Impl__Group_5__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Package_Impl__Group_5__3(); + rule__Package_Impl__Group_6_3__1__Impl(); state._fsp--; @@ -10799,35 +10898,35 @@ public final void rule__Package_Impl__Group_5__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group_5__2" + // $ANTLR end "rule__Package_Impl__Group_6_3__1" - // $ANTLR start "rule__Package_Impl__Group_5__2__Impl" - // InternalRos.g:3438:1: rule__Package_Impl__Group_5__2__Impl : ( ( rule__Package_Impl__SpecAssignment_5_2 ) ) ; - public final void rule__Package_Impl__Group_5__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__Group_6_3__1__Impl" + // InternalRosParser.g:3502:1: rule__Package_Impl__Group_6_3__1__Impl : ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) ; + public final void rule__Package_Impl__Group_6_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3442:1: ( ( ( rule__Package_Impl__SpecAssignment_5_2 ) ) ) - // InternalRos.g:3443:1: ( ( rule__Package_Impl__SpecAssignment_5_2 ) ) + // InternalRosParser.g:3506:1: ( ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) ) + // InternalRosParser.g:3507:1: ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) { - // InternalRos.g:3443:1: ( ( rule__Package_Impl__SpecAssignment_5_2 ) ) - // InternalRos.g:3444:2: ( rule__Package_Impl__SpecAssignment_5_2 ) + // InternalRosParser.g:3507:1: ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) + // InternalRosParser.g:3508:2: ( rule__Package_Impl__DependencyAssignment_6_3_1 ) { - before(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); - // InternalRos.g:3445:2: ( rule__Package_Impl__SpecAssignment_5_2 ) - // InternalRos.g:3445:3: rule__Package_Impl__SpecAssignment_5_2 + before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1()); + // InternalRosParser.g:3509:2: ( rule__Package_Impl__DependencyAssignment_6_3_1 ) + // InternalRosParser.g:3509:3: rule__Package_Impl__DependencyAssignment_6_3_1 { pushFollow(FOLLOW_2); - rule__Package_Impl__SpecAssignment_5_2(); + rule__Package_Impl__DependencyAssignment_6_3_1(); state._fsp--; } - after(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); + after(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1()); } @@ -10846,26 +10945,26 @@ public final void rule__Package_Impl__Group_5__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Package_Impl__Group_5__2__Impl" + // $ANTLR end "rule__Package_Impl__Group_6_3__1__Impl" - // $ANTLR start "rule__Package_Impl__Group_5__3" - // InternalRos.g:3453:1: rule__Package_Impl__Group_5__3 : rule__Package_Impl__Group_5__3__Impl rule__Package_Impl__Group_5__4 ; - public final void rule__Package_Impl__Group_5__3() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__0" + // InternalRosParser.g:3518: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 { - // InternalRos.g:3457:1: ( rule__Package_Impl__Group_5__3__Impl rule__Package_Impl__Group_5__4 ) - // InternalRos.g:3458:2: rule__Package_Impl__Group_5__3__Impl rule__Package_Impl__Group_5__4 + // InternalRosParser.g:3522:1: ( rule__Artifact__Group__0__Impl rule__Artifact__Group__1 ) + // InternalRosParser.g:3523:2: rule__Artifact__Group__0__Impl rule__Artifact__Group__1 { - pushFollow(FOLLOW_13); - rule__Package_Impl__Group_5__3__Impl(); + pushFollow(FOLLOW_3); + rule__Artifact__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Package_Impl__Group_5__4(); + rule__Artifact__Group__1(); state._fsp--; @@ -10884,53 +10983,29 @@ public final void rule__Package_Impl__Group_5__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group_5__3" + // $ANTLR end "rule__Artifact__Group__0" - // $ANTLR start "rule__Package_Impl__Group_5__3__Impl" - // InternalRos.g:3465:1: rule__Package_Impl__Group_5__3__Impl : ( ( rule__Package_Impl__Group_5_3__0 )* ) ; - public final void rule__Package_Impl__Group_5__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__0__Impl" + // InternalRosParser.g:3530:1: rule__Artifact__Group__0__Impl : ( () ) ; + public final void rule__Artifact__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3469:1: ( ( ( rule__Package_Impl__Group_5_3__0 )* ) ) - // InternalRos.g:3470:1: ( ( rule__Package_Impl__Group_5_3__0 )* ) + // InternalRosParser.g:3534:1: ( ( () ) ) + // InternalRosParser.g:3535:1: ( () ) { - // InternalRos.g:3470:1: ( ( rule__Package_Impl__Group_5_3__0 )* ) - // InternalRos.g:3471:2: ( rule__Package_Impl__Group_5_3__0 )* + // InternalRosParser.g:3535:1: ( () ) + // InternalRosParser.g:3536:2: () { - before(grammarAccess.getPackage_ImplAccess().getGroup_5_3()); - // InternalRos.g:3472:2: ( rule__Package_Impl__Group_5_3__0 )* - loop18: - do { - int alt18=2; - int LA18_0 = input.LA(1); - - if ( (LA18_0==43) ) { - alt18=1; - } - - - switch (alt18) { - case 1 : - // InternalRos.g:3472:3: rule__Package_Impl__Group_5_3__0 - { - pushFollow(FOLLOW_7); - rule__Package_Impl__Group_5_3__0(); - - state._fsp--; - - - } - break; - - default : - break loop18; - } - } while (true); + before(grammarAccess.getArtifactAccess().getArtifactAction_0()); + // InternalRosParser.g:3537:2: () + // InternalRosParser.g:3537:3: + { + } - after(grammarAccess.getPackage_ImplAccess().getGroup_5_3()); + after(grammarAccess.getArtifactAccess().getArtifactAction_0()); } @@ -10938,10 +11013,6 @@ public final void rule__Package_Impl__Group_5__3__Impl() throws RecognitionExcep } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -10949,21 +11020,26 @@ public final void rule__Package_Impl__Group_5__3__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Package_Impl__Group_5__3__Impl" + // $ANTLR end "rule__Artifact__Group__0__Impl" - // $ANTLR start "rule__Package_Impl__Group_5__4" - // InternalRos.g:3480:1: rule__Package_Impl__Group_5__4 : rule__Package_Impl__Group_5__4__Impl ; - public final void rule__Package_Impl__Group_5__4() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__1" + // InternalRosParser.g:3545: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 { - // InternalRos.g:3484:1: ( rule__Package_Impl__Group_5__4__Impl ) - // InternalRos.g:3485:2: rule__Package_Impl__Group_5__4__Impl + // InternalRosParser.g:3549:1: ( rule__Artifact__Group__1__Impl rule__Artifact__Group__2 ) + // InternalRosParser.g:3550:2: rule__Artifact__Group__1__Impl rule__Artifact__Group__2 { + pushFollow(FOLLOW_5); + rule__Artifact__Group__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Package_Impl__Group_5__4__Impl(); + rule__Artifact__Group__2(); state._fsp--; @@ -10982,25 +11058,35 @@ public final void rule__Package_Impl__Group_5__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group_5__4" + // $ANTLR end "rule__Artifact__Group__1" - // $ANTLR start "rule__Package_Impl__Group_5__4__Impl" - // InternalRos.g:3491:1: rule__Package_Impl__Group_5__4__Impl : ( '}' ) ; - public final void rule__Package_Impl__Group_5__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__1__Impl" + // InternalRosParser.g:3557:1: rule__Artifact__Group__1__Impl : ( ( rule__Artifact__NameAssignment_1 ) ) ; + public final void rule__Artifact__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3495:1: ( ( '}' ) ) - // InternalRos.g:3496:1: ( '}' ) + // InternalRosParser.g:3561:1: ( ( ( rule__Artifact__NameAssignment_1 ) ) ) + // InternalRosParser.g:3562:1: ( ( rule__Artifact__NameAssignment_1 ) ) + { + // InternalRosParser.g:3562:1: ( ( rule__Artifact__NameAssignment_1 ) ) + // InternalRosParser.g:3563:2: ( rule__Artifact__NameAssignment_1 ) { - // InternalRos.g:3496:1: ( '}' ) - // InternalRos.g:3497:2: '}' + before(grammarAccess.getArtifactAccess().getNameAssignment_1()); + // InternalRosParser.g:3564:2: ( rule__Artifact__NameAssignment_1 ) + // InternalRosParser.g:3564:3: rule__Artifact__NameAssignment_1 { - before(grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_5_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_5_4()); + pushFollow(FOLLOW_2); + rule__Artifact__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getArtifactAccess().getNameAssignment_1()); } @@ -11019,26 +11105,26 @@ public final void rule__Package_Impl__Group_5__4__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Package_Impl__Group_5__4__Impl" + // $ANTLR end "rule__Artifact__Group__1__Impl" - // $ANTLR start "rule__Package_Impl__Group_5_3__0" - // InternalRos.g:3507:1: rule__Package_Impl__Group_5_3__0 : rule__Package_Impl__Group_5_3__0__Impl rule__Package_Impl__Group_5_3__1 ; - public final void rule__Package_Impl__Group_5_3__0() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__2" + // InternalRosParser.g:3572: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 { - // InternalRos.g:3511:1: ( rule__Package_Impl__Group_5_3__0__Impl rule__Package_Impl__Group_5_3__1 ) - // InternalRos.g:3512:2: rule__Package_Impl__Group_5_3__0__Impl rule__Package_Impl__Group_5_3__1 + // InternalRosParser.g:3576:1: ( rule__Artifact__Group__2__Impl rule__Artifact__Group__3 ) + // InternalRosParser.g:3577:2: rule__Artifact__Group__2__Impl rule__Artifact__Group__3 { - pushFollow(FOLLOW_12); - rule__Package_Impl__Group_5_3__0__Impl(); + pushFollow(FOLLOW_6); + rule__Artifact__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Package_Impl__Group_5_3__1(); + rule__Artifact__Group__3(); state._fsp--; @@ -11057,25 +11143,25 @@ public final void rule__Package_Impl__Group_5_3__0() throws RecognitionException } return ; } - // $ANTLR end "rule__Package_Impl__Group_5_3__0" + // $ANTLR end "rule__Artifact__Group__2" - // $ANTLR start "rule__Package_Impl__Group_5_3__0__Impl" - // InternalRos.g:3519:1: rule__Package_Impl__Group_5_3__0__Impl : ( ',' ) ; - public final void rule__Package_Impl__Group_5_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__2__Impl" + // InternalRosParser.g:3584:1: rule__Artifact__Group__2__Impl : ( Colon ) ; + public final void rule__Artifact__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3523:1: ( ( ',' ) ) - // InternalRos.g:3524:1: ( ',' ) + // InternalRosParser.g:3588:1: ( ( Colon ) ) + // InternalRosParser.g:3589:1: ( Colon ) { - // InternalRos.g:3524:1: ( ',' ) - // InternalRos.g:3525:2: ',' + // InternalRosParser.g:3589:1: ( Colon ) + // InternalRosParser.g:3590:2: Colon { - before(grammarAccess.getPackage_ImplAccess().getCommaKeyword_5_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getPackage_ImplAccess().getCommaKeyword_5_3_0()); + before(grammarAccess.getArtifactAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getArtifactAccess().getColonKeyword_2()); } @@ -11094,21 +11180,26 @@ public final void rule__Package_Impl__Group_5_3__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__Package_Impl__Group_5_3__0__Impl" + // $ANTLR end "rule__Artifact__Group__2__Impl" - // $ANTLR start "rule__Package_Impl__Group_5_3__1" - // InternalRos.g:3534:1: rule__Package_Impl__Group_5_3__1 : rule__Package_Impl__Group_5_3__1__Impl ; - public final void rule__Package_Impl__Group_5_3__1() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__3" + // InternalRosParser.g:3599: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 { - // InternalRos.g:3538:1: ( rule__Package_Impl__Group_5_3__1__Impl ) - // InternalRos.g:3539:2: rule__Package_Impl__Group_5_3__1__Impl + // InternalRosParser.g:3603:1: ( rule__Artifact__Group__3__Impl rule__Artifact__Group__4 ) + // InternalRosParser.g:3604:2: rule__Artifact__Group__3__Impl rule__Artifact__Group__4 { + pushFollow(FOLLOW_15); + rule__Artifact__Group__3__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Package_Impl__Group_5_3__1__Impl(); + rule__Artifact__Group__4(); state._fsp--; @@ -11127,35 +11218,25 @@ public final void rule__Package_Impl__Group_5_3__1() throws RecognitionException } return ; } - // $ANTLR end "rule__Package_Impl__Group_5_3__1" + // $ANTLR end "rule__Artifact__Group__3" - // $ANTLR start "rule__Package_Impl__Group_5_3__1__Impl" - // InternalRos.g:3545:1: rule__Package_Impl__Group_5_3__1__Impl : ( ( rule__Package_Impl__SpecAssignment_5_3_1 ) ) ; - public final void rule__Package_Impl__Group_5_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__3__Impl" + // InternalRosParser.g:3611:1: rule__Artifact__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Artifact__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3549:1: ( ( ( rule__Package_Impl__SpecAssignment_5_3_1 ) ) ) - // InternalRos.g:3550:1: ( ( rule__Package_Impl__SpecAssignment_5_3_1 ) ) - { - // InternalRos.g:3550:1: ( ( rule__Package_Impl__SpecAssignment_5_3_1 ) ) - // InternalRos.g:3551:2: ( rule__Package_Impl__SpecAssignment_5_3_1 ) + // InternalRosParser.g:3615:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:3616:1: ( RULE_BEGIN ) { - before(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_3_1()); - // InternalRos.g:3552:2: ( rule__Package_Impl__SpecAssignment_5_3_1 ) - // InternalRos.g:3552:3: rule__Package_Impl__SpecAssignment_5_3_1 + // InternalRosParser.g:3616:1: ( RULE_BEGIN ) + // InternalRosParser.g:3617:2: RULE_BEGIN { - pushFollow(FOLLOW_2); - rule__Package_Impl__SpecAssignment_5_3_1(); - - state._fsp--; - - - } - - after(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_3_1()); + before(grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); } @@ -11174,26 +11255,26 @@ public final void rule__Package_Impl__Group_5_3__1__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__Package_Impl__Group_5_3__1__Impl" + // $ANTLR end "rule__Artifact__Group__3__Impl" - // $ANTLR start "rule__Package_Impl__Group_6__0" - // InternalRos.g:3561:1: rule__Package_Impl__Group_6__0 : rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 ; - public final void rule__Package_Impl__Group_6__0() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__4" + // InternalRosParser.g:3626: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 { - // InternalRos.g:3565:1: ( rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 ) - // InternalRos.g:3566:2: rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 + // InternalRosParser.g:3630:1: ( rule__Artifact__Group__4__Impl rule__Artifact__Group__5 ) + // InternalRosParser.g:3631:2: rule__Artifact__Group__4__Impl rule__Artifact__Group__5 { - pushFollow(FOLLOW_6); - rule__Package_Impl__Group_6__0__Impl(); + pushFollow(FOLLOW_15); + rule__Artifact__Group__4__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Package_Impl__Group_6__1(); + rule__Artifact__Group__5(); state._fsp--; @@ -11212,35 +11293,46 @@ public final void rule__Package_Impl__Group_6__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group_6__0" + // $ANTLR end "rule__Artifact__Group__4" - // $ANTLR start "rule__Package_Impl__Group_6__0__Impl" - // InternalRos.g:3573:1: rule__Package_Impl__Group_6__0__Impl : ( ( rule__Package_Impl__ArtifactAssignment_6_0 ) ) ; - public final void rule__Package_Impl__Group_6__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__4__Impl" + // InternalRosParser.g:3638:1: rule__Artifact__Group__4__Impl : ( ( rule__Artifact__NodeAssignment_4 )? ) ; + public final void rule__Artifact__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3577:1: ( ( ( rule__Package_Impl__ArtifactAssignment_6_0 ) ) ) - // InternalRos.g:3578:1: ( ( rule__Package_Impl__ArtifactAssignment_6_0 ) ) + // InternalRosParser.g:3642:1: ( ( ( rule__Artifact__NodeAssignment_4 )? ) ) + // InternalRosParser.g:3643:1: ( ( rule__Artifact__NodeAssignment_4 )? ) { - // InternalRos.g:3578:1: ( ( rule__Package_Impl__ArtifactAssignment_6_0 ) ) - // InternalRos.g:3579:2: ( rule__Package_Impl__ArtifactAssignment_6_0 ) + // InternalRosParser.g:3643:1: ( ( rule__Artifact__NodeAssignment_4 )? ) + // InternalRosParser.g:3644:2: ( rule__Artifact__NodeAssignment_4 )? { - before(grammarAccess.getPackage_ImplAccess().getArtifactAssignment_6_0()); - // InternalRos.g:3580:2: ( rule__Package_Impl__ArtifactAssignment_6_0 ) - // InternalRos.g:3580:3: rule__Package_Impl__ArtifactAssignment_6_0 - { - pushFollow(FOLLOW_2); - rule__Package_Impl__ArtifactAssignment_6_0(); + before(grammarAccess.getArtifactAccess().getNodeAssignment_4()); + // InternalRosParser.g:3645:2: ( rule__Artifact__NodeAssignment_4 )? + int alt19=2; + int LA19_0 = input.LA(1); - state._fsp--; + if ( (LA19_0==Node_1) ) { + alt19=1; + } + switch (alt19) { + case 1 : + // InternalRosParser.g:3645:3: rule__Artifact__NodeAssignment_4 + { + pushFollow(FOLLOW_2); + rule__Artifact__NodeAssignment_4(); + + state._fsp--; + } + break; + } - after(grammarAccess.getPackage_ImplAccess().getArtifactAssignment_6_0()); + after(grammarAccess.getArtifactAccess().getNodeAssignment_4()); } @@ -11259,21 +11351,21 @@ public final void rule__Package_Impl__Group_6__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Package_Impl__Group_6__0__Impl" + // $ANTLR end "rule__Artifact__Group__4__Impl" - // $ANTLR start "rule__Package_Impl__Group_6__1" - // InternalRos.g:3588:1: rule__Package_Impl__Group_6__1 : rule__Package_Impl__Group_6__1__Impl ; - public final void rule__Package_Impl__Group_6__1() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__5" + // InternalRosParser.g:3653:1: rule__Artifact__Group__5 : rule__Artifact__Group__5__Impl ; + public final void rule__Artifact__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3592:1: ( rule__Package_Impl__Group_6__1__Impl ) - // InternalRos.g:3593:2: rule__Package_Impl__Group_6__1__Impl + // InternalRosParser.g:3657:1: ( rule__Artifact__Group__5__Impl ) + // InternalRosParser.g:3658:2: rule__Artifact__Group__5__Impl { pushFollow(FOLLOW_2); - rule__Package_Impl__Group_6__1__Impl(); + rule__Artifact__Group__5__Impl(); state._fsp--; @@ -11292,53 +11384,25 @@ public final void rule__Package_Impl__Group_6__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Package_Impl__Group_6__1" + // $ANTLR end "rule__Artifact__Group__5" - // $ANTLR start "rule__Package_Impl__Group_6__1__Impl" - // InternalRos.g:3599:1: rule__Package_Impl__Group_6__1__Impl : ( ( rule__Package_Impl__Group_6_1__0 )* ) ; - public final void rule__Package_Impl__Group_6__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Artifact__Group__5__Impl" + // InternalRosParser.g:3664:1: rule__Artifact__Group__5__Impl : ( RULE_END ) ; + public final void rule__Artifact__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3603:1: ( ( ( rule__Package_Impl__Group_6_1__0 )* ) ) - // InternalRos.g:3604:1: ( ( rule__Package_Impl__Group_6_1__0 )* ) + // InternalRosParser.g:3668:1: ( ( RULE_END ) ) + // InternalRosParser.g:3669:1: ( RULE_END ) { - // InternalRos.g:3604:1: ( ( rule__Package_Impl__Group_6_1__0 )* ) - // InternalRos.g:3605:2: ( rule__Package_Impl__Group_6_1__0 )* + // InternalRosParser.g:3669:1: ( RULE_END ) + // InternalRosParser.g:3670:2: RULE_END { - before(grammarAccess.getPackage_ImplAccess().getGroup_6_1()); - // InternalRos.g:3606:2: ( rule__Package_Impl__Group_6_1__0 )* - loop19: - do { - int alt19=2; - int LA19_0 = input.LA(1); - - if ( (LA19_0==43) ) { - alt19=1; - } - - - switch (alt19) { - case 1 : - // InternalRos.g:3606:3: rule__Package_Impl__Group_6_1__0 - { - pushFollow(FOLLOW_7); - rule__Package_Impl__Group_6_1__0(); - - state._fsp--; - - - } - break; - - default : - break loop19; - } - } while (true); - - after(grammarAccess.getPackage_ImplAccess().getGroup_6_1()); + before(grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); } @@ -11357,26 +11421,26 @@ public final void rule__Package_Impl__Group_6__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Package_Impl__Group_6__1__Impl" + // $ANTLR end "rule__Artifact__Group__5__Impl" - // $ANTLR start "rule__Package_Impl__Group_6_1__0" - // InternalRos.g:3615:1: rule__Package_Impl__Group_6_1__0 : rule__Package_Impl__Group_6_1__0__Impl rule__Package_Impl__Group_6_1__1 ; - public final void rule__Package_Impl__Group_6_1__0() throws RecognitionException { + // $ANTLR start "rule__Node__Group__0" + // InternalRosParser.g:3680: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 { - // InternalRos.g:3619:1: ( rule__Package_Impl__Group_6_1__0__Impl rule__Package_Impl__Group_6_1__1 ) - // InternalRos.g:3620:2: rule__Package_Impl__Group_6_1__0__Impl rule__Package_Impl__Group_6_1__1 + // InternalRosParser.g:3684:1: ( rule__Node__Group__0__Impl rule__Node__Group__1 ) + // InternalRosParser.g:3685:2: rule__Node__Group__0__Impl rule__Node__Group__1 { - pushFollow(FOLLOW_14); - rule__Package_Impl__Group_6_1__0__Impl(); + pushFollow(FOLLOW_3); + rule__Node__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Package_Impl__Group_6_1__1(); + rule__Node__Group__1(); state._fsp--; @@ -11395,25 +11459,25 @@ public final void rule__Package_Impl__Group_6_1__0() throws RecognitionException } return ; } - // $ANTLR end "rule__Package_Impl__Group_6_1__0" + // $ANTLR end "rule__Node__Group__0" - // $ANTLR start "rule__Package_Impl__Group_6_1__0__Impl" - // InternalRos.g:3627:1: rule__Package_Impl__Group_6_1__0__Impl : ( ',' ) ; - public final void rule__Package_Impl__Group_6_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group__0__Impl" + // InternalRosParser.g:3692:1: rule__Node__Group__0__Impl : ( Node_1 ) ; + public final void rule__Node__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3631:1: ( ( ',' ) ) - // InternalRos.g:3632:1: ( ',' ) + // InternalRosParser.g:3696:1: ( ( Node_1 ) ) + // InternalRosParser.g:3697:1: ( Node_1 ) { - // InternalRos.g:3632:1: ( ',' ) - // InternalRos.g:3633:2: ',' + // InternalRosParser.g:3697:1: ( Node_1 ) + // InternalRosParser.g:3698:2: Node_1 { - before(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_1_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_1_0()); + before(grammarAccess.getNodeAccess().getNodeKeyword_0()); + match(input,Node_1,FOLLOW_2); + after(grammarAccess.getNodeAccess().getNodeKeyword_0()); } @@ -11432,21 +11496,26 @@ public final void rule__Package_Impl__Group_6_1__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__Package_Impl__Group_6_1__0__Impl" + // $ANTLR end "rule__Node__Group__0__Impl" - // $ANTLR start "rule__Package_Impl__Group_6_1__1" - // InternalRos.g:3642:1: rule__Package_Impl__Group_6_1__1 : rule__Package_Impl__Group_6_1__1__Impl ; - public final void rule__Package_Impl__Group_6_1__1() throws RecognitionException { + // $ANTLR start "rule__Node__Group__1" + // InternalRosParser.g:3707: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 { - // InternalRos.g:3646:1: ( rule__Package_Impl__Group_6_1__1__Impl ) - // InternalRos.g:3647:2: rule__Package_Impl__Group_6_1__1__Impl + // InternalRosParser.g:3711:1: ( rule__Node__Group__1__Impl rule__Node__Group__2 ) + // InternalRosParser.g:3712:2: rule__Node__Group__1__Impl rule__Node__Group__2 { + pushFollow(FOLLOW_6); + rule__Node__Group__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Package_Impl__Group_6_1__1__Impl(); + rule__Node__Group__2(); state._fsp--; @@ -11465,35 +11534,35 @@ public final void rule__Package_Impl__Group_6_1__1() throws RecognitionException } return ; } - // $ANTLR end "rule__Package_Impl__Group_6_1__1" + // $ANTLR end "rule__Node__Group__1" - // $ANTLR start "rule__Package_Impl__Group_6_1__1__Impl" - // InternalRos.g:3653:1: rule__Package_Impl__Group_6_1__1__Impl : ( ( rule__Package_Impl__ArtifactAssignment_6_1_1 ) ) ; - public final void rule__Package_Impl__Group_6_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group__1__Impl" + // InternalRosParser.g:3719:1: rule__Node__Group__1__Impl : ( ( rule__Node__NameAssignment_1 ) ) ; + public final void rule__Node__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3657:1: ( ( ( rule__Package_Impl__ArtifactAssignment_6_1_1 ) ) ) - // InternalRos.g:3658:1: ( ( rule__Package_Impl__ArtifactAssignment_6_1_1 ) ) + // InternalRosParser.g:3723:1: ( ( ( rule__Node__NameAssignment_1 ) ) ) + // InternalRosParser.g:3724:1: ( ( rule__Node__NameAssignment_1 ) ) { - // InternalRos.g:3658:1: ( ( rule__Package_Impl__ArtifactAssignment_6_1_1 ) ) - // InternalRos.g:3659:2: ( rule__Package_Impl__ArtifactAssignment_6_1_1 ) + // InternalRosParser.g:3724:1: ( ( rule__Node__NameAssignment_1 ) ) + // InternalRosParser.g:3725:2: ( rule__Node__NameAssignment_1 ) { - before(grammarAccess.getPackage_ImplAccess().getArtifactAssignment_6_1_1()); - // InternalRos.g:3660:2: ( rule__Package_Impl__ArtifactAssignment_6_1_1 ) - // InternalRos.g:3660:3: rule__Package_Impl__ArtifactAssignment_6_1_1 + before(grammarAccess.getNodeAccess().getNameAssignment_1()); + // InternalRosParser.g:3726:2: ( rule__Node__NameAssignment_1 ) + // InternalRosParser.g:3726:3: rule__Node__NameAssignment_1 { pushFollow(FOLLOW_2); - rule__Package_Impl__ArtifactAssignment_6_1_1(); + rule__Node__NameAssignment_1(); state._fsp--; } - after(grammarAccess.getPackage_ImplAccess().getArtifactAssignment_6_1_1()); + after(grammarAccess.getNodeAccess().getNameAssignment_1()); } @@ -11512,26 +11581,26 @@ public final void rule__Package_Impl__Group_6_1__1__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__Package_Impl__Group_6_1__1__Impl" + // $ANTLR end "rule__Node__Group__1__Impl" - // $ANTLR start "rule__Artifact__Group__0" - // InternalRos.g:3669:1: rule__Artifact__Group__0 : rule__Artifact__Group__0__Impl rule__Artifact__Group__1 ; - public final void rule__Artifact__Group__0() throws RecognitionException { + // $ANTLR start "rule__Node__Group__2" + // InternalRosParser.g:3734: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 { - // InternalRos.g:3673:1: ( rule__Artifact__Group__0__Impl rule__Artifact__Group__1 ) - // InternalRos.g:3674:2: rule__Artifact__Group__0__Impl rule__Artifact__Group__1 + // InternalRosParser.g:3738:1: ( rule__Node__Group__2__Impl rule__Node__Group__3 ) + // InternalRosParser.g:3739:2: rule__Node__Group__2__Impl rule__Node__Group__3 { - pushFollow(FOLLOW_14); - rule__Artifact__Group__0__Impl(); + pushFollow(FOLLOW_16); + rule__Node__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Artifact__Group__1(); + rule__Node__Group__3(); state._fsp--; @@ -11550,29 +11619,25 @@ public final void rule__Artifact__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__0" + // $ANTLR end "rule__Node__Group__2" - // $ANTLR start "rule__Artifact__Group__0__Impl" - // InternalRos.g:3681:1: rule__Artifact__Group__0__Impl : ( () ) ; - public final void rule__Artifact__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group__2__Impl" + // InternalRosParser.g:3746:1: rule__Node__Group__2__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3685:1: ( ( () ) ) - // InternalRos.g:3686:1: ( () ) + // InternalRosParser.g:3750:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:3751:1: ( RULE_BEGIN ) { - // InternalRos.g:3686:1: ( () ) - // InternalRos.g:3687:2: () + // InternalRosParser.g:3751:1: ( RULE_BEGIN ) + // InternalRosParser.g:3752:2: RULE_BEGIN { - before(grammarAccess.getArtifactAccess().getArtifactAction_0()); - // InternalRos.g:3688:2: () - // InternalRos.g:3688:3: - { - } - - after(grammarAccess.getArtifactAccess().getArtifactAction_0()); + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); } @@ -11580,6 +11645,10 @@ public final void rule__Artifact__Group__0__Impl() throws RecognitionException { } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -11587,26 +11656,26 @@ public final void rule__Artifact__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__0__Impl" + // $ANTLR end "rule__Node__Group__2__Impl" - // $ANTLR start "rule__Artifact__Group__1" - // InternalRos.g:3696:1: rule__Artifact__Group__1 : rule__Artifact__Group__1__Impl rule__Artifact__Group__2 ; - public final void rule__Artifact__Group__1() throws RecognitionException { + // $ANTLR start "rule__Node__Group__3" + // InternalRosParser.g:3761: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 { - // InternalRos.g:3700:1: ( rule__Artifact__Group__1__Impl rule__Artifact__Group__2 ) - // InternalRos.g:3701:2: rule__Artifact__Group__1__Impl rule__Artifact__Group__2 + // InternalRosParser.g:3765:1: ( rule__Node__Group__3__Impl rule__Node__Group__4 ) + // InternalRosParser.g:3766:2: rule__Node__Group__3__Impl rule__Node__Group__4 { - pushFollow(FOLLOW_15); - rule__Artifact__Group__1__Impl(); + pushFollow(FOLLOW_16); + rule__Node__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Artifact__Group__2(); + rule__Node__Group__4(); state._fsp--; @@ -11625,25 +11694,53 @@ public final void rule__Artifact__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__1" + // $ANTLR end "rule__Node__Group__3" - // $ANTLR start "rule__Artifact__Group__1__Impl" - // InternalRos.g:3708:1: rule__Artifact__Group__1__Impl : ( 'Artifact' ) ; - public final void rule__Artifact__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group__3__Impl" + // InternalRosParser.g:3773:1: rule__Node__Group__3__Impl : ( ( rule__Node__Alternatives_3 )* ) ; + public final void rule__Node__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3712:1: ( ( 'Artifact' ) ) - // InternalRos.g:3713:1: ( 'Artifact' ) + // InternalRosParser.g:3777:1: ( ( ( rule__Node__Alternatives_3 )* ) ) + // InternalRosParser.g:3778:1: ( ( rule__Node__Alternatives_3 )* ) { - // InternalRos.g:3713:1: ( 'Artifact' ) - // InternalRos.g:3714:2: 'Artifact' + // InternalRosParser.g:3778:1: ( ( rule__Node__Alternatives_3 )* ) + // InternalRosParser.g:3779:2: ( rule__Node__Alternatives_3 )* { - before(grammarAccess.getArtifactAccess().getArtifactKeyword_1()); - match(input,47,FOLLOW_2); - after(grammarAccess.getArtifactAccess().getArtifactKeyword_1()); + before(grammarAccess.getNodeAccess().getAlternatives_3()); + // InternalRosParser.g:3780:2: ( rule__Node__Alternatives_3 )* + loop20: + do { + int alt20=2; + int LA20_0 = input.LA(1); + + if ( ((LA20_0>=Serviceclient && LA20_0<=Actionserver)||(LA20_0>=Subscribers && LA20_0<=Publishers)) ) { + alt20=1; + } + + + switch (alt20) { + case 1 : + // InternalRosParser.g:3780:3: rule__Node__Alternatives_3 + { + pushFollow(FOLLOW_17); + rule__Node__Alternatives_3(); + + state._fsp--; + + + } + break; + + default : + break loop20; + } + } while (true); + + after(grammarAccess.getNodeAccess().getAlternatives_3()); } @@ -11662,26 +11759,21 @@ public final void rule__Artifact__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__1__Impl" + // $ANTLR end "rule__Node__Group__3__Impl" - // $ANTLR start "rule__Artifact__Group__2" - // InternalRos.g:3723:1: rule__Artifact__Group__2 : rule__Artifact__Group__2__Impl rule__Artifact__Group__3 ; - public final void rule__Artifact__Group__2() throws RecognitionException { + // $ANTLR start "rule__Node__Group__4" + // InternalRosParser.g:3788:1: rule__Node__Group__4 : rule__Node__Group__4__Impl ; + public final void rule__Node__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3727:1: ( rule__Artifact__Group__2__Impl rule__Artifact__Group__3 ) - // InternalRos.g:3728:2: rule__Artifact__Group__2__Impl rule__Artifact__Group__3 + // InternalRosParser.g:3792:1: ( rule__Node__Group__4__Impl ) + // InternalRosParser.g:3793:2: rule__Node__Group__4__Impl { - pushFollow(FOLLOW_4); - rule__Artifact__Group__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Artifact__Group__3(); + rule__Node__Group__4__Impl(); state._fsp--; @@ -11700,35 +11792,100 @@ public final void rule__Artifact__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__2" + // $ANTLR end "rule__Node__Group__4" - // $ANTLR start "rule__Artifact__Group__2__Impl" - // InternalRos.g:3735:1: rule__Artifact__Group__2__Impl : ( ( rule__Artifact__NameAssignment_2 ) ) ; - public final void rule__Artifact__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group__4__Impl" + // InternalRosParser.g:3799:1: rule__Node__Group__4__Impl : ( RULE_END ) ; + public final void rule__Node__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3739:1: ( ( ( rule__Artifact__NameAssignment_2 ) ) ) - // InternalRos.g:3740:1: ( ( rule__Artifact__NameAssignment_2 ) ) + // InternalRosParser.g:3803:1: ( ( RULE_END ) ) + // InternalRosParser.g:3804:1: ( RULE_END ) { - // InternalRos.g:3740:1: ( ( rule__Artifact__NameAssignment_2 ) ) - // InternalRos.g:3741:2: ( rule__Artifact__NameAssignment_2 ) + // InternalRosParser.g:3804:1: ( RULE_END ) + // InternalRosParser.g:3805:2: RULE_END { - before(grammarAccess.getArtifactAccess().getNameAssignment_2()); - // InternalRos.g:3742:2: ( rule__Artifact__NameAssignment_2 ) - // InternalRos.g:3742:3: rule__Artifact__NameAssignment_2 + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_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_3_0__0" + // InternalRosParser.g:3815:1: rule__Node__Group_3_0__0 : rule__Node__Group_3_0__0__Impl rule__Node__Group_3_0__1 ; + public final void rule__Node__Group_3_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:3819:1: ( rule__Node__Group_3_0__0__Impl rule__Node__Group_3_0__1 ) + // InternalRosParser.g:3820:2: rule__Node__Group_3_0__0__Impl rule__Node__Group_3_0__1 { + pushFollow(FOLLOW_6); + rule__Node__Group_3_0__0__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Artifact__NameAssignment_2(); + rule__Node__Group_3_0__1(); state._fsp--; } - after(grammarAccess.getArtifactAccess().getNameAssignment_2()); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__0" + + + // $ANTLR start "rule__Node__Group_3_0__0__Impl" + // InternalRosParser.g:3827:1: rule__Node__Group_3_0__0__Impl : ( Publishers ) ; + public final void rule__Node__Group_3_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:3831:1: ( ( Publishers ) ) + // InternalRosParser.g:3832:1: ( Publishers ) + { + // InternalRosParser.g:3832:1: ( Publishers ) + // InternalRosParser.g:3833:2: Publishers + { + before(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); + match(input,Publishers,FOLLOW_2); + after(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); } @@ -11747,26 +11904,26 @@ public final void rule__Artifact__Group__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__2__Impl" + // $ANTLR end "rule__Node__Group_3_0__0__Impl" - // $ANTLR start "rule__Artifact__Group__3" - // InternalRos.g:3750:1: rule__Artifact__Group__3 : rule__Artifact__Group__3__Impl rule__Artifact__Group__4 ; - public final void rule__Artifact__Group__3() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_0__1" + // InternalRosParser.g:3842:1: rule__Node__Group_3_0__1 : rule__Node__Group_3_0__1__Impl rule__Node__Group_3_0__2 ; + public final void rule__Node__Group_3_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3754:1: ( rule__Artifact__Group__3__Impl rule__Artifact__Group__4 ) - // InternalRos.g:3755:2: rule__Artifact__Group__3__Impl rule__Artifact__Group__4 + // InternalRosParser.g:3846:1: ( rule__Node__Group_3_0__1__Impl rule__Node__Group_3_0__2 ) + // InternalRosParser.g:3847:2: rule__Node__Group_3_0__1__Impl rule__Node__Group_3_0__2 { - pushFollow(FOLLOW_16); - rule__Artifact__Group__3__Impl(); + pushFollow(FOLLOW_18); + rule__Node__Group_3_0__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Artifact__Group__4(); + rule__Node__Group_3_0__2(); state._fsp--; @@ -11785,25 +11942,25 @@ public final void rule__Artifact__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__3" + // $ANTLR end "rule__Node__Group_3_0__1" - // $ANTLR start "rule__Artifact__Group__3__Impl" - // InternalRos.g:3762:1: rule__Artifact__Group__3__Impl : ( '{' ) ; - public final void rule__Artifact__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_0__1__Impl" + // InternalRosParser.g:3854:1: rule__Node__Group_3_0__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3766:1: ( ( '{' ) ) - // InternalRos.g:3767:1: ( '{' ) + // InternalRosParser.g:3858:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:3859:1: ( RULE_BEGIN ) { - // InternalRos.g:3767:1: ( '{' ) - // InternalRos.g:3768:2: '{' + // InternalRosParser.g:3859:1: ( RULE_BEGIN ) + // InternalRosParser.g:3860:2: RULE_BEGIN { - before(grammarAccess.getArtifactAccess().getLeftCurlyBracketKeyword_3()); - match(input,41,FOLLOW_2); - after(grammarAccess.getArtifactAccess().getLeftCurlyBracketKeyword_3()); + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); } @@ -11822,26 +11979,26 @@ public final void rule__Artifact__Group__3__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__3__Impl" + // $ANTLR end "rule__Node__Group_3_0__1__Impl" - // $ANTLR start "rule__Artifact__Group__4" - // InternalRos.g:3777:1: rule__Artifact__Group__4 : rule__Artifact__Group__4__Impl rule__Artifact__Group__5 ; - public final void rule__Artifact__Group__4() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_0__2" + // InternalRosParser.g:3869:1: rule__Node__Group_3_0__2 : rule__Node__Group_3_0__2__Impl rule__Node__Group_3_0__3 ; + public final void rule__Node__Group_3_0__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3781:1: ( rule__Artifact__Group__4__Impl rule__Artifact__Group__5 ) - // InternalRos.g:3782:2: rule__Artifact__Group__4__Impl rule__Artifact__Group__5 + // InternalRosParser.g:3873:1: ( rule__Node__Group_3_0__2__Impl rule__Node__Group_3_0__3 ) + // InternalRosParser.g:3874:2: rule__Node__Group_3_0__2__Impl rule__Node__Group_3_0__3 { - pushFollow(FOLLOW_16); - rule__Artifact__Group__4__Impl(); + pushFollow(FOLLOW_18); + rule__Node__Group_3_0__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Artifact__Group__5(); + rule__Node__Group_3_0__3(); state._fsp--; @@ -11860,46 +12017,53 @@ public final void rule__Artifact__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__4" + // $ANTLR end "rule__Node__Group_3_0__2" - // $ANTLR start "rule__Artifact__Group__4__Impl" - // InternalRos.g:3789:1: rule__Artifact__Group__4__Impl : ( ( rule__Artifact__NodeAssignment_4 )? ) ; - public final void rule__Artifact__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_0__2__Impl" + // InternalRosParser.g:3881:1: rule__Node__Group_3_0__2__Impl : ( ( rule__Node__PublisherAssignment_3_0_2 )* ) ; + public final void rule__Node__Group_3_0__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3793:1: ( ( ( rule__Artifact__NodeAssignment_4 )? ) ) - // InternalRos.g:3794:1: ( ( rule__Artifact__NodeAssignment_4 )? ) + // InternalRosParser.g:3885:1: ( ( ( rule__Node__PublisherAssignment_3_0_2 )* ) ) + // InternalRosParser.g:3886:1: ( ( rule__Node__PublisherAssignment_3_0_2 )* ) { - // InternalRos.g:3794:1: ( ( rule__Artifact__NodeAssignment_4 )? ) - // InternalRos.g:3795:2: ( rule__Artifact__NodeAssignment_4 )? + // InternalRosParser.g:3886:1: ( ( rule__Node__PublisherAssignment_3_0_2 )* ) + // InternalRosParser.g:3887:2: ( rule__Node__PublisherAssignment_3_0_2 )* { - before(grammarAccess.getArtifactAccess().getNodeAssignment_4()); - // InternalRos.g:3796:2: ( rule__Artifact__NodeAssignment_4 )? - int alt20=2; - int LA20_0 = input.LA(1); + before(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); + // InternalRosParser.g:3888:2: ( rule__Node__PublisherAssignment_3_0_2 )* + loop21: + do { + int alt21=2; + int LA21_0 = input.LA(1); - if ( (LA20_0==56) ) { - alt20=1; - } - switch (alt20) { - case 1 : - // InternalRos.g:3796:3: rule__Artifact__NodeAssignment_4 - { - pushFollow(FOLLOW_2); - rule__Artifact__NodeAssignment_4(); + if ( (LA21_0==RULE_ID||LA21_0==RULE_STRING) ) { + alt21=1; + } - state._fsp--; + switch (alt21) { + case 1 : + // InternalRosParser.g:3888:3: rule__Node__PublisherAssignment_3_0_2 + { + pushFollow(FOLLOW_19); + rule__Node__PublisherAssignment_3_0_2(); - } - break; + state._fsp--; - } - after(grammarAccess.getArtifactAccess().getNodeAssignment_4()); + } + break; + + default : + break loop21; + } + } while (true); + + after(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); } @@ -11918,21 +12082,21 @@ public final void rule__Artifact__Group__4__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__4__Impl" + // $ANTLR end "rule__Node__Group_3_0__2__Impl" - // $ANTLR start "rule__Artifact__Group__5" - // InternalRos.g:3804:1: rule__Artifact__Group__5 : rule__Artifact__Group__5__Impl ; - public final void rule__Artifact__Group__5() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_0__3" + // InternalRosParser.g:3896:1: rule__Node__Group_3_0__3 : rule__Node__Group_3_0__3__Impl ; + public final void rule__Node__Group_3_0__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3808:1: ( rule__Artifact__Group__5__Impl ) - // InternalRos.g:3809:2: rule__Artifact__Group__5__Impl + // InternalRosParser.g:3900:1: ( rule__Node__Group_3_0__3__Impl ) + // InternalRosParser.g:3901:2: rule__Node__Group_3_0__3__Impl { pushFollow(FOLLOW_2); - rule__Artifact__Group__5__Impl(); + rule__Node__Group_3_0__3__Impl(); state._fsp--; @@ -11951,25 +12115,25 @@ public final void rule__Artifact__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__5" + // $ANTLR end "rule__Node__Group_3_0__3" - // $ANTLR start "rule__Artifact__Group__5__Impl" - // InternalRos.g:3815:1: rule__Artifact__Group__5__Impl : ( '}' ) ; - public final void rule__Artifact__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_0__3__Impl" + // InternalRosParser.g:3907:1: rule__Node__Group_3_0__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_0__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3819:1: ( ( '}' ) ) - // InternalRos.g:3820:1: ( '}' ) + // InternalRosParser.g:3911:1: ( ( RULE_END ) ) + // InternalRosParser.g:3912:1: ( RULE_END ) { - // InternalRos.g:3820:1: ( '}' ) - // InternalRos.g:3821:2: '}' + // InternalRosParser.g:3912:1: ( RULE_END ) + // InternalRosParser.g:3913:2: RULE_END { - before(grammarAccess.getArtifactAccess().getRightCurlyBracketKeyword_5()); - match(input,42,FOLLOW_2); - after(grammarAccess.getArtifactAccess().getRightCurlyBracketKeyword_5()); + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); } @@ -11988,26 +12152,26 @@ public final void rule__Artifact__Group__5__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Artifact__Group__5__Impl" + // $ANTLR end "rule__Node__Group_3_0__3__Impl" - // $ANTLR start "rule__CatkinPackage__Group__0" - // InternalRos.g:3831:1: rule__CatkinPackage__Group__0 : rule__CatkinPackage__Group__0__Impl rule__CatkinPackage__Group__1 ; - public final void rule__CatkinPackage__Group__0() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_1__0" + // InternalRosParser.g:3923:1: rule__Node__Group_3_1__0 : rule__Node__Group_3_1__0__Impl rule__Node__Group_3_1__1 ; + public final void rule__Node__Group_3_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3835:1: ( rule__CatkinPackage__Group__0__Impl rule__CatkinPackage__Group__1 ) - // InternalRos.g:3836:2: rule__CatkinPackage__Group__0__Impl rule__CatkinPackage__Group__1 + // InternalRosParser.g:3927:1: ( rule__Node__Group_3_1__0__Impl rule__Node__Group_3_1__1 ) + // InternalRosParser.g:3928:2: rule__Node__Group_3_1__0__Impl rule__Node__Group_3_1__1 { - pushFollow(FOLLOW_17); - rule__CatkinPackage__Group__0__Impl(); + pushFollow(FOLLOW_6); + rule__Node__Group_3_1__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group__1(); + rule__Node__Group_3_1__1(); state._fsp--; @@ -12026,29 +12190,100 @@ public final void rule__CatkinPackage__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__CatkinPackage__Group__0" + // $ANTLR end "rule__Node__Group_3_1__0" - // $ANTLR start "rule__CatkinPackage__Group__0__Impl" - // InternalRos.g:3843:1: rule__CatkinPackage__Group__0__Impl : ( () ) ; - public final void rule__CatkinPackage__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_1__0__Impl" + // InternalRosParser.g:3935:1: rule__Node__Group_3_1__0__Impl : ( Subscribers ) ; + public final void rule__Node__Group_3_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3847:1: ( ( () ) ) - // InternalRos.g:3848:1: ( () ) + // InternalRosParser.g:3939:1: ( ( Subscribers ) ) + // InternalRosParser.g:3940:1: ( Subscribers ) { - // InternalRos.g:3848:1: ( () ) - // InternalRos.g:3849:2: () + // InternalRosParser.g:3940:1: ( Subscribers ) + // InternalRosParser.g:3941:2: Subscribers { - before(grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0()); - // InternalRos.g:3850:2: () - // InternalRos.g:3850:3: + before(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); + match(input,Subscribers,FOLLOW_2); + after(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_1__1" + // InternalRosParser.g:3950:1: rule__Node__Group_3_1__1 : rule__Node__Group_3_1__1__Impl rule__Node__Group_3_1__2 ; + public final void rule__Node__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:3954:1: ( rule__Node__Group_3_1__1__Impl rule__Node__Group_3_1__2 ) + // InternalRosParser.g:3955:2: rule__Node__Group_3_1__1__Impl rule__Node__Group_3_1__2 { + pushFollow(FOLLOW_18); + rule__Node__Group_3_1__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_1__2(); + + state._fsp--; + + } - after(grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0()); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__1" + + + // $ANTLR start "rule__Node__Group_3_1__1__Impl" + // InternalRosParser.g:3962:1: rule__Node__Group_3_1__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:3966:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:3967:1: ( RULE_BEGIN ) + { + // InternalRosParser.g:3967:1: ( RULE_BEGIN ) + // InternalRosParser.g:3968:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); } @@ -12056,6 +12291,10 @@ public final void rule__CatkinPackage__Group__0__Impl() throws RecognitionExcept } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -12063,26 +12302,26 @@ public final void rule__CatkinPackage__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__CatkinPackage__Group__0__Impl" + // $ANTLR end "rule__Node__Group_3_1__1__Impl" - // $ANTLR start "rule__CatkinPackage__Group__1" - // InternalRos.g:3858:1: rule__CatkinPackage__Group__1 : rule__CatkinPackage__Group__1__Impl rule__CatkinPackage__Group__2 ; - public final void rule__CatkinPackage__Group__1() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_1__2" + // InternalRosParser.g:3977:1: rule__Node__Group_3_1__2 : rule__Node__Group_3_1__2__Impl rule__Node__Group_3_1__3 ; + public final void rule__Node__Group_3_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3862:1: ( rule__CatkinPackage__Group__1__Impl rule__CatkinPackage__Group__2 ) - // InternalRos.g:3863:2: rule__CatkinPackage__Group__1__Impl rule__CatkinPackage__Group__2 + // InternalRosParser.g:3981:1: ( rule__Node__Group_3_1__2__Impl rule__Node__Group_3_1__3 ) + // InternalRosParser.g:3982:2: rule__Node__Group_3_1__2__Impl rule__Node__Group_3_1__3 { - pushFollow(FOLLOW_15); - rule__CatkinPackage__Group__1__Impl(); + pushFollow(FOLLOW_18); + rule__Node__Group_3_1__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group__2(); + rule__Node__Group_3_1__3(); state._fsp--; @@ -12101,25 +12340,53 @@ public final void rule__CatkinPackage__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__CatkinPackage__Group__1" + // $ANTLR end "rule__Node__Group_3_1__2" - // $ANTLR start "rule__CatkinPackage__Group__1__Impl" - // InternalRos.g:3870:1: rule__CatkinPackage__Group__1__Impl : ( 'CatkinPackage' ) ; - public final void rule__CatkinPackage__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_1__2__Impl" + // InternalRosParser.g:3989:1: rule__Node__Group_3_1__2__Impl : ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) ; + public final void rule__Node__Group_3_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3874:1: ( ( 'CatkinPackage' ) ) - // InternalRos.g:3875:1: ( 'CatkinPackage' ) + // InternalRosParser.g:3993:1: ( ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) ) + // InternalRosParser.g:3994:1: ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) { - // InternalRos.g:3875:1: ( 'CatkinPackage' ) - // InternalRos.g:3876:2: 'CatkinPackage' + // InternalRosParser.g:3994:1: ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) + // InternalRosParser.g:3995:2: ( rule__Node__SubscriberAssignment_3_1_2 )* { - before(grammarAccess.getCatkinPackageAccess().getCatkinPackageKeyword_1()); - match(input,48,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getCatkinPackageKeyword_1()); + before(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); + // InternalRosParser.g:3996:2: ( rule__Node__SubscriberAssignment_3_1_2 )* + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( (LA22_0==RULE_ID||LA22_0==RULE_STRING) ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalRosParser.g:3996:3: rule__Node__SubscriberAssignment_3_1_2 + { + pushFollow(FOLLOW_19); + rule__Node__SubscriberAssignment_3_1_2(); + + state._fsp--; + + + } + break; + + default : + break loop22; + } + } while (true); + + after(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); } @@ -12138,26 +12405,21 @@ public final void rule__CatkinPackage__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__CatkinPackage__Group__1__Impl" + // $ANTLR end "rule__Node__Group_3_1__2__Impl" - // $ANTLR start "rule__CatkinPackage__Group__2" - // InternalRos.g:3885:1: rule__CatkinPackage__Group__2 : rule__CatkinPackage__Group__2__Impl rule__CatkinPackage__Group__3 ; - public final void rule__CatkinPackage__Group__2() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_1__3" + // InternalRosParser.g:4004:1: rule__Node__Group_3_1__3 : rule__Node__Group_3_1__3__Impl ; + public final void rule__Node__Group_3_1__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3889:1: ( rule__CatkinPackage__Group__2__Impl rule__CatkinPackage__Group__3 ) - // InternalRos.g:3890:2: rule__CatkinPackage__Group__2__Impl rule__CatkinPackage__Group__3 + // InternalRosParser.g:4008:1: ( rule__Node__Group_3_1__3__Impl ) + // InternalRosParser.g:4009:2: rule__Node__Group_3_1__3__Impl { - pushFollow(FOLLOW_4); - rule__CatkinPackage__Group__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__CatkinPackage__Group__3(); + rule__Node__Group_3_1__3__Impl(); state._fsp--; @@ -12176,35 +12438,25 @@ public final void rule__CatkinPackage__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__CatkinPackage__Group__2" + // $ANTLR end "rule__Node__Group_3_1__3" - // $ANTLR start "rule__CatkinPackage__Group__2__Impl" - // InternalRos.g:3897:1: rule__CatkinPackage__Group__2__Impl : ( ( rule__CatkinPackage__NameAssignment_2 ) ) ; - public final void rule__CatkinPackage__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_1__3__Impl" + // InternalRosParser.g:4015:1: rule__Node__Group_3_1__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_1__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3901:1: ( ( ( rule__CatkinPackage__NameAssignment_2 ) ) ) - // InternalRos.g:3902:1: ( ( rule__CatkinPackage__NameAssignment_2 ) ) + // InternalRosParser.g:4019:1: ( ( RULE_END ) ) + // InternalRosParser.g:4020:1: ( RULE_END ) { - // InternalRos.g:3902:1: ( ( rule__CatkinPackage__NameAssignment_2 ) ) - // InternalRos.g:3903:2: ( rule__CatkinPackage__NameAssignment_2 ) + // InternalRosParser.g:4020:1: ( RULE_END ) + // InternalRosParser.g:4021:2: RULE_END { - before(grammarAccess.getCatkinPackageAccess().getNameAssignment_2()); - // InternalRos.g:3904:2: ( rule__CatkinPackage__NameAssignment_2 ) - // InternalRos.g:3904:3: rule__CatkinPackage__NameAssignment_2 - { - pushFollow(FOLLOW_2); - rule__CatkinPackage__NameAssignment_2(); - - state._fsp--; - - - } - - after(grammarAccess.getCatkinPackageAccess().getNameAssignment_2()); + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); } @@ -12223,26 +12475,26 @@ public final void rule__CatkinPackage__Group__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__CatkinPackage__Group__2__Impl" + // $ANTLR end "rule__Node__Group_3_1__3__Impl" - // $ANTLR start "rule__CatkinPackage__Group__3" - // InternalRos.g:3912:1: rule__CatkinPackage__Group__3 : rule__CatkinPackage__Group__3__Impl rule__CatkinPackage__Group__4 ; - public final void rule__CatkinPackage__Group__3() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_2__0" + // InternalRosParser.g:4031:1: rule__Node__Group_3_2__0 : rule__Node__Group_3_2__0__Impl rule__Node__Group_3_2__1 ; + public final void rule__Node__Group_3_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3916:1: ( rule__CatkinPackage__Group__3__Impl rule__CatkinPackage__Group__4 ) - // InternalRos.g:3917:2: rule__CatkinPackage__Group__3__Impl rule__CatkinPackage__Group__4 + // InternalRosParser.g:4035:1: ( rule__Node__Group_3_2__0__Impl rule__Node__Group_3_2__1 ) + // InternalRosParser.g:4036:2: rule__Node__Group_3_2__0__Impl rule__Node__Group_3_2__1 { - pushFollow(FOLLOW_18); - rule__CatkinPackage__Group__3__Impl(); + pushFollow(FOLLOW_6); + rule__Node__Group_3_2__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group__4(); + rule__Node__Group_3_2__1(); state._fsp--; @@ -12261,25 +12513,25 @@ public final void rule__CatkinPackage__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__CatkinPackage__Group__3" + // $ANTLR end "rule__Node__Group_3_2__0" - // $ANTLR start "rule__CatkinPackage__Group__3__Impl" - // InternalRos.g:3924:1: rule__CatkinPackage__Group__3__Impl : ( '{' ) ; - public final void rule__CatkinPackage__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_2__0__Impl" + // InternalRosParser.g:4043:1: rule__Node__Group_3_2__0__Impl : ( Serviceserver ) ; + public final void rule__Node__Group_3_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3928:1: ( ( '{' ) ) - // InternalRos.g:3929:1: ( '{' ) + // InternalRosParser.g:4047:1: ( ( Serviceserver ) ) + // InternalRosParser.g:4048:1: ( Serviceserver ) { - // InternalRos.g:3929:1: ( '{' ) - // InternalRos.g:3930:2: '{' + // InternalRosParser.g:4048:1: ( Serviceserver ) + // InternalRosParser.g:4049:2: Serviceserver { - before(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_3()); - match(input,41,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_3()); + before(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); + match(input,Serviceserver,FOLLOW_2); + after(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); } @@ -12298,26 +12550,26 @@ public final void rule__CatkinPackage__Group__3__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__CatkinPackage__Group__3__Impl" + // $ANTLR end "rule__Node__Group_3_2__0__Impl" - // $ANTLR start "rule__CatkinPackage__Group__4" - // InternalRos.g:3939:1: rule__CatkinPackage__Group__4 : rule__CatkinPackage__Group__4__Impl rule__CatkinPackage__Group__5 ; - public final void rule__CatkinPackage__Group__4() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_2__1" + // InternalRosParser.g:4058:1: rule__Node__Group_3_2__1 : rule__Node__Group_3_2__1__Impl rule__Node__Group_3_2__2 ; + public final void rule__Node__Group_3_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3943:1: ( rule__CatkinPackage__Group__4__Impl rule__CatkinPackage__Group__5 ) - // InternalRos.g:3944:2: rule__CatkinPackage__Group__4__Impl rule__CatkinPackage__Group__5 + // InternalRosParser.g:4062:1: ( rule__Node__Group_3_2__1__Impl rule__Node__Group_3_2__2 ) + // InternalRosParser.g:4063:2: rule__Node__Group_3_2__1__Impl rule__Node__Group_3_2__2 { pushFollow(FOLLOW_18); - rule__CatkinPackage__Group__4__Impl(); + rule__Node__Group_3_2__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group__5(); + rule__Node__Group_3_2__2(); state._fsp--; @@ -12336,46 +12588,25 @@ public final void rule__CatkinPackage__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__CatkinPackage__Group__4" + // $ANTLR end "rule__Node__Group_3_2__1" - // $ANTLR start "rule__CatkinPackage__Group__4__Impl" - // InternalRos.g:3951:1: rule__CatkinPackage__Group__4__Impl : ( ( rule__CatkinPackage__Group_4__0 )? ) ; - public final void rule__CatkinPackage__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_2__1__Impl" + // InternalRosParser.g:4070:1: rule__Node__Group_3_2__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3955:1: ( ( ( rule__CatkinPackage__Group_4__0 )? ) ) - // InternalRos.g:3956:1: ( ( rule__CatkinPackage__Group_4__0 )? ) + // InternalRosParser.g:4074:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:4075:1: ( RULE_BEGIN ) { - // InternalRos.g:3956:1: ( ( rule__CatkinPackage__Group_4__0 )? ) - // InternalRos.g:3957:2: ( rule__CatkinPackage__Group_4__0 )? + // InternalRosParser.g:4075:1: ( RULE_BEGIN ) + // InternalRosParser.g:4076:2: RULE_BEGIN { - before(grammarAccess.getCatkinPackageAccess().getGroup_4()); - // InternalRos.g:3958:2: ( rule__CatkinPackage__Group_4__0 )? - int alt21=2; - int LA21_0 = input.LA(1); - - if ( (LA21_0==45) ) { - alt21=1; - } - switch (alt21) { - case 1 : - // InternalRos.g:3958:3: rule__CatkinPackage__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_4__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getCatkinPackageAccess().getGroup_4()); + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); } @@ -12394,26 +12625,26 @@ public final void rule__CatkinPackage__Group__4__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__CatkinPackage__Group__4__Impl" + // $ANTLR end "rule__Node__Group_3_2__1__Impl" - // $ANTLR start "rule__CatkinPackage__Group__5" - // InternalRos.g:3966:1: rule__CatkinPackage__Group__5 : rule__CatkinPackage__Group__5__Impl rule__CatkinPackage__Group__6 ; - public final void rule__CatkinPackage__Group__5() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_2__2" + // InternalRosParser.g:4085:1: rule__Node__Group_3_2__2 : rule__Node__Group_3_2__2__Impl rule__Node__Group_3_2__3 ; + public final void rule__Node__Group_3_2__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3970:1: ( rule__CatkinPackage__Group__5__Impl rule__CatkinPackage__Group__6 ) - // InternalRos.g:3971:2: rule__CatkinPackage__Group__5__Impl rule__CatkinPackage__Group__6 + // InternalRosParser.g:4089:1: ( rule__Node__Group_3_2__2__Impl rule__Node__Group_3_2__3 ) + // InternalRosParser.g:4090:2: rule__Node__Group_3_2__2__Impl rule__Node__Group_3_2__3 { pushFollow(FOLLOW_18); - rule__CatkinPackage__Group__5__Impl(); + rule__Node__Group_3_2__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group__6(); + rule__Node__Group_3_2__3(); state._fsp--; @@ -12432,46 +12663,53 @@ public final void rule__CatkinPackage__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__CatkinPackage__Group__5" + // $ANTLR end "rule__Node__Group_3_2__2" - // $ANTLR start "rule__CatkinPackage__Group__5__Impl" - // InternalRos.g:3978:1: rule__CatkinPackage__Group__5__Impl : ( ( rule__CatkinPackage__Group_5__0 )? ) ; - public final void rule__CatkinPackage__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_2__2__Impl" + // InternalRosParser.g:4097:1: rule__Node__Group_3_2__2__Impl : ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) ; + public final void rule__Node__Group_3_2__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3982:1: ( ( ( rule__CatkinPackage__Group_5__0 )? ) ) - // InternalRos.g:3983:1: ( ( rule__CatkinPackage__Group_5__0 )? ) + // InternalRosParser.g:4101:1: ( ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) ) + // InternalRosParser.g:4102:1: ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) { - // InternalRos.g:3983:1: ( ( rule__CatkinPackage__Group_5__0 )? ) - // InternalRos.g:3984:2: ( rule__CatkinPackage__Group_5__0 )? + // InternalRosParser.g:4102:1: ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) + // InternalRosParser.g:4103:2: ( rule__Node__ServiceserverAssignment_3_2_2 )* { - before(grammarAccess.getCatkinPackageAccess().getGroup_5()); - // InternalRos.g:3985:2: ( rule__CatkinPackage__Group_5__0 )? - int alt22=2; - int LA22_0 = input.LA(1); + before(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); + // InternalRosParser.g:4104:2: ( rule__Node__ServiceserverAssignment_3_2_2 )* + loop23: + do { + int alt23=2; + int LA23_0 = input.LA(1); - if ( (LA22_0==49) ) { - alt22=1; - } - switch (alt22) { - case 1 : - // InternalRos.g:3985:3: rule__CatkinPackage__Group_5__0 - { - pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_5__0(); + if ( (LA23_0==RULE_ID||LA23_0==RULE_STRING) ) { + alt23=1; + } - state._fsp--; + switch (alt23) { + case 1 : + // InternalRosParser.g:4104:3: rule__Node__ServiceserverAssignment_3_2_2 + { + pushFollow(FOLLOW_19); + rule__Node__ServiceserverAssignment_3_2_2(); - } - break; + state._fsp--; - } - after(grammarAccess.getCatkinPackageAccess().getGroup_5()); + } + break; + + default : + break loop23; + } + } while (true); + + after(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); } @@ -12490,26 +12728,21 @@ public final void rule__CatkinPackage__Group__5__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__CatkinPackage__Group__5__Impl" + // $ANTLR end "rule__Node__Group_3_2__2__Impl" - // $ANTLR start "rule__CatkinPackage__Group__6" - // InternalRos.g:3993:1: rule__CatkinPackage__Group__6 : rule__CatkinPackage__Group__6__Impl rule__CatkinPackage__Group__7 ; - public final void rule__CatkinPackage__Group__6() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_2__3" + // InternalRosParser.g:4112:1: rule__Node__Group_3_2__3 : rule__Node__Group_3_2__3__Impl ; + public final void rule__Node__Group_3_2__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:3997:1: ( rule__CatkinPackage__Group__6__Impl rule__CatkinPackage__Group__7 ) - // InternalRos.g:3998:2: rule__CatkinPackage__Group__6__Impl rule__CatkinPackage__Group__7 + // InternalRosParser.g:4116:1: ( rule__Node__Group_3_2__3__Impl ) + // InternalRosParser.g:4117:2: rule__Node__Group_3_2__3__Impl { - pushFollow(FOLLOW_18); - rule__CatkinPackage__Group__6__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__CatkinPackage__Group__7(); + rule__Node__Group_3_2__3__Impl(); state._fsp--; @@ -12528,46 +12761,25 @@ public final void rule__CatkinPackage__Group__6() throws RecognitionException { } return ; } - // $ANTLR end "rule__CatkinPackage__Group__6" + // $ANTLR end "rule__Node__Group_3_2__3" - // $ANTLR start "rule__CatkinPackage__Group__6__Impl" - // InternalRos.g:4005:1: rule__CatkinPackage__Group__6__Impl : ( ( rule__CatkinPackage__Group_6__0 )? ) ; - public final void rule__CatkinPackage__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_2__3__Impl" + // InternalRosParser.g:4123:1: rule__Node__Group_3_2__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_2__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4009:1: ( ( ( rule__CatkinPackage__Group_6__0 )? ) ) - // InternalRos.g:4010:1: ( ( rule__CatkinPackage__Group_6__0 )? ) + // InternalRosParser.g:4127:1: ( ( RULE_END ) ) + // InternalRosParser.g:4128:1: ( RULE_END ) { - // InternalRos.g:4010:1: ( ( rule__CatkinPackage__Group_6__0 )? ) - // InternalRos.g:4011:2: ( rule__CatkinPackage__Group_6__0 )? + // InternalRosParser.g:4128:1: ( RULE_END ) + // InternalRosParser.g:4129:2: RULE_END { - before(grammarAccess.getCatkinPackageAccess().getGroup_6()); - // InternalRos.g:4012:2: ( rule__CatkinPackage__Group_6__0 )? - int alt23=2; - int LA23_0 = input.LA(1); - - if ( (LA23_0==46) ) { - alt23=1; - } - switch (alt23) { - case 1 : - // InternalRos.g:4012:3: rule__CatkinPackage__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_6__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getCatkinPackageAccess().getGroup_6()); + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); } @@ -12586,26 +12798,26 @@ public final void rule__CatkinPackage__Group__6__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__CatkinPackage__Group__6__Impl" + // $ANTLR end "rule__Node__Group_3_2__3__Impl" - // $ANTLR start "rule__CatkinPackage__Group__7" - // InternalRos.g:4020:1: rule__CatkinPackage__Group__7 : rule__CatkinPackage__Group__7__Impl rule__CatkinPackage__Group__8 ; - public final void rule__CatkinPackage__Group__7() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_3__0" + // InternalRosParser.g:4139:1: rule__Node__Group_3_3__0 : rule__Node__Group_3_3__0__Impl rule__Node__Group_3_3__1 ; + public final void rule__Node__Group_3_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4024:1: ( rule__CatkinPackage__Group__7__Impl rule__CatkinPackage__Group__8 ) - // InternalRos.g:4025:2: rule__CatkinPackage__Group__7__Impl rule__CatkinPackage__Group__8 + // InternalRosParser.g:4143:1: ( rule__Node__Group_3_3__0__Impl rule__Node__Group_3_3__1 ) + // InternalRosParser.g:4144:2: rule__Node__Group_3_3__0__Impl rule__Node__Group_3_3__1 { - pushFollow(FOLLOW_18); - rule__CatkinPackage__Group__7__Impl(); + pushFollow(FOLLOW_6); + rule__Node__Group_3_3__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group__8(); + rule__Node__Group_3_3__1(); state._fsp--; @@ -12624,46 +12836,25 @@ public final void rule__CatkinPackage__Group__7() throws RecognitionException { } return ; } - // $ANTLR end "rule__CatkinPackage__Group__7" + // $ANTLR end "rule__Node__Group_3_3__0" - // $ANTLR start "rule__CatkinPackage__Group__7__Impl" - // InternalRos.g:4032:1: rule__CatkinPackage__Group__7__Impl : ( ( rule__CatkinPackage__Group_7__0 )? ) ; - public final void rule__CatkinPackage__Group__7__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_3__0__Impl" + // InternalRosParser.g:4151:1: rule__Node__Group_3_3__0__Impl : ( Serviceclient ) ; + public final void rule__Node__Group_3_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4036:1: ( ( ( rule__CatkinPackage__Group_7__0 )? ) ) - // InternalRos.g:4037:1: ( ( rule__CatkinPackage__Group_7__0 )? ) + // InternalRosParser.g:4155:1: ( ( Serviceclient ) ) + // InternalRosParser.g:4156:1: ( Serviceclient ) { - // InternalRos.g:4037:1: ( ( rule__CatkinPackage__Group_7__0 )? ) - // InternalRos.g:4038:2: ( rule__CatkinPackage__Group_7__0 )? + // InternalRosParser.g:4156:1: ( Serviceclient ) + // InternalRosParser.g:4157:2: Serviceclient { - before(grammarAccess.getCatkinPackageAccess().getGroup_7()); - // InternalRos.g:4039:2: ( rule__CatkinPackage__Group_7__0 )? - int alt24=2; - int LA24_0 = input.LA(1); - - if ( (LA24_0==47) ) { - alt24=1; - } - switch (alt24) { - case 1 : - // InternalRos.g:4039:3: rule__CatkinPackage__Group_7__0 - { - pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_7__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getCatkinPackageAccess().getGroup_7()); + before(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); + match(input,Serviceclient,FOLLOW_2); + after(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); } @@ -12682,21 +12873,26 @@ public final void rule__CatkinPackage__Group__7__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__CatkinPackage__Group__7__Impl" + // $ANTLR end "rule__Node__Group_3_3__0__Impl" - // $ANTLR start "rule__CatkinPackage__Group__8" - // InternalRos.g:4047:1: rule__CatkinPackage__Group__8 : rule__CatkinPackage__Group__8__Impl ; - public final void rule__CatkinPackage__Group__8() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_3__1" + // InternalRosParser.g:4166:1: rule__Node__Group_3_3__1 : rule__Node__Group_3_3__1__Impl rule__Node__Group_3_3__2 ; + public final void rule__Node__Group_3_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4051:1: ( rule__CatkinPackage__Group__8__Impl ) - // InternalRos.g:4052:2: rule__CatkinPackage__Group__8__Impl + // InternalRosParser.g:4170:1: ( rule__Node__Group_3_3__1__Impl rule__Node__Group_3_3__2 ) + // InternalRosParser.g:4171:2: rule__Node__Group_3_3__1__Impl rule__Node__Group_3_3__2 { + pushFollow(FOLLOW_18); + rule__Node__Group_3_3__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__CatkinPackage__Group__8__Impl(); + rule__Node__Group_3_3__2(); state._fsp--; @@ -12715,25 +12911,25 @@ public final void rule__CatkinPackage__Group__8() throws RecognitionException { } return ; } - // $ANTLR end "rule__CatkinPackage__Group__8" + // $ANTLR end "rule__Node__Group_3_3__1" - // $ANTLR start "rule__CatkinPackage__Group__8__Impl" - // InternalRos.g:4058:1: rule__CatkinPackage__Group__8__Impl : ( '}' ) ; - public final void rule__CatkinPackage__Group__8__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_3__1__Impl" + // InternalRosParser.g:4178:1: rule__Node__Group_3_3__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4062:1: ( ( '}' ) ) - // InternalRos.g:4063:1: ( '}' ) + // InternalRosParser.g:4182:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:4183:1: ( RULE_BEGIN ) { - // InternalRos.g:4063:1: ( '}' ) - // InternalRos.g:4064:2: '}' + // InternalRosParser.g:4183:1: ( RULE_BEGIN ) + // InternalRosParser.g:4184:2: RULE_BEGIN { - before(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_8()); - match(input,42,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_8()); + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); } @@ -12752,26 +12948,26 @@ public final void rule__CatkinPackage__Group__8__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__CatkinPackage__Group__8__Impl" + // $ANTLR end "rule__Node__Group_3_3__1__Impl" - // $ANTLR start "rule__CatkinPackage__Group_4__0" - // InternalRos.g:4074: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 { + // $ANTLR start "rule__Node__Group_3_3__2" + // InternalRosParser.g:4193:1: rule__Node__Group_3_3__2 : rule__Node__Group_3_3__2__Impl rule__Node__Group_3_3__3 ; + public final void rule__Node__Group_3_3__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4078:1: ( rule__CatkinPackage__Group_4__0__Impl rule__CatkinPackage__Group_4__1 ) - // InternalRos.g:4079:2: rule__CatkinPackage__Group_4__0__Impl rule__CatkinPackage__Group_4__1 + // InternalRosParser.g:4197:1: ( rule__Node__Group_3_3__2__Impl rule__Node__Group_3_3__3 ) + // InternalRosParser.g:4198:2: rule__Node__Group_3_3__2__Impl rule__Node__Group_3_3__3 { - pushFollow(FOLLOW_10); - rule__CatkinPackage__Group_4__0__Impl(); + pushFollow(FOLLOW_18); + rule__Node__Group_3_3__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_4__1(); + rule__Node__Group_3_3__3(); state._fsp--; @@ -12790,105 +12986,53 @@ public final void rule__CatkinPackage__Group_4__0() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_4__0" + // $ANTLR end "rule__Node__Group_3_3__2" - // $ANTLR start "rule__CatkinPackage__Group_4__0__Impl" - // InternalRos.g:4086:1: rule__CatkinPackage__Group_4__0__Impl : ( 'FromGitRepo' ) ; - public final void rule__CatkinPackage__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_3__2__Impl" + // InternalRosParser.g:4205:1: rule__Node__Group_3_3__2__Impl : ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) ; + public final void rule__Node__Group_3_3__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4090:1: ( ( 'FromGitRepo' ) ) - // InternalRos.g:4091:1: ( 'FromGitRepo' ) - { - // InternalRos.g:4091:1: ( 'FromGitRepo' ) - // InternalRos.g:4092:2: 'FromGitRepo' + // InternalRosParser.g:4209:1: ( ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) ) + // InternalRosParser.g:4210:1: ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) { - before(grammarAccess.getCatkinPackageAccess().getFromGitRepoKeyword_4_0()); - match(input,45,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" - // InternalRos.g:4101: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 { - // InternalRos.g:4105:1: ( rule__CatkinPackage__Group_4__1__Impl ) - // InternalRos.g:4106:2: rule__CatkinPackage__Group_4__1__Impl + // InternalRosParser.g:4210:1: ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) + // InternalRosParser.g:4211:2: ( rule__Node__ServiceclientAssignment_3_3_2 )* { - pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_4__1__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + before(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); + // InternalRosParser.g:4212:2: ( rule__Node__ServiceclientAssignment_3_3_2 )* + loop24: + do { + int alt24=2; + int LA24_0 = input.LA(1); - } - return ; - } - // $ANTLR end "rule__CatkinPackage__Group_4__1" + if ( (LA24_0==RULE_ID||LA24_0==RULE_STRING) ) { + alt24=1; + } - // $ANTLR start "rule__CatkinPackage__Group_4__1__Impl" - // InternalRos.g:4112:1: rule__CatkinPackage__Group_4__1__Impl : ( ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) ) ; - public final void rule__CatkinPackage__Group_4__1__Impl() throws RecognitionException { + switch (alt24) { + case 1 : + // InternalRosParser.g:4212:3: rule__Node__ServiceclientAssignment_3_3_2 + { + pushFollow(FOLLOW_19); + rule__Node__ServiceclientAssignment_3_3_2(); - int stackSize = keepStackSize(); - - try { - // InternalRos.g:4116:1: ( ( ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) ) ) - // InternalRos.g:4117:1: ( ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) ) - { - // InternalRos.g:4117:1: ( ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) ) - // InternalRos.g:4118:2: ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) - { - before(grammarAccess.getCatkinPackageAccess().getFromGitRepoAssignment_4_1()); - // InternalRos.g:4119:2: ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) - // InternalRos.g:4119:3: rule__CatkinPackage__FromGitRepoAssignment_4_1 - { - pushFollow(FOLLOW_2); - rule__CatkinPackage__FromGitRepoAssignment_4_1(); + state._fsp--; - state._fsp--; + } + break; - } + default : + break loop24; + } + } while (true); - after(grammarAccess.getCatkinPackageAccess().getFromGitRepoAssignment_4_1()); + after(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); } @@ -12907,26 +13051,21 @@ public final void rule__CatkinPackage__Group_4__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_4__1__Impl" + // $ANTLR end "rule__Node__Group_3_3__2__Impl" - // $ANTLR start "rule__CatkinPackage__Group_5__0" - // InternalRos.g:4128: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 { + // $ANTLR start "rule__Node__Group_3_3__3" + // InternalRosParser.g:4220:1: rule__Node__Group_3_3__3 : rule__Node__Group_3_3__3__Impl ; + public final void rule__Node__Group_3_3__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4132:1: ( rule__CatkinPackage__Group_5__0__Impl rule__CatkinPackage__Group_5__1 ) - // InternalRos.g:4133:2: rule__CatkinPackage__Group_5__0__Impl rule__CatkinPackage__Group_5__1 + // InternalRosParser.g:4224:1: ( rule__Node__Group_3_3__3__Impl ) + // InternalRosParser.g:4225:2: rule__Node__Group_3_3__3__Impl { - pushFollow(FOLLOW_4); - rule__CatkinPackage__Group_5__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_5__1(); + rule__Node__Group_3_3__3__Impl(); state._fsp--; @@ -12945,25 +13084,25 @@ public final void rule__CatkinPackage__Group_5__0() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5__0" + // $ANTLR end "rule__Node__Group_3_3__3" - // $ANTLR start "rule__CatkinPackage__Group_5__0__Impl" - // InternalRos.g:4140:1: rule__CatkinPackage__Group_5__0__Impl : ( 'Dependencies' ) ; - public final void rule__CatkinPackage__Group_5__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_3__3__Impl" + // InternalRosParser.g:4231:1: rule__Node__Group_3_3__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_3__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4144:1: ( ( 'Dependencies' ) ) - // InternalRos.g:4145:1: ( 'Dependencies' ) + // InternalRosParser.g:4235:1: ( ( RULE_END ) ) + // InternalRosParser.g:4236:1: ( RULE_END ) { - // InternalRos.g:4145:1: ( 'Dependencies' ) - // InternalRos.g:4146:2: 'Dependencies' + // InternalRosParser.g:4236:1: ( RULE_END ) + // InternalRosParser.g:4237:2: RULE_END { - before(grammarAccess.getCatkinPackageAccess().getDependenciesKeyword_5_0()); - match(input,49,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getDependenciesKeyword_5_0()); + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); } @@ -12982,26 +13121,26 @@ public final void rule__CatkinPackage__Group_5__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5__0__Impl" + // $ANTLR end "rule__Node__Group_3_3__3__Impl" - // $ANTLR start "rule__CatkinPackage__Group_5__1" - // InternalRos.g:4155: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 { + // $ANTLR start "rule__Node__Group_3_4__0" + // InternalRosParser.g:4247:1: rule__Node__Group_3_4__0 : rule__Node__Group_3_4__0__Impl rule__Node__Group_3_4__1 ; + public final void rule__Node__Group_3_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4159:1: ( rule__CatkinPackage__Group_5__1__Impl rule__CatkinPackage__Group_5__2 ) - // InternalRos.g:4160:2: rule__CatkinPackage__Group_5__1__Impl rule__CatkinPackage__Group_5__2 + // InternalRosParser.g:4251:1: ( rule__Node__Group_3_4__0__Impl rule__Node__Group_3_4__1 ) + // InternalRosParser.g:4252:2: rule__Node__Group_3_4__0__Impl rule__Node__Group_3_4__1 { - pushFollow(FOLLOW_19); - rule__CatkinPackage__Group_5__1__Impl(); + pushFollow(FOLLOW_6); + rule__Node__Group_3_4__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_5__2(); + rule__Node__Group_3_4__1(); state._fsp--; @@ -13020,25 +13159,25 @@ public final void rule__CatkinPackage__Group_5__1() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5__1" + // $ANTLR end "rule__Node__Group_3_4__0" - // $ANTLR start "rule__CatkinPackage__Group_5__1__Impl" - // InternalRos.g:4167:1: rule__CatkinPackage__Group_5__1__Impl : ( '{' ) ; - public final void rule__CatkinPackage__Group_5__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_4__0__Impl" + // InternalRosParser.g:4259:1: rule__Node__Group_3_4__0__Impl : ( Actionserver ) ; + public final void rule__Node__Group_3_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4171:1: ( ( '{' ) ) - // InternalRos.g:4172:1: ( '{' ) + // InternalRosParser.g:4263:1: ( ( Actionserver ) ) + // InternalRosParser.g:4264:1: ( Actionserver ) { - // InternalRos.g:4172:1: ( '{' ) - // InternalRos.g:4173:2: '{' + // InternalRosParser.g:4264:1: ( Actionserver ) + // InternalRosParser.g:4265:2: Actionserver { - before(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_5_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_5_1()); + before(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); + match(input,Actionserver,FOLLOW_2); + after(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); } @@ -13057,26 +13196,26 @@ public final void rule__CatkinPackage__Group_5__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5__1__Impl" + // $ANTLR end "rule__Node__Group_3_4__0__Impl" - // $ANTLR start "rule__CatkinPackage__Group_5__2" - // InternalRos.g:4182: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 { + // $ANTLR start "rule__Node__Group_3_4__1" + // InternalRosParser.g:4274:1: rule__Node__Group_3_4__1 : rule__Node__Group_3_4__1__Impl rule__Node__Group_3_4__2 ; + public final void rule__Node__Group_3_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4186:1: ( rule__CatkinPackage__Group_5__2__Impl rule__CatkinPackage__Group_5__3 ) - // InternalRos.g:4187:2: rule__CatkinPackage__Group_5__2__Impl rule__CatkinPackage__Group_5__3 + // InternalRosParser.g:4278:1: ( rule__Node__Group_3_4__1__Impl rule__Node__Group_3_4__2 ) + // InternalRosParser.g:4279:2: rule__Node__Group_3_4__1__Impl rule__Node__Group_3_4__2 { - pushFollow(FOLLOW_13); - rule__CatkinPackage__Group_5__2__Impl(); + pushFollow(FOLLOW_18); + rule__Node__Group_3_4__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_5__3(); + rule__Node__Group_3_4__2(); state._fsp--; @@ -13095,35 +13234,25 @@ public final void rule__CatkinPackage__Group_5__2() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5__2" + // $ANTLR end "rule__Node__Group_3_4__1" - // $ANTLR start "rule__CatkinPackage__Group_5__2__Impl" - // InternalRos.g:4194:1: rule__CatkinPackage__Group_5__2__Impl : ( ( rule__CatkinPackage__DependencyAssignment_5_2 ) ) ; - public final void rule__CatkinPackage__Group_5__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_4__1__Impl" + // InternalRosParser.g:4286:1: rule__Node__Group_3_4__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4198:1: ( ( ( rule__CatkinPackage__DependencyAssignment_5_2 ) ) ) - // InternalRos.g:4199:1: ( ( rule__CatkinPackage__DependencyAssignment_5_2 ) ) + // InternalRosParser.g:4290:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:4291:1: ( RULE_BEGIN ) { - // InternalRos.g:4199:1: ( ( rule__CatkinPackage__DependencyAssignment_5_2 ) ) - // InternalRos.g:4200:2: ( rule__CatkinPackage__DependencyAssignment_5_2 ) + // InternalRosParser.g:4291:1: ( RULE_BEGIN ) + // InternalRosParser.g:4292:2: RULE_BEGIN { - before(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_5_2()); - // InternalRos.g:4201:2: ( rule__CatkinPackage__DependencyAssignment_5_2 ) - // InternalRos.g:4201:3: rule__CatkinPackage__DependencyAssignment_5_2 - { - pushFollow(FOLLOW_2); - rule__CatkinPackage__DependencyAssignment_5_2(); - - state._fsp--; - - - } - - after(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_5_2()); + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); } @@ -13142,26 +13271,26 @@ public final void rule__CatkinPackage__Group_5__2__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5__2__Impl" + // $ANTLR end "rule__Node__Group_3_4__1__Impl" - // $ANTLR start "rule__CatkinPackage__Group_5__3" - // InternalRos.g:4209:1: rule__CatkinPackage__Group_5__3 : rule__CatkinPackage__Group_5__3__Impl rule__CatkinPackage__Group_5__4 ; - public final void rule__CatkinPackage__Group_5__3() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_4__2" + // InternalRosParser.g:4301:1: rule__Node__Group_3_4__2 : rule__Node__Group_3_4__2__Impl rule__Node__Group_3_4__3 ; + public final void rule__Node__Group_3_4__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4213:1: ( rule__CatkinPackage__Group_5__3__Impl rule__CatkinPackage__Group_5__4 ) - // InternalRos.g:4214:2: rule__CatkinPackage__Group_5__3__Impl rule__CatkinPackage__Group_5__4 + // InternalRosParser.g:4305:1: ( rule__Node__Group_3_4__2__Impl rule__Node__Group_3_4__3 ) + // InternalRosParser.g:4306:2: rule__Node__Group_3_4__2__Impl rule__Node__Group_3_4__3 { - pushFollow(FOLLOW_13); - rule__CatkinPackage__Group_5__3__Impl(); + pushFollow(FOLLOW_18); + rule__Node__Group_3_4__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_5__4(); + rule__Node__Group_3_4__3(); state._fsp--; @@ -13180,40 +13309,40 @@ public final void rule__CatkinPackage__Group_5__3() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5__3" + // $ANTLR end "rule__Node__Group_3_4__2" - // $ANTLR start "rule__CatkinPackage__Group_5__3__Impl" - // InternalRos.g:4221:1: rule__CatkinPackage__Group_5__3__Impl : ( ( rule__CatkinPackage__Group_5_3__0 )* ) ; - public final void rule__CatkinPackage__Group_5__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_4__2__Impl" + // InternalRosParser.g:4313:1: rule__Node__Group_3_4__2__Impl : ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) ; + public final void rule__Node__Group_3_4__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4225:1: ( ( ( rule__CatkinPackage__Group_5_3__0 )* ) ) - // InternalRos.g:4226:1: ( ( rule__CatkinPackage__Group_5_3__0 )* ) + // InternalRosParser.g:4317:1: ( ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) ) + // InternalRosParser.g:4318:1: ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) { - // InternalRos.g:4226:1: ( ( rule__CatkinPackage__Group_5_3__0 )* ) - // InternalRos.g:4227:2: ( rule__CatkinPackage__Group_5_3__0 )* + // InternalRosParser.g:4318:1: ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) + // InternalRosParser.g:4319:2: ( rule__Node__ActionserverAssignment_3_4_2 )* { - before(grammarAccess.getCatkinPackageAccess().getGroup_5_3()); - // InternalRos.g:4228:2: ( rule__CatkinPackage__Group_5_3__0 )* + before(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); + // InternalRosParser.g:4320:2: ( rule__Node__ActionserverAssignment_3_4_2 )* loop25: do { int alt25=2; int LA25_0 = input.LA(1); - if ( (LA25_0==43) ) { + if ( (LA25_0==RULE_ID||LA25_0==RULE_STRING) ) { alt25=1; } switch (alt25) { case 1 : - // InternalRos.g:4228:3: rule__CatkinPackage__Group_5_3__0 + // InternalRosParser.g:4320:3: rule__Node__ActionserverAssignment_3_4_2 { - pushFollow(FOLLOW_7); - rule__CatkinPackage__Group_5_3__0(); + pushFollow(FOLLOW_19); + rule__Node__ActionserverAssignment_3_4_2(); state._fsp--; @@ -13226,7 +13355,7 @@ public final void rule__CatkinPackage__Group_5__3__Impl() throws RecognitionExce } } while (true); - after(grammarAccess.getCatkinPackageAccess().getGroup_5_3()); + after(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); } @@ -13245,21 +13374,21 @@ public final void rule__CatkinPackage__Group_5__3__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5__3__Impl" + // $ANTLR end "rule__Node__Group_3_4__2__Impl" - // $ANTLR start "rule__CatkinPackage__Group_5__4" - // InternalRos.g:4236:1: rule__CatkinPackage__Group_5__4 : rule__CatkinPackage__Group_5__4__Impl ; - public final void rule__CatkinPackage__Group_5__4() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_4__3" + // InternalRosParser.g:4328:1: rule__Node__Group_3_4__3 : rule__Node__Group_3_4__3__Impl ; + public final void rule__Node__Group_3_4__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4240:1: ( rule__CatkinPackage__Group_5__4__Impl ) - // InternalRos.g:4241:2: rule__CatkinPackage__Group_5__4__Impl + // InternalRosParser.g:4332:1: ( rule__Node__Group_3_4__3__Impl ) + // InternalRosParser.g:4333:2: rule__Node__Group_3_4__3__Impl { pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_5__4__Impl(); + rule__Node__Group_3_4__3__Impl(); state._fsp--; @@ -13278,25 +13407,25 @@ public final void rule__CatkinPackage__Group_5__4() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5__4" + // $ANTLR end "rule__Node__Group_3_4__3" - // $ANTLR start "rule__CatkinPackage__Group_5__4__Impl" - // InternalRos.g:4247:1: rule__CatkinPackage__Group_5__4__Impl : ( '}' ) ; - public final void rule__CatkinPackage__Group_5__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_4__3__Impl" + // InternalRosParser.g:4339:1: rule__Node__Group_3_4__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_4__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4251:1: ( ( '}' ) ) - // InternalRos.g:4252:1: ( '}' ) + // InternalRosParser.g:4343:1: ( ( RULE_END ) ) + // InternalRosParser.g:4344:1: ( RULE_END ) { - // InternalRos.g:4252:1: ( '}' ) - // InternalRos.g:4253:2: '}' + // InternalRosParser.g:4344:1: ( RULE_END ) + // InternalRosParser.g:4345:2: RULE_END { - before(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_5_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_5_4()); + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); } @@ -13315,26 +13444,26 @@ public final void rule__CatkinPackage__Group_5__4__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5__4__Impl" + // $ANTLR end "rule__Node__Group_3_4__3__Impl" - // $ANTLR start "rule__CatkinPackage__Group_5_3__0" - // InternalRos.g:4263:1: rule__CatkinPackage__Group_5_3__0 : rule__CatkinPackage__Group_5_3__0__Impl rule__CatkinPackage__Group_5_3__1 ; - public final void rule__CatkinPackage__Group_5_3__0() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_5__0" + // InternalRosParser.g:4355:1: rule__Node__Group_3_5__0 : rule__Node__Group_3_5__0__Impl rule__Node__Group_3_5__1 ; + public final void rule__Node__Group_3_5__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4267:1: ( rule__CatkinPackage__Group_5_3__0__Impl rule__CatkinPackage__Group_5_3__1 ) - // InternalRos.g:4268:2: rule__CatkinPackage__Group_5_3__0__Impl rule__CatkinPackage__Group_5_3__1 + // InternalRosParser.g:4359:1: ( rule__Node__Group_3_5__0__Impl rule__Node__Group_3_5__1 ) + // InternalRosParser.g:4360:2: rule__Node__Group_3_5__0__Impl rule__Node__Group_3_5__1 { - pushFollow(FOLLOW_19); - rule__CatkinPackage__Group_5_3__0__Impl(); + pushFollow(FOLLOW_6); + rule__Node__Group_3_5__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_5_3__1(); + rule__Node__Group_3_5__1(); state._fsp--; @@ -13353,25 +13482,25 @@ public final void rule__CatkinPackage__Group_5_3__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5_3__0" + // $ANTLR end "rule__Node__Group_3_5__0" - // $ANTLR start "rule__CatkinPackage__Group_5_3__0__Impl" - // InternalRos.g:4275:1: rule__CatkinPackage__Group_5_3__0__Impl : ( ',' ) ; - public final void rule__CatkinPackage__Group_5_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_5__0__Impl" + // InternalRosParser.g:4367:1: rule__Node__Group_3_5__0__Impl : ( Actionclient ) ; + public final void rule__Node__Group_3_5__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4279:1: ( ( ',' ) ) - // InternalRos.g:4280:1: ( ',' ) + // InternalRosParser.g:4371:1: ( ( Actionclient ) ) + // InternalRosParser.g:4372:1: ( Actionclient ) { - // InternalRos.g:4280:1: ( ',' ) - // InternalRos.g:4281:2: ',' + // InternalRosParser.g:4372:1: ( Actionclient ) + // InternalRosParser.g:4373:2: Actionclient { - before(grammarAccess.getCatkinPackageAccess().getCommaKeyword_5_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getCommaKeyword_5_3_0()); + before(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); + match(input,Actionclient,FOLLOW_2); + after(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); } @@ -13390,21 +13519,26 @@ public final void rule__CatkinPackage__Group_5_3__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5_3__0__Impl" + // $ANTLR end "rule__Node__Group_3_5__0__Impl" - // $ANTLR start "rule__CatkinPackage__Group_5_3__1" - // InternalRos.g:4290:1: rule__CatkinPackage__Group_5_3__1 : rule__CatkinPackage__Group_5_3__1__Impl ; - public final void rule__CatkinPackage__Group_5_3__1() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_5__1" + // InternalRosParser.g:4382:1: rule__Node__Group_3_5__1 : rule__Node__Group_3_5__1__Impl rule__Node__Group_3_5__2 ; + public final void rule__Node__Group_3_5__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4294:1: ( rule__CatkinPackage__Group_5_3__1__Impl ) - // InternalRos.g:4295:2: rule__CatkinPackage__Group_5_3__1__Impl + // InternalRosParser.g:4386:1: ( rule__Node__Group_3_5__1__Impl rule__Node__Group_3_5__2 ) + // InternalRosParser.g:4387:2: rule__Node__Group_3_5__1__Impl rule__Node__Group_3_5__2 { + pushFollow(FOLLOW_18); + rule__Node__Group_3_5__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_5_3__1__Impl(); + rule__Node__Group_3_5__2(); state._fsp--; @@ -13423,35 +13557,25 @@ public final void rule__CatkinPackage__Group_5_3__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5_3__1" + // $ANTLR end "rule__Node__Group_3_5__1" - // $ANTLR start "rule__CatkinPackage__Group_5_3__1__Impl" - // InternalRos.g:4301:1: rule__CatkinPackage__Group_5_3__1__Impl : ( ( rule__CatkinPackage__DependencyAssignment_5_3_1 ) ) ; - public final void rule__CatkinPackage__Group_5_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_5__1__Impl" + // InternalRosParser.g:4394:1: rule__Node__Group_3_5__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_5__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4305:1: ( ( ( rule__CatkinPackage__DependencyAssignment_5_3_1 ) ) ) - // InternalRos.g:4306:1: ( ( rule__CatkinPackage__DependencyAssignment_5_3_1 ) ) - { - // InternalRos.g:4306:1: ( ( rule__CatkinPackage__DependencyAssignment_5_3_1 ) ) - // InternalRos.g:4307:2: ( rule__CatkinPackage__DependencyAssignment_5_3_1 ) + // InternalRosParser.g:4398:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:4399:1: ( RULE_BEGIN ) { - before(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_5_3_1()); - // InternalRos.g:4308:2: ( rule__CatkinPackage__DependencyAssignment_5_3_1 ) - // InternalRos.g:4308:3: rule__CatkinPackage__DependencyAssignment_5_3_1 + // InternalRosParser.g:4399:1: ( RULE_BEGIN ) + // InternalRosParser.g:4400:2: RULE_BEGIN { - pushFollow(FOLLOW_2); - rule__CatkinPackage__DependencyAssignment_5_3_1(); - - state._fsp--; - - - } - - after(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_5_3_1()); + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); } @@ -13470,26 +13594,26 @@ public final void rule__CatkinPackage__Group_5_3__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__CatkinPackage__Group_5_3__1__Impl" + // $ANTLR end "rule__Node__Group_3_5__1__Impl" - // $ANTLR start "rule__CatkinPackage__Group_6__0" - // InternalRos.g:4317: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 { + // $ANTLR start "rule__Node__Group_3_5__2" + // InternalRosParser.g:4409:1: rule__Node__Group_3_5__2 : rule__Node__Group_3_5__2__Impl rule__Node__Group_3_5__3 ; + public final void rule__Node__Group_3_5__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4321:1: ( rule__CatkinPackage__Group_6__0__Impl rule__CatkinPackage__Group_6__1 ) - // InternalRos.g:4322:2: rule__CatkinPackage__Group_6__0__Impl rule__CatkinPackage__Group_6__1 + // InternalRosParser.g:4413:1: ( rule__Node__Group_3_5__2__Impl rule__Node__Group_3_5__3 ) + // InternalRosParser.g:4414:2: rule__Node__Group_3_5__2__Impl rule__Node__Group_3_5__3 { - pushFollow(FOLLOW_4); - rule__CatkinPackage__Group_6__0__Impl(); + pushFollow(FOLLOW_18); + rule__Node__Group_3_5__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_6__1(); + rule__Node__Group_3_5__3(); state._fsp--; @@ -13508,25 +13632,53 @@ public final void rule__CatkinPackage__Group_6__0() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6__0" + // $ANTLR end "rule__Node__Group_3_5__2" - // $ANTLR start "rule__CatkinPackage__Group_6__0__Impl" - // InternalRos.g:4329:1: rule__CatkinPackage__Group_6__0__Impl : ( 'Specs' ) ; - public final void rule__CatkinPackage__Group_6__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_5__2__Impl" + // InternalRosParser.g:4421:1: rule__Node__Group_3_5__2__Impl : ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) ; + public final void rule__Node__Group_3_5__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4333:1: ( ( 'Specs' ) ) - // InternalRos.g:4334:1: ( 'Specs' ) + // InternalRosParser.g:4425:1: ( ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) ) + // InternalRosParser.g:4426:1: ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) { - // InternalRos.g:4334:1: ( 'Specs' ) - // InternalRos.g:4335:2: 'Specs' + // InternalRosParser.g:4426:1: ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) + // InternalRosParser.g:4427:2: ( rule__Node__ActionclientAssignment_3_5_2 )* { - before(grammarAccess.getCatkinPackageAccess().getSpecsKeyword_6_0()); - match(input,46,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getSpecsKeyword_6_0()); + before(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); + // InternalRosParser.g:4428:2: ( rule__Node__ActionclientAssignment_3_5_2 )* + loop26: + do { + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0==RULE_ID||LA26_0==RULE_STRING) ) { + alt26=1; + } + + + switch (alt26) { + case 1 : + // InternalRosParser.g:4428:3: rule__Node__ActionclientAssignment_3_5_2 + { + pushFollow(FOLLOW_19); + rule__Node__ActionclientAssignment_3_5_2(); + + state._fsp--; + + + } + break; + + default : + break loop26; + } + } while (true); + + after(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); } @@ -13545,26 +13697,21 @@ public final void rule__CatkinPackage__Group_6__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6__0__Impl" + // $ANTLR end "rule__Node__Group_3_5__2__Impl" - // $ANTLR start "rule__CatkinPackage__Group_6__1" - // InternalRos.g:4344: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 { + // $ANTLR start "rule__Node__Group_3_5__3" + // InternalRosParser.g:4436:1: rule__Node__Group_3_5__3 : rule__Node__Group_3_5__3__Impl ; + public final void rule__Node__Group_3_5__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4348:1: ( rule__CatkinPackage__Group_6__1__Impl rule__CatkinPackage__Group_6__2 ) - // InternalRos.g:4349:2: rule__CatkinPackage__Group_6__1__Impl rule__CatkinPackage__Group_6__2 + // InternalRosParser.g:4440:1: ( rule__Node__Group_3_5__3__Impl ) + // InternalRosParser.g:4441:2: rule__Node__Group_3_5__3__Impl { - pushFollow(FOLLOW_12); - rule__CatkinPackage__Group_6__1__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_6__2(); + rule__Node__Group_3_5__3__Impl(); state._fsp--; @@ -13583,25 +13730,25 @@ public final void rule__CatkinPackage__Group_6__1() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6__1" + // $ANTLR end "rule__Node__Group_3_5__3" - // $ANTLR start "rule__CatkinPackage__Group_6__1__Impl" - // InternalRos.g:4356:1: rule__CatkinPackage__Group_6__1__Impl : ( '{' ) ; - public final void rule__CatkinPackage__Group_6__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_5__3__Impl" + // InternalRosParser.g:4447:1: rule__Node__Group_3_5__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_5__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4360:1: ( ( '{' ) ) - // InternalRos.g:4361:1: ( '{' ) + // InternalRosParser.g:4451:1: ( ( RULE_END ) ) + // InternalRosParser.g:4452:1: ( RULE_END ) { - // InternalRos.g:4361:1: ( '{' ) - // InternalRos.g:4362:2: '{' + // InternalRosParser.g:4452:1: ( RULE_END ) + // InternalRosParser.g:4453:2: RULE_END { - before(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_6_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_6_1()); + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); } @@ -13620,26 +13767,26 @@ public final void rule__CatkinPackage__Group_6__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6__1__Impl" + // $ANTLR end "rule__Node__Group_3_5__3__Impl" - // $ANTLR start "rule__CatkinPackage__Group_6__2" - // InternalRos.g:4371: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 { + // $ANTLR start "rule__Node__Group_3_6__0" + // InternalRosParser.g:4463:1: rule__Node__Group_3_6__0 : rule__Node__Group_3_6__0__Impl rule__Node__Group_3_6__1 ; + public final void rule__Node__Group_3_6__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4375:1: ( rule__CatkinPackage__Group_6__2__Impl rule__CatkinPackage__Group_6__3 ) - // InternalRos.g:4376:2: rule__CatkinPackage__Group_6__2__Impl rule__CatkinPackage__Group_6__3 + // InternalRosParser.g:4467:1: ( rule__Node__Group_3_6__0__Impl rule__Node__Group_3_6__1 ) + // InternalRosParser.g:4468:2: rule__Node__Group_3_6__0__Impl rule__Node__Group_3_6__1 { - pushFollow(FOLLOW_13); - rule__CatkinPackage__Group_6__2__Impl(); + pushFollow(FOLLOW_6); + rule__Node__Group_3_6__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_6__3(); + rule__Node__Group_3_6__1(); state._fsp--; @@ -13658,35 +13805,25 @@ public final void rule__CatkinPackage__Group_6__2() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6__2" + // $ANTLR end "rule__Node__Group_3_6__0" - // $ANTLR start "rule__CatkinPackage__Group_6__2__Impl" - // InternalRos.g:4383:1: rule__CatkinPackage__Group_6__2__Impl : ( ( rule__CatkinPackage__SpecAssignment_6_2 ) ) ; - public final void rule__CatkinPackage__Group_6__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_6__0__Impl" + // InternalRosParser.g:4475:1: rule__Node__Group_3_6__0__Impl : ( Parameters ) ; + public final void rule__Node__Group_3_6__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4387:1: ( ( ( rule__CatkinPackage__SpecAssignment_6_2 ) ) ) - // InternalRos.g:4388:1: ( ( rule__CatkinPackage__SpecAssignment_6_2 ) ) + // InternalRosParser.g:4479:1: ( ( Parameters ) ) + // InternalRosParser.g:4480:1: ( Parameters ) { - // InternalRos.g:4388:1: ( ( rule__CatkinPackage__SpecAssignment_6_2 ) ) - // InternalRos.g:4389:2: ( rule__CatkinPackage__SpecAssignment_6_2 ) + // InternalRosParser.g:4480:1: ( Parameters ) + // InternalRosParser.g:4481:2: Parameters { - before(grammarAccess.getCatkinPackageAccess().getSpecAssignment_6_2()); - // InternalRos.g:4390:2: ( rule__CatkinPackage__SpecAssignment_6_2 ) - // InternalRos.g:4390:3: rule__CatkinPackage__SpecAssignment_6_2 - { - pushFollow(FOLLOW_2); - rule__CatkinPackage__SpecAssignment_6_2(); - - state._fsp--; - - - } - - after(grammarAccess.getCatkinPackageAccess().getSpecAssignment_6_2()); + before(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); + match(input,Parameters,FOLLOW_2); + after(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); } @@ -13705,26 +13842,26 @@ public final void rule__CatkinPackage__Group_6__2__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6__2__Impl" + // $ANTLR end "rule__Node__Group_3_6__0__Impl" - // $ANTLR start "rule__CatkinPackage__Group_6__3" - // InternalRos.g:4398: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 { + // $ANTLR start "rule__Node__Group_3_6__1" + // InternalRosParser.g:4490:1: rule__Node__Group_3_6__1 : rule__Node__Group_3_6__1__Impl rule__Node__Group_3_6__2 ; + public final void rule__Node__Group_3_6__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4402:1: ( rule__CatkinPackage__Group_6__3__Impl rule__CatkinPackage__Group_6__4 ) - // InternalRos.g:4403:2: rule__CatkinPackage__Group_6__3__Impl rule__CatkinPackage__Group_6__4 + // InternalRosParser.g:4494:1: ( rule__Node__Group_3_6__1__Impl rule__Node__Group_3_6__2 ) + // InternalRosParser.g:4495:2: rule__Node__Group_3_6__1__Impl rule__Node__Group_3_6__2 { - pushFollow(FOLLOW_13); - rule__CatkinPackage__Group_6__3__Impl(); + pushFollow(FOLLOW_18); + rule__Node__Group_3_6__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_6__4(); + rule__Node__Group_3_6__2(); state._fsp--; @@ -13743,55 +13880,65 @@ public final void rule__CatkinPackage__Group_6__3() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6__3" + // $ANTLR end "rule__Node__Group_3_6__1" - // $ANTLR start "rule__CatkinPackage__Group_6__3__Impl" - // InternalRos.g:4410:1: rule__CatkinPackage__Group_6__3__Impl : ( ( rule__CatkinPackage__Group_6_3__0 )* ) ; - public final void rule__CatkinPackage__Group_6__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_6__1__Impl" + // InternalRosParser.g:4502:1: rule__Node__Group_3_6__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_6__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4414:1: ( ( ( rule__CatkinPackage__Group_6_3__0 )* ) ) - // InternalRos.g:4415:1: ( ( rule__CatkinPackage__Group_6_3__0 )* ) + // InternalRosParser.g:4506:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:4507:1: ( RULE_BEGIN ) { - // InternalRos.g:4415:1: ( ( rule__CatkinPackage__Group_6_3__0 )* ) - // InternalRos.g:4416:2: ( rule__CatkinPackage__Group_6_3__0 )* + // InternalRosParser.g:4507:1: ( RULE_BEGIN ) + // InternalRosParser.g:4508:2: RULE_BEGIN { - before(grammarAccess.getCatkinPackageAccess().getGroup_6_3()); - // InternalRos.g:4417:2: ( rule__CatkinPackage__Group_6_3__0 )* - loop26: - do { - int alt26=2; - int LA26_0 = input.LA(1); + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); - if ( (LA26_0==43) ) { - alt26=1; - } + } - switch (alt26) { - case 1 : - // InternalRos.g:4417:3: rule__CatkinPackage__Group_6_3__0 - { - pushFollow(FOLLOW_7); - rule__CatkinPackage__Group_6_3__0(); + } - state._fsp--; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + restoreStackSize(stackSize); - } - break; + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__1__Impl" - default : - break loop26; - } - } while (true); - after(grammarAccess.getCatkinPackageAccess().getGroup_6_3()); + // $ANTLR start "rule__Node__Group_3_6__2" + // InternalRosParser.g:4517:1: rule__Node__Group_3_6__2 : rule__Node__Group_3_6__2__Impl rule__Node__Group_3_6__3 ; + public final void rule__Node__Group_3_6__2() throws RecognitionException { - } + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:4521:1: ( rule__Node__Group_3_6__2__Impl rule__Node__Group_3_6__3 ) + // InternalRosParser.g:4522:2: rule__Node__Group_3_6__2__Impl rule__Node__Group_3_6__3 + { + pushFollow(FOLLOW_18); + rule__Node__Group_3_6__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_6__3(); + + state._fsp--; } @@ -13808,58 +13955,53 @@ public final void rule__CatkinPackage__Group_6__3__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6__3__Impl" + // $ANTLR end "rule__Node__Group_3_6__2" - // $ANTLR start "rule__CatkinPackage__Group_6__4" - // InternalRos.g:4425:1: rule__CatkinPackage__Group_6__4 : rule__CatkinPackage__Group_6__4__Impl ; - public final void rule__CatkinPackage__Group_6__4() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_6__2__Impl" + // InternalRosParser.g:4529:1: rule__Node__Group_3_6__2__Impl : ( ( rule__Node__ParameterAssignment_3_6_2 )* ) ; + public final void rule__Node__Group_3_6__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4429:1: ( rule__CatkinPackage__Group_6__4__Impl ) - // InternalRos.g:4430:2: rule__CatkinPackage__Group_6__4__Impl + // InternalRosParser.g:4533:1: ( ( ( rule__Node__ParameterAssignment_3_6_2 )* ) ) + // InternalRosParser.g:4534:1: ( ( rule__Node__ParameterAssignment_3_6_2 )* ) { - pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_6__4__Impl(); + // InternalRosParser.g:4534:1: ( ( rule__Node__ParameterAssignment_3_6_2 )* ) + // InternalRosParser.g:4535:2: ( rule__Node__ParameterAssignment_3_6_2 )* + { + before(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); + // InternalRosParser.g:4536:2: ( rule__Node__ParameterAssignment_3_6_2 )* + loop27: + do { + int alt27=2; + int LA27_0 = input.LA(1); - state._fsp--; + if ( (LA27_0==RULE_ID||LA27_0==RULE_STRING) ) { + alt27=1; + } - } + switch (alt27) { + case 1 : + // InternalRosParser.g:4536:3: rule__Node__ParameterAssignment_3_6_2 + { + pushFollow(FOLLOW_19); + rule__Node__ParameterAssignment_3_6_2(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__CatkinPackage__Group_6__4" + } + break; + default : + break loop27; + } + } while (true); - // $ANTLR start "rule__CatkinPackage__Group_6__4__Impl" - // InternalRos.g:4436:1: rule__CatkinPackage__Group_6__4__Impl : ( '}' ) ; - public final void rule__CatkinPackage__Group_6__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:4440:1: ( ( '}' ) ) - // InternalRos.g:4441:1: ( '}' ) - { - // InternalRos.g:4441:1: ( '}' ) - // InternalRos.g:4442:2: '}' - { - before(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_6_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_6_4()); + after(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); } @@ -13878,26 +14020,21 @@ public final void rule__CatkinPackage__Group_6__4__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6__4__Impl" + // $ANTLR end "rule__Node__Group_3_6__2__Impl" - // $ANTLR start "rule__CatkinPackage__Group_6_3__0" - // InternalRos.g:4452: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 { + // $ANTLR start "rule__Node__Group_3_6__3" + // InternalRosParser.g:4544:1: rule__Node__Group_3_6__3 : rule__Node__Group_3_6__3__Impl ; + public final void rule__Node__Group_3_6__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4456:1: ( rule__CatkinPackage__Group_6_3__0__Impl rule__CatkinPackage__Group_6_3__1 ) - // InternalRos.g:4457:2: rule__CatkinPackage__Group_6_3__0__Impl rule__CatkinPackage__Group_6_3__1 + // InternalRosParser.g:4548:1: ( rule__Node__Group_3_6__3__Impl ) + // InternalRosParser.g:4549:2: rule__Node__Group_3_6__3__Impl { - pushFollow(FOLLOW_12); - rule__CatkinPackage__Group_6_3__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_6_3__1(); + rule__Node__Group_3_6__3__Impl(); state._fsp--; @@ -13916,25 +14053,25 @@ public final void rule__CatkinPackage__Group_6_3__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6_3__0" + // $ANTLR end "rule__Node__Group_3_6__3" - // $ANTLR start "rule__CatkinPackage__Group_6_3__0__Impl" - // InternalRos.g:4464:1: rule__CatkinPackage__Group_6_3__0__Impl : ( ',' ) ; - public final void rule__CatkinPackage__Group_6_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Node__Group_3_6__3__Impl" + // InternalRosParser.g:4555:1: rule__Node__Group_3_6__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_6__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4468:1: ( ( ',' ) ) - // InternalRos.g:4469:1: ( ',' ) + // InternalRosParser.g:4559:1: ( ( RULE_END ) ) + // InternalRosParser.g:4560:1: ( RULE_END ) { - // InternalRos.g:4469:1: ( ',' ) - // InternalRos.g:4470:2: ',' + // InternalRosParser.g:4560:1: ( RULE_END ) + // InternalRosParser.g:4561:2: RULE_END { - before(grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); } @@ -13953,21 +14090,26 @@ public final void rule__CatkinPackage__Group_6_3__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6_3__0__Impl" + // $ANTLR end "rule__Node__Group_3_6__3__Impl" - // $ANTLR start "rule__CatkinPackage__Group_6_3__1" - // InternalRos.g:4479: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 { + // $ANTLR start "rule__TopicSpec__Group__0" + // InternalRosParser.g:4571:1: rule__TopicSpec__Group__0 : rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 ; + public final void rule__TopicSpec__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4483:1: ( rule__CatkinPackage__Group_6_3__1__Impl ) - // InternalRos.g:4484:2: rule__CatkinPackage__Group_6_3__1__Impl + // InternalRosParser.g:4575:1: ( rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 ) + // InternalRosParser.g:4576:2: rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 { + pushFollow(FOLLOW_20); + rule__TopicSpec__Group__0__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_6_3__1__Impl(); + rule__TopicSpec__Group__1(); state._fsp--; @@ -13986,35 +14128,29 @@ public final void rule__CatkinPackage__Group_6_3__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6_3__1" + // $ANTLR end "rule__TopicSpec__Group__0" - // $ANTLR start "rule__CatkinPackage__Group_6_3__1__Impl" - // InternalRos.g:4490:1: rule__CatkinPackage__Group_6_3__1__Impl : ( ( rule__CatkinPackage__SpecAssignment_6_3_1 ) ) ; - public final void rule__CatkinPackage__Group_6_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__0__Impl" + // InternalRosParser.g:4583:1: rule__TopicSpec__Group__0__Impl : ( () ) ; + public final void rule__TopicSpec__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4494:1: ( ( ( rule__CatkinPackage__SpecAssignment_6_3_1 ) ) ) - // InternalRos.g:4495:1: ( ( rule__CatkinPackage__SpecAssignment_6_3_1 ) ) + // InternalRosParser.g:4587:1: ( ( () ) ) + // InternalRosParser.g:4588:1: ( () ) { - // InternalRos.g:4495:1: ( ( rule__CatkinPackage__SpecAssignment_6_3_1 ) ) - // InternalRos.g:4496:2: ( rule__CatkinPackage__SpecAssignment_6_3_1 ) + // InternalRosParser.g:4588:1: ( () ) + // InternalRosParser.g:4589:2: () { - before(grammarAccess.getCatkinPackageAccess().getSpecAssignment_6_3_1()); - // InternalRos.g:4497:2: ( rule__CatkinPackage__SpecAssignment_6_3_1 ) - // InternalRos.g:4497:3: rule__CatkinPackage__SpecAssignment_6_3_1 + before(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); + // InternalRosParser.g:4590:2: () + // InternalRosParser.g:4590:3: { - pushFollow(FOLLOW_2); - rule__CatkinPackage__SpecAssignment_6_3_1(); - - state._fsp--; - - } - after(grammarAccess.getCatkinPackageAccess().getSpecAssignment_6_3_1()); + after(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); } @@ -14022,10 +14158,6 @@ public final void rule__CatkinPackage__Group_6_3__1__Impl() throws RecognitionEx } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -14033,26 +14165,26 @@ public final void rule__CatkinPackage__Group_6_3__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__CatkinPackage__Group_6_3__1__Impl" + // $ANTLR end "rule__TopicSpec__Group__0__Impl" - // $ANTLR start "rule__CatkinPackage__Group_7__0" - // InternalRos.g:4506:1: rule__CatkinPackage__Group_7__0 : rule__CatkinPackage__Group_7__0__Impl rule__CatkinPackage__Group_7__1 ; - public final void rule__CatkinPackage__Group_7__0() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__1" + // InternalRosParser.g:4598:1: rule__TopicSpec__Group__1 : rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 ; + public final void rule__TopicSpec__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4510:1: ( rule__CatkinPackage__Group_7__0__Impl rule__CatkinPackage__Group_7__1 ) - // InternalRos.g:4511:2: rule__CatkinPackage__Group_7__0__Impl rule__CatkinPackage__Group_7__1 + // InternalRosParser.g:4602:1: ( rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 ) + // InternalRosParser.g:4603:2: rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 { - pushFollow(FOLLOW_6); - rule__CatkinPackage__Group_7__0__Impl(); + pushFollow(FOLLOW_21); + rule__TopicSpec__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_7__1(); + rule__TopicSpec__Group__2(); state._fsp--; @@ -14071,35 +14203,25 @@ public final void rule__CatkinPackage__Group_7__0() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_7__0" + // $ANTLR end "rule__TopicSpec__Group__1" - // $ANTLR start "rule__CatkinPackage__Group_7__0__Impl" - // InternalRos.g:4518:1: rule__CatkinPackage__Group_7__0__Impl : ( ( rule__CatkinPackage__ArtifactAssignment_7_0 ) ) ; - public final void rule__CatkinPackage__Group_7__0__Impl() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__1__Impl" + // InternalRosParser.g:4610:1: rule__TopicSpec__Group__1__Impl : ( Msg ) ; + public final void rule__TopicSpec__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4522:1: ( ( ( rule__CatkinPackage__ArtifactAssignment_7_0 ) ) ) - // InternalRos.g:4523:1: ( ( rule__CatkinPackage__ArtifactAssignment_7_0 ) ) - { - // InternalRos.g:4523:1: ( ( rule__CatkinPackage__ArtifactAssignment_7_0 ) ) - // InternalRos.g:4524:2: ( rule__CatkinPackage__ArtifactAssignment_7_0 ) + // InternalRosParser.g:4614:1: ( ( Msg ) ) + // InternalRosParser.g:4615:1: ( Msg ) { - before(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_7_0()); - // InternalRos.g:4525:2: ( rule__CatkinPackage__ArtifactAssignment_7_0 ) - // InternalRos.g:4525:3: rule__CatkinPackage__ArtifactAssignment_7_0 + // InternalRosParser.g:4615:1: ( Msg ) + // InternalRosParser.g:4616:2: Msg { - pushFollow(FOLLOW_2); - rule__CatkinPackage__ArtifactAssignment_7_0(); - - state._fsp--; - - - } - - after(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_7_0()); + before(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); + match(input,Msg,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); } @@ -14118,21 +14240,26 @@ public final void rule__CatkinPackage__Group_7__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_7__0__Impl" + // $ANTLR end "rule__TopicSpec__Group__1__Impl" - // $ANTLR start "rule__CatkinPackage__Group_7__1" - // InternalRos.g:4533:1: rule__CatkinPackage__Group_7__1 : rule__CatkinPackage__Group_7__1__Impl ; - public final void rule__CatkinPackage__Group_7__1() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__2" + // InternalRosParser.g:4625:1: rule__TopicSpec__Group__2 : rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 ; + public final void rule__TopicSpec__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4537:1: ( rule__CatkinPackage__Group_7__1__Impl ) - // InternalRos.g:4538:2: rule__CatkinPackage__Group_7__1__Impl + // InternalRosParser.g:4629:1: ( rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 ) + // InternalRosParser.g:4630:2: rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 { + pushFollow(FOLLOW_6); + rule__TopicSpec__Group__2__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_7__1__Impl(); + rule__TopicSpec__Group__3(); state._fsp--; @@ -14151,53 +14278,35 @@ public final void rule__CatkinPackage__Group_7__1() throws RecognitionException } return ; } - // $ANTLR end "rule__CatkinPackage__Group_7__1" + // $ANTLR end "rule__TopicSpec__Group__2" - // $ANTLR start "rule__CatkinPackage__Group_7__1__Impl" - // InternalRos.g:4544:1: rule__CatkinPackage__Group_7__1__Impl : ( ( rule__CatkinPackage__Group_7_1__0 )* ) ; - public final void rule__CatkinPackage__Group_7__1__Impl() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__2__Impl" + // InternalRosParser.g:4637:1: rule__TopicSpec__Group__2__Impl : ( ( rule__TopicSpec__NameAssignment_2 ) ) ; + public final void rule__TopicSpec__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4548:1: ( ( ( rule__CatkinPackage__Group_7_1__0 )* ) ) - // InternalRos.g:4549:1: ( ( rule__CatkinPackage__Group_7_1__0 )* ) + // InternalRosParser.g:4641:1: ( ( ( rule__TopicSpec__NameAssignment_2 ) ) ) + // InternalRosParser.g:4642:1: ( ( rule__TopicSpec__NameAssignment_2 ) ) { - // InternalRos.g:4549:1: ( ( rule__CatkinPackage__Group_7_1__0 )* ) - // InternalRos.g:4550:2: ( rule__CatkinPackage__Group_7_1__0 )* + // InternalRosParser.g:4642:1: ( ( rule__TopicSpec__NameAssignment_2 ) ) + // InternalRosParser.g:4643:2: ( rule__TopicSpec__NameAssignment_2 ) { - before(grammarAccess.getCatkinPackageAccess().getGroup_7_1()); - // InternalRos.g:4551:2: ( rule__CatkinPackage__Group_7_1__0 )* - loop27: - do { - int alt27=2; - int LA27_0 = input.LA(1); - - if ( (LA27_0==43) ) { - alt27=1; - } - - - switch (alt27) { - case 1 : - // InternalRos.g:4551:3: rule__CatkinPackage__Group_7_1__0 - { - pushFollow(FOLLOW_7); - rule__CatkinPackage__Group_7_1__0(); - - state._fsp--; + before(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); + // InternalRosParser.g:4644:2: ( rule__TopicSpec__NameAssignment_2 ) + // InternalRosParser.g:4644:3: rule__TopicSpec__NameAssignment_2 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__NameAssignment_2(); + state._fsp--; - } - break; - default : - break loop27; - } - } while (true); + } - after(grammarAccess.getCatkinPackageAccess().getGroup_7_1()); + after(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); } @@ -14216,26 +14325,26 @@ public final void rule__CatkinPackage__Group_7__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__Group_7__1__Impl" + // $ANTLR end "rule__TopicSpec__Group__2__Impl" - // $ANTLR start "rule__CatkinPackage__Group_7_1__0" - // InternalRos.g:4560:1: rule__CatkinPackage__Group_7_1__0 : rule__CatkinPackage__Group_7_1__0__Impl rule__CatkinPackage__Group_7_1__1 ; - public final void rule__CatkinPackage__Group_7_1__0() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__3" + // InternalRosParser.g:4652:1: rule__TopicSpec__Group__3 : rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 ; + public final void rule__TopicSpec__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4564:1: ( rule__CatkinPackage__Group_7_1__0__Impl rule__CatkinPackage__Group_7_1__1 ) - // InternalRos.g:4565:2: rule__CatkinPackage__Group_7_1__0__Impl rule__CatkinPackage__Group_7_1__1 + // InternalRosParser.g:4656:1: ( rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 ) + // InternalRosParser.g:4657:2: rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 { - pushFollow(FOLLOW_14); - rule__CatkinPackage__Group_7_1__0__Impl(); + pushFollow(FOLLOW_22); + rule__TopicSpec__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_7_1__1(); + rule__TopicSpec__Group__4(); state._fsp--; @@ -14254,25 +14363,25 @@ public final void rule__CatkinPackage__Group_7_1__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__CatkinPackage__Group_7_1__0" + // $ANTLR end "rule__TopicSpec__Group__3" - // $ANTLR start "rule__CatkinPackage__Group_7_1__0__Impl" - // InternalRos.g:4572:1: rule__CatkinPackage__Group_7_1__0__Impl : ( ',' ) ; - public final void rule__CatkinPackage__Group_7_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__3__Impl" + // InternalRosParser.g:4664:1: rule__TopicSpec__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__TopicSpec__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4576:1: ( ( ',' ) ) - // InternalRos.g:4577:1: ( ',' ) + // InternalRosParser.g:4668:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:4669:1: ( RULE_BEGIN ) { - // InternalRos.g:4577:1: ( ',' ) - // InternalRos.g:4578:2: ',' + // InternalRosParser.g:4669:1: ( RULE_BEGIN ) + // InternalRosParser.g:4670:2: RULE_BEGIN { - before(grammarAccess.getCatkinPackageAccess().getCommaKeyword_7_1_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getCatkinPackageAccess().getCommaKeyword_7_1_0()); + before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); } @@ -14291,21 +14400,26 @@ public final void rule__CatkinPackage__Group_7_1__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__CatkinPackage__Group_7_1__0__Impl" + // $ANTLR end "rule__TopicSpec__Group__3__Impl" - // $ANTLR start "rule__CatkinPackage__Group_7_1__1" - // InternalRos.g:4587:1: rule__CatkinPackage__Group_7_1__1 : rule__CatkinPackage__Group_7_1__1__Impl ; - public final void rule__CatkinPackage__Group_7_1__1() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__4" + // InternalRosParser.g:4679:1: rule__TopicSpec__Group__4 : rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 ; + public final void rule__TopicSpec__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4591:1: ( rule__CatkinPackage__Group_7_1__1__Impl ) - // InternalRos.g:4592:2: rule__CatkinPackage__Group_7_1__1__Impl + // InternalRosParser.g:4683:1: ( rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 ) + // InternalRosParser.g:4684:2: rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 { + pushFollow(FOLLOW_23); + rule__TopicSpec__Group__4__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__CatkinPackage__Group_7_1__1__Impl(); + rule__TopicSpec__Group__5(); state._fsp--; @@ -14324,35 +14438,25 @@ public final void rule__CatkinPackage__Group_7_1__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__CatkinPackage__Group_7_1__1" + // $ANTLR end "rule__TopicSpec__Group__4" - // $ANTLR start "rule__CatkinPackage__Group_7_1__1__Impl" - // InternalRos.g:4598:1: rule__CatkinPackage__Group_7_1__1__Impl : ( ( rule__CatkinPackage__ArtifactAssignment_7_1_1 ) ) ; - public final void rule__CatkinPackage__Group_7_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__4__Impl" + // InternalRosParser.g:4691:1: rule__TopicSpec__Group__4__Impl : ( Message_1 ) ; + public final void rule__TopicSpec__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4602:1: ( ( ( rule__CatkinPackage__ArtifactAssignment_7_1_1 ) ) ) - // InternalRos.g:4603:1: ( ( rule__CatkinPackage__ArtifactAssignment_7_1_1 ) ) + // InternalRosParser.g:4695:1: ( ( Message_1 ) ) + // InternalRosParser.g:4696:1: ( Message_1 ) { - // InternalRos.g:4603:1: ( ( rule__CatkinPackage__ArtifactAssignment_7_1_1 ) ) - // InternalRos.g:4604:2: ( rule__CatkinPackage__ArtifactAssignment_7_1_1 ) + // InternalRosParser.g:4696:1: ( Message_1 ) + // InternalRosParser.g:4697:2: Message_1 { - before(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_7_1_1()); - // InternalRos.g:4605:2: ( rule__CatkinPackage__ArtifactAssignment_7_1_1 ) - // InternalRos.g:4605:3: rule__CatkinPackage__ArtifactAssignment_7_1_1 - { - pushFollow(FOLLOW_2); - rule__CatkinPackage__ArtifactAssignment_7_1_1(); - - state._fsp--; - - - } - - after(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_7_1_1()); + before(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); + match(input,Message_1,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); } @@ -14371,26 +14475,26 @@ public final void rule__CatkinPackage__Group_7_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__CatkinPackage__Group_7_1__1__Impl" + // $ANTLR end "rule__TopicSpec__Group__4__Impl" - // $ANTLR start "rule__AmentPackage__Group__0" - // InternalRos.g:4614:1: rule__AmentPackage__Group__0 : rule__AmentPackage__Group__0__Impl rule__AmentPackage__Group__1 ; - public final void rule__AmentPackage__Group__0() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__5" + // InternalRosParser.g:4706:1: rule__TopicSpec__Group__5 : rule__TopicSpec__Group__5__Impl rule__TopicSpec__Group__6 ; + public final void rule__TopicSpec__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4618:1: ( rule__AmentPackage__Group__0__Impl rule__AmentPackage__Group__1 ) - // InternalRos.g:4619:2: rule__AmentPackage__Group__0__Impl rule__AmentPackage__Group__1 + // InternalRosParser.g:4710:1: ( rule__TopicSpec__Group__5__Impl rule__TopicSpec__Group__6 ) + // InternalRosParser.g:4711:2: rule__TopicSpec__Group__5__Impl rule__TopicSpec__Group__6 { - pushFollow(FOLLOW_8); - rule__AmentPackage__Group__0__Impl(); + pushFollow(FOLLOW_23); + rule__TopicSpec__Group__5__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group__1(); + rule__TopicSpec__Group__6(); state._fsp--; @@ -14409,100 +14513,46 @@ public final void rule__AmentPackage__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group__0" + // $ANTLR end "rule__TopicSpec__Group__5" - // $ANTLR start "rule__AmentPackage__Group__0__Impl" - // InternalRos.g:4626:1: rule__AmentPackage__Group__0__Impl : ( () ) ; - public final void rule__AmentPackage__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__5__Impl" + // InternalRosParser.g:4718:1: rule__TopicSpec__Group__5__Impl : ( ( rule__TopicSpec__Group_5__0 )? ) ; + public final void rule__TopicSpec__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4630:1: ( ( () ) ) - // InternalRos.g:4631:1: ( () ) - { - // InternalRos.g:4631:1: ( () ) - // InternalRos.g:4632:2: () + // InternalRosParser.g:4722:1: ( ( ( rule__TopicSpec__Group_5__0 )? ) ) + // InternalRosParser.g:4723:1: ( ( rule__TopicSpec__Group_5__0 )? ) { - before(grammarAccess.getAmentPackageAccess().getAmentPackageAction_0()); - // InternalRos.g:4633:2: () - // InternalRos.g:4633:3: + // InternalRosParser.g:4723:1: ( ( rule__TopicSpec__Group_5__0 )? ) + // InternalRosParser.g:4724:2: ( rule__TopicSpec__Group_5__0 )? { - } - - after(grammarAccess.getAmentPackageAccess().getAmentPackageAction_0()); - - } - + before(grammarAccess.getTopicSpecAccess().getGroup_5()); + // InternalRosParser.g:4725:2: ( rule__TopicSpec__Group_5__0 )? + int alt28=2; + int LA28_0 = input.LA(1); + if ( (LA28_0==RULE_BEGIN) ) { + alt28=1; } + switch (alt28) { + case 1 : + // InternalRosParser.g:4725:3: rule__TopicSpec__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__Group_5__0(); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__AmentPackage__Group__0__Impl" - - - // $ANTLR start "rule__AmentPackage__Group__1" - // InternalRos.g:4641:1: rule__AmentPackage__Group__1 : rule__AmentPackage__Group__1__Impl rule__AmentPackage__Group__2 ; - public final void rule__AmentPackage__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:4645:1: ( rule__AmentPackage__Group__1__Impl rule__AmentPackage__Group__2 ) - // InternalRos.g:4646:2: rule__AmentPackage__Group__1__Impl rule__AmentPackage__Group__2 - { - pushFollow(FOLLOW_15); - rule__AmentPackage__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__AmentPackage__Group__2(); + state._fsp--; - state._fsp--; + } + break; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__AmentPackage__Group__1" - - - // $ANTLR start "rule__AmentPackage__Group__1__Impl" - // InternalRos.g:4653:1: rule__AmentPackage__Group__1__Impl : ( 'AmentPackage' ) ; - public final void rule__AmentPackage__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:4657:1: ( ( 'AmentPackage' ) ) - // InternalRos.g:4658:1: ( 'AmentPackage' ) - { - // InternalRos.g:4658:1: ( 'AmentPackage' ) - // InternalRos.g:4659:2: 'AmentPackage' - { - before(grammarAccess.getAmentPackageAccess().getAmentPackageKeyword_1()); - match(input,50,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getAmentPackageKeyword_1()); + after(grammarAccess.getTopicSpecAccess().getGroup_5()); } @@ -14521,26 +14571,21 @@ public final void rule__AmentPackage__Group__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AmentPackage__Group__1__Impl" + // $ANTLR end "rule__TopicSpec__Group__5__Impl" - // $ANTLR start "rule__AmentPackage__Group__2" - // InternalRos.g:4668:1: rule__AmentPackage__Group__2 : rule__AmentPackage__Group__2__Impl rule__AmentPackage__Group__3 ; - public final void rule__AmentPackage__Group__2() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__6" + // InternalRosParser.g:4733:1: rule__TopicSpec__Group__6 : rule__TopicSpec__Group__6__Impl ; + public final void rule__TopicSpec__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4672:1: ( rule__AmentPackage__Group__2__Impl rule__AmentPackage__Group__3 ) - // InternalRos.g:4673:2: rule__AmentPackage__Group__2__Impl rule__AmentPackage__Group__3 + // InternalRosParser.g:4737:1: ( rule__TopicSpec__Group__6__Impl ) + // InternalRosParser.g:4738:2: rule__TopicSpec__Group__6__Impl { - pushFollow(FOLLOW_4); - rule__AmentPackage__Group__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__AmentPackage__Group__3(); + rule__TopicSpec__Group__6__Impl(); state._fsp--; @@ -14559,35 +14604,25 @@ public final void rule__AmentPackage__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group__2" + // $ANTLR end "rule__TopicSpec__Group__6" - // $ANTLR start "rule__AmentPackage__Group__2__Impl" - // InternalRos.g:4680:1: rule__AmentPackage__Group__2__Impl : ( ( rule__AmentPackage__NameAssignment_2 ) ) ; - public final void rule__AmentPackage__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group__6__Impl" + // InternalRosParser.g:4744:1: rule__TopicSpec__Group__6__Impl : ( RULE_END ) ; + public final void rule__TopicSpec__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4684:1: ( ( ( rule__AmentPackage__NameAssignment_2 ) ) ) - // InternalRos.g:4685:1: ( ( rule__AmentPackage__NameAssignment_2 ) ) + // InternalRosParser.g:4748:1: ( ( RULE_END ) ) + // InternalRosParser.g:4749:1: ( RULE_END ) { - // InternalRos.g:4685:1: ( ( rule__AmentPackage__NameAssignment_2 ) ) - // InternalRos.g:4686:2: ( rule__AmentPackage__NameAssignment_2 ) + // InternalRosParser.g:4749:1: ( RULE_END ) + // InternalRosParser.g:4750:2: RULE_END { - before(grammarAccess.getAmentPackageAccess().getNameAssignment_2()); - // InternalRos.g:4687:2: ( rule__AmentPackage__NameAssignment_2 ) - // InternalRos.g:4687:3: rule__AmentPackage__NameAssignment_2 - { - pushFollow(FOLLOW_2); - rule__AmentPackage__NameAssignment_2(); - - state._fsp--; - - - } - - after(grammarAccess.getAmentPackageAccess().getNameAssignment_2()); + before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); } @@ -14606,26 +14641,26 @@ public final void rule__AmentPackage__Group__2__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AmentPackage__Group__2__Impl" + // $ANTLR end "rule__TopicSpec__Group__6__Impl" - // $ANTLR start "rule__AmentPackage__Group__3" - // InternalRos.g:4695:1: rule__AmentPackage__Group__3 : rule__AmentPackage__Group__3__Impl rule__AmentPackage__Group__4 ; - public final void rule__AmentPackage__Group__3() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group_5__0" + // InternalRosParser.g:4760:1: rule__TopicSpec__Group_5__0 : rule__TopicSpec__Group_5__0__Impl rule__TopicSpec__Group_5__1 ; + public final void rule__TopicSpec__Group_5__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4699:1: ( rule__AmentPackage__Group__3__Impl rule__AmentPackage__Group__4 ) - // InternalRos.g:4700:2: rule__AmentPackage__Group__3__Impl rule__AmentPackage__Group__4 + // InternalRosParser.g:4764:1: ( rule__TopicSpec__Group_5__0__Impl rule__TopicSpec__Group_5__1 ) + // InternalRosParser.g:4765:2: rule__TopicSpec__Group_5__0__Impl rule__TopicSpec__Group_5__1 { - pushFollow(FOLLOW_18); - rule__AmentPackage__Group__3__Impl(); + pushFollow(FOLLOW_24); + rule__TopicSpec__Group_5__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group__4(); + rule__TopicSpec__Group_5__1(); state._fsp--; @@ -14644,66 +14679,28 @@ public final void rule__AmentPackage__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group__3" + // $ANTLR end "rule__TopicSpec__Group_5__0" - // $ANTLR start "rule__AmentPackage__Group__3__Impl" - // InternalRos.g:4707:1: rule__AmentPackage__Group__3__Impl : ( '{' ) ; - public final void rule__AmentPackage__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group_5__0__Impl" + // InternalRosParser.g:4772:1: rule__TopicSpec__Group_5__0__Impl : ( RULE_BEGIN ) ; + public final void rule__TopicSpec__Group_5__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4711:1: ( ( '{' ) ) - // InternalRos.g:4712:1: ( '{' ) + // InternalRosParser.g:4776:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:4777:1: ( RULE_BEGIN ) { - // InternalRos.g:4712:1: ( '{' ) - // InternalRos.g:4713:2: '{' + // InternalRosParser.g:4777:1: ( RULE_BEGIN ) + // InternalRosParser.g:4778:2: RULE_BEGIN { - before(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_3()); - match(input,41,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_3()); - - } - + before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__AmentPackage__Group__3__Impl" - - - // $ANTLR start "rule__AmentPackage__Group__4" - // InternalRos.g:4722:1: rule__AmentPackage__Group__4 : rule__AmentPackage__Group__4__Impl rule__AmentPackage__Group__5 ; - public final void rule__AmentPackage__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:4726:1: ( rule__AmentPackage__Group__4__Impl rule__AmentPackage__Group__5 ) - // InternalRos.g:4727:2: rule__AmentPackage__Group__4__Impl rule__AmentPackage__Group__5 - { - pushFollow(FOLLOW_18); - rule__AmentPackage__Group__4__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__AmentPackage__Group__5(); - - state._fsp--; - } @@ -14719,84 +14716,26 @@ public final void rule__AmentPackage__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group__4" + // $ANTLR end "rule__TopicSpec__Group_5__0__Impl" - // $ANTLR start "rule__AmentPackage__Group__4__Impl" - // InternalRos.g:4734:1: rule__AmentPackage__Group__4__Impl : ( ( rule__AmentPackage__Group_4__0 )? ) ; - public final void rule__AmentPackage__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group_5__1" + // InternalRosParser.g:4787:1: rule__TopicSpec__Group_5__1 : rule__TopicSpec__Group_5__1__Impl rule__TopicSpec__Group_5__2 ; + public final void rule__TopicSpec__Group_5__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4738:1: ( ( ( rule__AmentPackage__Group_4__0 )? ) ) - // InternalRos.g:4739:1: ( ( rule__AmentPackage__Group_4__0 )? ) + // InternalRosParser.g:4791:1: ( rule__TopicSpec__Group_5__1__Impl rule__TopicSpec__Group_5__2 ) + // InternalRosParser.g:4792:2: rule__TopicSpec__Group_5__1__Impl rule__TopicSpec__Group_5__2 { - // InternalRos.g:4739:1: ( ( rule__AmentPackage__Group_4__0 )? ) - // InternalRos.g:4740:2: ( rule__AmentPackage__Group_4__0 )? - { - before(grammarAccess.getAmentPackageAccess().getGroup_4()); - // InternalRos.g:4741:2: ( rule__AmentPackage__Group_4__0 )? - int alt28=2; - int LA28_0 = input.LA(1); - - if ( (LA28_0==45) ) { - alt28=1; - } - switch (alt28) { - case 1 : - // InternalRos.g:4741:3: rule__AmentPackage__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__AmentPackage__Group_4__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getAmentPackageAccess().getGroup_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__AmentPackage__Group__4__Impl" - - - // $ANTLR start "rule__AmentPackage__Group__5" - // InternalRos.g:4749:1: rule__AmentPackage__Group__5 : rule__AmentPackage__Group__5__Impl rule__AmentPackage__Group__6 ; - public final void rule__AmentPackage__Group__5() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:4753:1: ( rule__AmentPackage__Group__5__Impl rule__AmentPackage__Group__6 ) - // InternalRos.g:4754:2: rule__AmentPackage__Group__5__Impl rule__AmentPackage__Group__6 - { - pushFollow(FOLLOW_18); - rule__AmentPackage__Group__5__Impl(); + pushFollow(FOLLOW_25); + rule__TopicSpec__Group_5__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group__6(); + rule__TopicSpec__Group_5__2(); state._fsp--; @@ -14815,46 +14754,35 @@ public final void rule__AmentPackage__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group__5" + // $ANTLR end "rule__TopicSpec__Group_5__1" - // $ANTLR start "rule__AmentPackage__Group__5__Impl" - // InternalRos.g:4761:1: rule__AmentPackage__Group__5__Impl : ( ( rule__AmentPackage__Group_5__0 )? ) ; - public final void rule__AmentPackage__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group_5__1__Impl" + // InternalRosParser.g:4799:1: rule__TopicSpec__Group_5__1__Impl : ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) ; + public final void rule__TopicSpec__Group_5__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4765:1: ( ( ( rule__AmentPackage__Group_5__0 )? ) ) - // InternalRos.g:4766:1: ( ( rule__AmentPackage__Group_5__0 )? ) + // InternalRosParser.g:4803:1: ( ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) ) + // InternalRosParser.g:4804:1: ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) { - // InternalRos.g:4766:1: ( ( rule__AmentPackage__Group_5__0 )? ) - // InternalRos.g:4767:2: ( rule__AmentPackage__Group_5__0 )? + // InternalRosParser.g:4804:1: ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) + // InternalRosParser.g:4805:2: ( rule__TopicSpec__MessageAssignment_5_1 ) { - before(grammarAccess.getAmentPackageAccess().getGroup_5()); - // InternalRos.g:4768:2: ( rule__AmentPackage__Group_5__0 )? - int alt29=2; - int LA29_0 = input.LA(1); - - if ( (LA29_0==49) ) { - alt29=1; - } - switch (alt29) { - case 1 : - // InternalRos.g:4768:3: rule__AmentPackage__Group_5__0 - { - pushFollow(FOLLOW_2); - rule__AmentPackage__Group_5__0(); - - state._fsp--; + before(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); + // InternalRosParser.g:4806:2: ( rule__TopicSpec__MessageAssignment_5_1 ) + // InternalRosParser.g:4806:3: rule__TopicSpec__MessageAssignment_5_1 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__MessageAssignment_5_1(); + state._fsp--; - } - break; } - after(grammarAccess.getAmentPackageAccess().getGroup_5()); + after(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); } @@ -14873,26 +14801,21 @@ public final void rule__AmentPackage__Group__5__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AmentPackage__Group__5__Impl" + // $ANTLR end "rule__TopicSpec__Group_5__1__Impl" - // $ANTLR start "rule__AmentPackage__Group__6" - // InternalRos.g:4776:1: rule__AmentPackage__Group__6 : rule__AmentPackage__Group__6__Impl rule__AmentPackage__Group__7 ; - public final void rule__AmentPackage__Group__6() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group_5__2" + // InternalRosParser.g:4814:1: rule__TopicSpec__Group_5__2 : rule__TopicSpec__Group_5__2__Impl ; + public final void rule__TopicSpec__Group_5__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4780:1: ( rule__AmentPackage__Group__6__Impl rule__AmentPackage__Group__7 ) - // InternalRos.g:4781:2: rule__AmentPackage__Group__6__Impl rule__AmentPackage__Group__7 + // InternalRosParser.g:4818:1: ( rule__TopicSpec__Group_5__2__Impl ) + // InternalRosParser.g:4819:2: rule__TopicSpec__Group_5__2__Impl { - pushFollow(FOLLOW_18); - rule__AmentPackage__Group__6__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__AmentPackage__Group__7(); + rule__TopicSpec__Group_5__2__Impl(); state._fsp--; @@ -14911,46 +14834,25 @@ public final void rule__AmentPackage__Group__6() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group__6" + // $ANTLR end "rule__TopicSpec__Group_5__2" - // $ANTLR start "rule__AmentPackage__Group__6__Impl" - // InternalRos.g:4788:1: rule__AmentPackage__Group__6__Impl : ( ( rule__AmentPackage__Group_6__0 )? ) ; - public final void rule__AmentPackage__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__Group_5__2__Impl" + // InternalRosParser.g:4825:1: rule__TopicSpec__Group_5__2__Impl : ( RULE_END ) ; + public final void rule__TopicSpec__Group_5__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4792:1: ( ( ( rule__AmentPackage__Group_6__0 )? ) ) - // InternalRos.g:4793:1: ( ( rule__AmentPackage__Group_6__0 )? ) + // InternalRosParser.g:4829:1: ( ( RULE_END ) ) + // InternalRosParser.g:4830:1: ( RULE_END ) { - // InternalRos.g:4793:1: ( ( rule__AmentPackage__Group_6__0 )? ) - // InternalRos.g:4794:2: ( rule__AmentPackage__Group_6__0 )? + // InternalRosParser.g:4830:1: ( RULE_END ) + // InternalRosParser.g:4831:2: RULE_END { - before(grammarAccess.getAmentPackageAccess().getGroup_6()); - // InternalRos.g:4795:2: ( rule__AmentPackage__Group_6__0 )? - int alt30=2; - int LA30_0 = input.LA(1); - - if ( (LA30_0==46) ) { - alt30=1; - } - switch (alt30) { - case 1 : - // InternalRos.g:4795:3: rule__AmentPackage__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__AmentPackage__Group_6__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getAmentPackageAccess().getGroup_6()); + before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); } @@ -14969,26 +14871,26 @@ public final void rule__AmentPackage__Group__6__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AmentPackage__Group__6__Impl" + // $ANTLR end "rule__TopicSpec__Group_5__2__Impl" - // $ANTLR start "rule__AmentPackage__Group__7" - // InternalRos.g:4803:1: rule__AmentPackage__Group__7 : rule__AmentPackage__Group__7__Impl rule__AmentPackage__Group__8 ; - public final void rule__AmentPackage__Group__7() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__0" + // InternalRosParser.g:4841:1: rule__ServiceSpec__Group__0 : rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 ; + public final void rule__ServiceSpec__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4807:1: ( rule__AmentPackage__Group__7__Impl rule__AmentPackage__Group__8 ) - // InternalRos.g:4808:2: rule__AmentPackage__Group__7__Impl rule__AmentPackage__Group__8 + // InternalRosParser.g:4845:1: ( rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 ) + // InternalRosParser.g:4846:2: rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 { - pushFollow(FOLLOW_18); - rule__AmentPackage__Group__7__Impl(); + pushFollow(FOLLOW_26); + rule__ServiceSpec__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group__8(); + rule__ServiceSpec__Group__1(); state._fsp--; @@ -15007,46 +14909,29 @@ public final void rule__AmentPackage__Group__7() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group__7" + // $ANTLR end "rule__ServiceSpec__Group__0" - // $ANTLR start "rule__AmentPackage__Group__7__Impl" - // InternalRos.g:4815:1: rule__AmentPackage__Group__7__Impl : ( ( rule__AmentPackage__Group_7__0 )? ) ; - public final void rule__AmentPackage__Group__7__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__0__Impl" + // InternalRosParser.g:4853:1: rule__ServiceSpec__Group__0__Impl : ( () ) ; + public final void rule__ServiceSpec__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4819:1: ( ( ( rule__AmentPackage__Group_7__0 )? ) ) - // InternalRos.g:4820:1: ( ( rule__AmentPackage__Group_7__0 )? ) + // InternalRosParser.g:4857:1: ( ( () ) ) + // InternalRosParser.g:4858:1: ( () ) { - // InternalRos.g:4820:1: ( ( rule__AmentPackage__Group_7__0 )? ) - // InternalRos.g:4821:2: ( rule__AmentPackage__Group_7__0 )? + // InternalRosParser.g:4858:1: ( () ) + // InternalRosParser.g:4859:2: () + { + before(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); + // InternalRosParser.g:4860:2: () + // InternalRosParser.g:4860:3: { - before(grammarAccess.getAmentPackageAccess().getGroup_7()); - // InternalRos.g:4822:2: ( rule__AmentPackage__Group_7__0 )? - int alt31=2; - int LA31_0 = input.LA(1); - - if ( (LA31_0==47) ) { - alt31=1; - } - switch (alt31) { - case 1 : - // InternalRos.g:4822:3: rule__AmentPackage__Group_7__0 - { - pushFollow(FOLLOW_2); - rule__AmentPackage__Group_7__0(); - - state._fsp--; - - - } - break; - } - after(grammarAccess.getAmentPackageAccess().getGroup_7()); + after(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); } @@ -15054,10 +14939,6 @@ public final void rule__AmentPackage__Group__7__Impl() throws RecognitionExcepti } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -15065,21 +14946,26 @@ public final void rule__AmentPackage__Group__7__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AmentPackage__Group__7__Impl" + // $ANTLR end "rule__ServiceSpec__Group__0__Impl" - // $ANTLR start "rule__AmentPackage__Group__8" - // InternalRos.g:4830:1: rule__AmentPackage__Group__8 : rule__AmentPackage__Group__8__Impl ; - public final void rule__AmentPackage__Group__8() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__1" + // InternalRosParser.g:4868:1: rule__ServiceSpec__Group__1 : rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 ; + public final void rule__ServiceSpec__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4834:1: ( rule__AmentPackage__Group__8__Impl ) - // InternalRos.g:4835:2: rule__AmentPackage__Group__8__Impl + // InternalRosParser.g:4872:1: ( rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 ) + // InternalRosParser.g:4873:2: rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 { + pushFollow(FOLLOW_8); + rule__ServiceSpec__Group__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__AmentPackage__Group__8__Impl(); + rule__ServiceSpec__Group__2(); state._fsp--; @@ -15098,25 +14984,25 @@ public final void rule__AmentPackage__Group__8() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group__8" + // $ANTLR end "rule__ServiceSpec__Group__1" - // $ANTLR start "rule__AmentPackage__Group__8__Impl" - // InternalRos.g:4841:1: rule__AmentPackage__Group__8__Impl : ( '}' ) ; - public final void rule__AmentPackage__Group__8__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__1__Impl" + // InternalRosParser.g:4880:1: rule__ServiceSpec__Group__1__Impl : ( Srv ) ; + public final void rule__ServiceSpec__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4845:1: ( ( '}' ) ) - // InternalRos.g:4846:1: ( '}' ) + // InternalRosParser.g:4884:1: ( ( Srv ) ) + // InternalRosParser.g:4885:1: ( Srv ) { - // InternalRos.g:4846:1: ( '}' ) - // InternalRos.g:4847:2: '}' + // InternalRosParser.g:4885:1: ( Srv ) + // InternalRosParser.g:4886:2: Srv { - before(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_8()); - match(input,42,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_8()); + before(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); + match(input,Srv,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); } @@ -15135,26 +15021,26 @@ public final void rule__AmentPackage__Group__8__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AmentPackage__Group__8__Impl" + // $ANTLR end "rule__ServiceSpec__Group__1__Impl" - // $ANTLR start "rule__AmentPackage__Group_4__0" - // InternalRos.g:4857:1: rule__AmentPackage__Group_4__0 : rule__AmentPackage__Group_4__0__Impl rule__AmentPackage__Group_4__1 ; - public final void rule__AmentPackage__Group_4__0() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__2" + // InternalRosParser.g:4895:1: rule__ServiceSpec__Group__2 : rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 ; + public final void rule__ServiceSpec__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4861:1: ( rule__AmentPackage__Group_4__0__Impl rule__AmentPackage__Group_4__1 ) - // InternalRos.g:4862:2: rule__AmentPackage__Group_4__0__Impl rule__AmentPackage__Group_4__1 + // InternalRosParser.g:4899:1: ( rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 ) + // InternalRosParser.g:4900:2: rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 { - pushFollow(FOLLOW_10); - rule__AmentPackage__Group_4__0__Impl(); + pushFollow(FOLLOW_6); + rule__ServiceSpec__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group_4__1(); + rule__ServiceSpec__Group__3(); state._fsp--; @@ -15173,25 +15059,35 @@ public final void rule__AmentPackage__Group_4__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_4__0" + // $ANTLR end "rule__ServiceSpec__Group__2" - // $ANTLR start "rule__AmentPackage__Group_4__0__Impl" - // InternalRos.g:4869:1: rule__AmentPackage__Group_4__0__Impl : ( 'FromGitRepo' ) ; - public final void rule__AmentPackage__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__2__Impl" + // InternalRosParser.g:4907:1: rule__ServiceSpec__Group__2__Impl : ( ( rule__ServiceSpec__NameAssignment_2 ) ) ; + public final void rule__ServiceSpec__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4873:1: ( ( 'FromGitRepo' ) ) - // InternalRos.g:4874:1: ( 'FromGitRepo' ) + // InternalRosParser.g:4911:1: ( ( ( rule__ServiceSpec__NameAssignment_2 ) ) ) + // InternalRosParser.g:4912:1: ( ( rule__ServiceSpec__NameAssignment_2 ) ) { - // InternalRos.g:4874:1: ( 'FromGitRepo' ) - // InternalRos.g:4875:2: 'FromGitRepo' + // InternalRosParser.g:4912:1: ( ( rule__ServiceSpec__NameAssignment_2 ) ) + // InternalRosParser.g:4913:2: ( rule__ServiceSpec__NameAssignment_2 ) { - before(grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); - match(input,45,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); + before(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); + // InternalRosParser.g:4914:2: ( rule__ServiceSpec__NameAssignment_2 ) + // InternalRosParser.g:4914:3: rule__ServiceSpec__NameAssignment_2 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__NameAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); } @@ -15210,21 +15106,26 @@ public final void rule__AmentPackage__Group_4__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_4__0__Impl" + // $ANTLR end "rule__ServiceSpec__Group__2__Impl" - // $ANTLR start "rule__AmentPackage__Group_4__1" - // InternalRos.g:4884:1: rule__AmentPackage__Group_4__1 : rule__AmentPackage__Group_4__1__Impl ; - public final void rule__AmentPackage__Group_4__1() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__3" + // InternalRosParser.g:4922:1: rule__ServiceSpec__Group__3 : rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 ; + public final void rule__ServiceSpec__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4888:1: ( rule__AmentPackage__Group_4__1__Impl ) - // InternalRos.g:4889:2: rule__AmentPackage__Group_4__1__Impl + // InternalRosParser.g:4926:1: ( rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 ) + // InternalRosParser.g:4927:2: rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 { + pushFollow(FOLLOW_27); + rule__ServiceSpec__Group__3__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__AmentPackage__Group_4__1__Impl(); + rule__ServiceSpec__Group__4(); state._fsp--; @@ -15243,35 +15144,25 @@ public final void rule__AmentPackage__Group_4__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_4__1" + // $ANTLR end "rule__ServiceSpec__Group__3" - // $ANTLR start "rule__AmentPackage__Group_4__1__Impl" - // InternalRos.g:4895:1: rule__AmentPackage__Group_4__1__Impl : ( ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) ) ; - public final void rule__AmentPackage__Group_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__3__Impl" + // InternalRosParser.g:4934:1: rule__ServiceSpec__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceSpec__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4899:1: ( ( ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) ) ) - // InternalRos.g:4900:1: ( ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) ) - { - // InternalRos.g:4900:1: ( ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) ) - // InternalRos.g:4901:2: ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) + // InternalRosParser.g:4938:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:4939:1: ( RULE_BEGIN ) { - before(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_4_1()); - // InternalRos.g:4902:2: ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) - // InternalRos.g:4902:3: rule__AmentPackage__FromGitRepoAssignment_4_1 + // InternalRosParser.g:4939:1: ( RULE_BEGIN ) + // InternalRosParser.g:4940:2: RULE_BEGIN { - pushFollow(FOLLOW_2); - rule__AmentPackage__FromGitRepoAssignment_4_1(); - - state._fsp--; - - - } - - after(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_4_1()); + before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); } @@ -15290,26 +15181,26 @@ public final void rule__AmentPackage__Group_4__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_4__1__Impl" + // $ANTLR end "rule__ServiceSpec__Group__3__Impl" - // $ANTLR start "rule__AmentPackage__Group_5__0" - // InternalRos.g:4911:1: rule__AmentPackage__Group_5__0 : rule__AmentPackage__Group_5__0__Impl rule__AmentPackage__Group_5__1 ; - public final void rule__AmentPackage__Group_5__0() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__4" + // InternalRosParser.g:4949:1: rule__ServiceSpec__Group__4 : rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 ; + public final void rule__ServiceSpec__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4915:1: ( rule__AmentPackage__Group_5__0__Impl rule__AmentPackage__Group_5__1 ) - // InternalRos.g:4916:2: rule__AmentPackage__Group_5__0__Impl rule__AmentPackage__Group_5__1 + // InternalRosParser.g:4953:1: ( rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 ) + // InternalRosParser.g:4954:2: rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 { - pushFollow(FOLLOW_4); - rule__AmentPackage__Group_5__0__Impl(); + pushFollow(FOLLOW_28); + rule__ServiceSpec__Group__4__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group_5__1(); + rule__ServiceSpec__Group__5(); state._fsp--; @@ -15328,25 +15219,25 @@ public final void rule__AmentPackage__Group_5__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_5__0" + // $ANTLR end "rule__ServiceSpec__Group__4" - // $ANTLR start "rule__AmentPackage__Group_5__0__Impl" - // InternalRos.g:4923:1: rule__AmentPackage__Group_5__0__Impl : ( 'Dependencies' ) ; - public final void rule__AmentPackage__Group_5__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__4__Impl" + // InternalRosParser.g:4961:1: rule__ServiceSpec__Group__4__Impl : ( Request ) ; + public final void rule__ServiceSpec__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4927:1: ( ( 'Dependencies' ) ) - // InternalRos.g:4928:1: ( 'Dependencies' ) + // InternalRosParser.g:4965:1: ( ( Request ) ) + // InternalRosParser.g:4966:1: ( Request ) { - // InternalRos.g:4928:1: ( 'Dependencies' ) - // InternalRos.g:4929:2: 'Dependencies' + // InternalRosParser.g:4966:1: ( Request ) + // InternalRosParser.g:4967:2: Request { - before(grammarAccess.getAmentPackageAccess().getDependenciesKeyword_5_0()); - match(input,49,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getDependenciesKeyword_5_0()); + before(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); + match(input,Request,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); } @@ -15365,26 +15256,26 @@ public final void rule__AmentPackage__Group_5__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_5__0__Impl" + // $ANTLR end "rule__ServiceSpec__Group__4__Impl" - // $ANTLR start "rule__AmentPackage__Group_5__1" - // InternalRos.g:4938:1: rule__AmentPackage__Group_5__1 : rule__AmentPackage__Group_5__1__Impl rule__AmentPackage__Group_5__2 ; - public final void rule__AmentPackage__Group_5__1() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__5" + // InternalRosParser.g:4976:1: rule__ServiceSpec__Group__5 : rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 ; + public final void rule__ServiceSpec__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4942:1: ( rule__AmentPackage__Group_5__1__Impl rule__AmentPackage__Group_5__2 ) - // InternalRos.g:4943:2: rule__AmentPackage__Group_5__1__Impl rule__AmentPackage__Group_5__2 + // InternalRosParser.g:4980:1: ( rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 ) + // InternalRosParser.g:4981:2: rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 { - pushFollow(FOLLOW_19); - rule__AmentPackage__Group_5__1__Impl(); + pushFollow(FOLLOW_28); + rule__ServiceSpec__Group__5__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group_5__2(); + rule__ServiceSpec__Group__6(); state._fsp--; @@ -15403,25 +15294,46 @@ public final void rule__AmentPackage__Group_5__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_5__1" + // $ANTLR end "rule__ServiceSpec__Group__5" - // $ANTLR start "rule__AmentPackage__Group_5__1__Impl" - // InternalRos.g:4950:1: rule__AmentPackage__Group_5__1__Impl : ( '{' ) ; - public final void rule__AmentPackage__Group_5__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__5__Impl" + // InternalRosParser.g:4988:1: rule__ServiceSpec__Group__5__Impl : ( ( rule__ServiceSpec__Group_5__0 )? ) ; + public final void rule__ServiceSpec__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4954:1: ( ( '{' ) ) - // InternalRos.g:4955:1: ( '{' ) + // InternalRosParser.g:4992:1: ( ( ( rule__ServiceSpec__Group_5__0 )? ) ) + // InternalRosParser.g:4993:1: ( ( rule__ServiceSpec__Group_5__0 )? ) { - // InternalRos.g:4955:1: ( '{' ) - // InternalRos.g:4956:2: '{' + // InternalRosParser.g:4993:1: ( ( rule__ServiceSpec__Group_5__0 )? ) + // InternalRosParser.g:4994:2: ( rule__ServiceSpec__Group_5__0 )? { - before(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_5_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_5_1()); + before(grammarAccess.getServiceSpecAccess().getGroup_5()); + // InternalRosParser.g:4995:2: ( rule__ServiceSpec__Group_5__0 )? + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0==RULE_BEGIN) ) { + alt29=1; + } + switch (alt29) { + case 1 : + // InternalRosParser.g:4995:3: rule__ServiceSpec__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceSpecAccess().getGroup_5()); } @@ -15440,26 +15352,26 @@ public final void rule__AmentPackage__Group_5__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_5__1__Impl" + // $ANTLR end "rule__ServiceSpec__Group__5__Impl" - // $ANTLR start "rule__AmentPackage__Group_5__2" - // InternalRos.g:4965:1: rule__AmentPackage__Group_5__2 : rule__AmentPackage__Group_5__2__Impl rule__AmentPackage__Group_5__3 ; - public final void rule__AmentPackage__Group_5__2() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__6" + // InternalRosParser.g:5003:1: rule__ServiceSpec__Group__6 : rule__ServiceSpec__Group__6__Impl rule__ServiceSpec__Group__7 ; + public final void rule__ServiceSpec__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4969:1: ( rule__AmentPackage__Group_5__2__Impl rule__AmentPackage__Group_5__3 ) - // InternalRos.g:4970:2: rule__AmentPackage__Group_5__2__Impl rule__AmentPackage__Group_5__3 + // InternalRosParser.g:5007:1: ( rule__ServiceSpec__Group__6__Impl rule__ServiceSpec__Group__7 ) + // InternalRosParser.g:5008:2: rule__ServiceSpec__Group__6__Impl rule__ServiceSpec__Group__7 { - pushFollow(FOLLOW_13); - rule__AmentPackage__Group_5__2__Impl(); + pushFollow(FOLLOW_23); + rule__ServiceSpec__Group__6__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group_5__3(); + rule__ServiceSpec__Group__7(); state._fsp--; @@ -15478,35 +15390,25 @@ public final void rule__AmentPackage__Group_5__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_5__2" + // $ANTLR end "rule__ServiceSpec__Group__6" - // $ANTLR start "rule__AmentPackage__Group_5__2__Impl" - // InternalRos.g:4977:1: rule__AmentPackage__Group_5__2__Impl : ( ( rule__AmentPackage__DependencyAssignment_5_2 ) ) ; - public final void rule__AmentPackage__Group_5__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__6__Impl" + // InternalRosParser.g:5015:1: rule__ServiceSpec__Group__6__Impl : ( Response ) ; + public final void rule__ServiceSpec__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4981:1: ( ( ( rule__AmentPackage__DependencyAssignment_5_2 ) ) ) - // InternalRos.g:4982:1: ( ( rule__AmentPackage__DependencyAssignment_5_2 ) ) - { - // InternalRos.g:4982:1: ( ( rule__AmentPackage__DependencyAssignment_5_2 ) ) - // InternalRos.g:4983:2: ( rule__AmentPackage__DependencyAssignment_5_2 ) + // InternalRosParser.g:5019:1: ( ( Response ) ) + // InternalRosParser.g:5020:1: ( Response ) { - before(grammarAccess.getAmentPackageAccess().getDependencyAssignment_5_2()); - // InternalRos.g:4984:2: ( rule__AmentPackage__DependencyAssignment_5_2 ) - // InternalRos.g:4984:3: rule__AmentPackage__DependencyAssignment_5_2 + // InternalRosParser.g:5020:1: ( Response ) + // InternalRosParser.g:5021:2: Response { - pushFollow(FOLLOW_2); - rule__AmentPackage__DependencyAssignment_5_2(); - - state._fsp--; - - - } - - after(grammarAccess.getAmentPackageAccess().getDependencyAssignment_5_2()); + before(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); + match(input,Response,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); } @@ -15525,26 +15427,26 @@ public final void rule__AmentPackage__Group_5__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_5__2__Impl" + // $ANTLR end "rule__ServiceSpec__Group__6__Impl" - // $ANTLR start "rule__AmentPackage__Group_5__3" - // InternalRos.g:4992:1: rule__AmentPackage__Group_5__3 : rule__AmentPackage__Group_5__3__Impl rule__AmentPackage__Group_5__4 ; - public final void rule__AmentPackage__Group_5__3() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__7" + // InternalRosParser.g:5030:1: rule__ServiceSpec__Group__7 : rule__ServiceSpec__Group__7__Impl rule__ServiceSpec__Group__8 ; + public final void rule__ServiceSpec__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:4996:1: ( rule__AmentPackage__Group_5__3__Impl rule__AmentPackage__Group_5__4 ) - // InternalRos.g:4997:2: rule__AmentPackage__Group_5__3__Impl rule__AmentPackage__Group_5__4 + // InternalRosParser.g:5034:1: ( rule__ServiceSpec__Group__7__Impl rule__ServiceSpec__Group__8 ) + // InternalRosParser.g:5035:2: rule__ServiceSpec__Group__7__Impl rule__ServiceSpec__Group__8 { - pushFollow(FOLLOW_13); - rule__AmentPackage__Group_5__3__Impl(); + pushFollow(FOLLOW_23); + rule__ServiceSpec__Group__7__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group_5__4(); + rule__ServiceSpec__Group__8(); state._fsp--; @@ -15563,53 +15465,46 @@ public final void rule__AmentPackage__Group_5__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_5__3" + // $ANTLR end "rule__ServiceSpec__Group__7" - // $ANTLR start "rule__AmentPackage__Group_5__3__Impl" - // InternalRos.g:5004:1: rule__AmentPackage__Group_5__3__Impl : ( ( rule__AmentPackage__Group_5_3__0 )* ) ; - public final void rule__AmentPackage__Group_5__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__7__Impl" + // InternalRosParser.g:5042:1: rule__ServiceSpec__Group__7__Impl : ( ( rule__ServiceSpec__Group_7__0 )? ) ; + public final void rule__ServiceSpec__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5008:1: ( ( ( rule__AmentPackage__Group_5_3__0 )* ) ) - // InternalRos.g:5009:1: ( ( rule__AmentPackage__Group_5_3__0 )* ) + // InternalRosParser.g:5046:1: ( ( ( rule__ServiceSpec__Group_7__0 )? ) ) + // InternalRosParser.g:5047:1: ( ( rule__ServiceSpec__Group_7__0 )? ) { - // InternalRos.g:5009:1: ( ( rule__AmentPackage__Group_5_3__0 )* ) - // InternalRos.g:5010:2: ( rule__AmentPackage__Group_5_3__0 )* + // InternalRosParser.g:5047:1: ( ( rule__ServiceSpec__Group_7__0 )? ) + // InternalRosParser.g:5048:2: ( rule__ServiceSpec__Group_7__0 )? { - before(grammarAccess.getAmentPackageAccess().getGroup_5_3()); - // InternalRos.g:5011:2: ( rule__AmentPackage__Group_5_3__0 )* - loop32: - do { - int alt32=2; - int LA32_0 = input.LA(1); - - if ( (LA32_0==43) ) { - alt32=1; - } - + before(grammarAccess.getServiceSpecAccess().getGroup_7()); + // InternalRosParser.g:5049:2: ( rule__ServiceSpec__Group_7__0 )? + int alt30=2; + int LA30_0 = input.LA(1); - switch (alt32) { - case 1 : - // InternalRos.g:5011:3: rule__AmentPackage__Group_5_3__0 - { - pushFollow(FOLLOW_7); - rule__AmentPackage__Group_5_3__0(); + if ( (LA30_0==RULE_BEGIN) ) { + alt30=1; + } + switch (alt30) { + case 1 : + // InternalRosParser.g:5049:3: rule__ServiceSpec__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_7__0(); - state._fsp--; + state._fsp--; - } - break; + } + break; - default : - break loop32; - } - } while (true); + } - after(grammarAccess.getAmentPackageAccess().getGroup_5_3()); + after(grammarAccess.getServiceSpecAccess().getGroup_7()); } @@ -15628,21 +15523,21 @@ public final void rule__AmentPackage__Group_5__3__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_5__3__Impl" + // $ANTLR end "rule__ServiceSpec__Group__7__Impl" - // $ANTLR start "rule__AmentPackage__Group_5__4" - // InternalRos.g:5019:1: rule__AmentPackage__Group_5__4 : rule__AmentPackage__Group_5__4__Impl ; - public final void rule__AmentPackage__Group_5__4() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__8" + // InternalRosParser.g:5057:1: rule__ServiceSpec__Group__8 : rule__ServiceSpec__Group__8__Impl ; + public final void rule__ServiceSpec__Group__8() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5023:1: ( rule__AmentPackage__Group_5__4__Impl ) - // InternalRos.g:5024:2: rule__AmentPackage__Group_5__4__Impl + // InternalRosParser.g:5061:1: ( rule__ServiceSpec__Group__8__Impl ) + // InternalRosParser.g:5062:2: rule__ServiceSpec__Group__8__Impl { pushFollow(FOLLOW_2); - rule__AmentPackage__Group_5__4__Impl(); + rule__ServiceSpec__Group__8__Impl(); state._fsp--; @@ -15661,25 +15556,25 @@ public final void rule__AmentPackage__Group_5__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_5__4" + // $ANTLR end "rule__ServiceSpec__Group__8" - // $ANTLR start "rule__AmentPackage__Group_5__4__Impl" - // InternalRos.g:5030:1: rule__AmentPackage__Group_5__4__Impl : ( '}' ) ; - public final void rule__AmentPackage__Group_5__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group__8__Impl" + // InternalRosParser.g:5068:1: rule__ServiceSpec__Group__8__Impl : ( RULE_END ) ; + public final void rule__ServiceSpec__Group__8__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5034:1: ( ( '}' ) ) - // InternalRos.g:5035:1: ( '}' ) + // InternalRosParser.g:5072:1: ( ( RULE_END ) ) + // InternalRosParser.g:5073:1: ( RULE_END ) { - // InternalRos.g:5035:1: ( '}' ) - // InternalRos.g:5036:2: '}' + // InternalRosParser.g:5073:1: ( RULE_END ) + // InternalRosParser.g:5074:2: RULE_END { - before(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_5_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_5_4()); + before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); } @@ -15698,26 +15593,26 @@ public final void rule__AmentPackage__Group_5__4__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_5__4__Impl" + // $ANTLR end "rule__ServiceSpec__Group__8__Impl" - // $ANTLR start "rule__AmentPackage__Group_5_3__0" - // InternalRos.g:5046:1: rule__AmentPackage__Group_5_3__0 : rule__AmentPackage__Group_5_3__0__Impl rule__AmentPackage__Group_5_3__1 ; - public final void rule__AmentPackage__Group_5_3__0() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_5__0" + // InternalRosParser.g:5084:1: rule__ServiceSpec__Group_5__0 : rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 ; + public final void rule__ServiceSpec__Group_5__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5050:1: ( rule__AmentPackage__Group_5_3__0__Impl rule__AmentPackage__Group_5_3__1 ) - // InternalRos.g:5051:2: rule__AmentPackage__Group_5_3__0__Impl rule__AmentPackage__Group_5_3__1 + // InternalRosParser.g:5088:1: ( rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 ) + // InternalRosParser.g:5089:2: rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 { - pushFollow(FOLLOW_19); - rule__AmentPackage__Group_5_3__0__Impl(); + pushFollow(FOLLOW_24); + rule__ServiceSpec__Group_5__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group_5_3__1(); + rule__ServiceSpec__Group_5__1(); state._fsp--; @@ -15736,25 +15631,25 @@ public final void rule__AmentPackage__Group_5_3__0() throws RecognitionException } return ; } - // $ANTLR end "rule__AmentPackage__Group_5_3__0" + // $ANTLR end "rule__ServiceSpec__Group_5__0" - // $ANTLR start "rule__AmentPackage__Group_5_3__0__Impl" - // InternalRos.g:5058:1: rule__AmentPackage__Group_5_3__0__Impl : ( ',' ) ; - public final void rule__AmentPackage__Group_5_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_5__0__Impl" + // InternalRosParser.g:5096:1: rule__ServiceSpec__Group_5__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceSpec__Group_5__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5062:1: ( ( ',' ) ) - // InternalRos.g:5063:1: ( ',' ) + // InternalRosParser.g:5100:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:5101:1: ( RULE_BEGIN ) { - // InternalRos.g:5063:1: ( ',' ) - // InternalRos.g:5064:2: ',' + // InternalRosParser.g:5101:1: ( RULE_BEGIN ) + // InternalRosParser.g:5102:2: RULE_BEGIN { - before(grammarAccess.getAmentPackageAccess().getCommaKeyword_5_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getCommaKeyword_5_3_0()); + before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); } @@ -15773,21 +15668,26 @@ public final void rule__AmentPackage__Group_5_3__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__AmentPackage__Group_5_3__0__Impl" + // $ANTLR end "rule__ServiceSpec__Group_5__0__Impl" - // $ANTLR start "rule__AmentPackage__Group_5_3__1" - // InternalRos.g:5073:1: rule__AmentPackage__Group_5_3__1 : rule__AmentPackage__Group_5_3__1__Impl ; - public final void rule__AmentPackage__Group_5_3__1() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_5__1" + // InternalRosParser.g:5111:1: rule__ServiceSpec__Group_5__1 : rule__ServiceSpec__Group_5__1__Impl rule__ServiceSpec__Group_5__2 ; + public final void rule__ServiceSpec__Group_5__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5077:1: ( rule__AmentPackage__Group_5_3__1__Impl ) - // InternalRos.g:5078:2: rule__AmentPackage__Group_5_3__1__Impl + // InternalRosParser.g:5115:1: ( rule__ServiceSpec__Group_5__1__Impl rule__ServiceSpec__Group_5__2 ) + // InternalRosParser.g:5116:2: rule__ServiceSpec__Group_5__1__Impl rule__ServiceSpec__Group_5__2 { + pushFollow(FOLLOW_25); + rule__ServiceSpec__Group_5__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__AmentPackage__Group_5_3__1__Impl(); + rule__ServiceSpec__Group_5__2(); state._fsp--; @@ -15806,35 +15706,35 @@ public final void rule__AmentPackage__Group_5_3__1() throws RecognitionException } return ; } - // $ANTLR end "rule__AmentPackage__Group_5_3__1" + // $ANTLR end "rule__ServiceSpec__Group_5__1" - // $ANTLR start "rule__AmentPackage__Group_5_3__1__Impl" - // InternalRos.g:5084:1: rule__AmentPackage__Group_5_3__1__Impl : ( ( rule__AmentPackage__DependencyAssignment_5_3_1 ) ) ; - public final void rule__AmentPackage__Group_5_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_5__1__Impl" + // InternalRosParser.g:5123:1: rule__ServiceSpec__Group_5__1__Impl : ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) ; + public final void rule__ServiceSpec__Group_5__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5088:1: ( ( ( rule__AmentPackage__DependencyAssignment_5_3_1 ) ) ) - // InternalRos.g:5089:1: ( ( rule__AmentPackage__DependencyAssignment_5_3_1 ) ) + // InternalRosParser.g:5127:1: ( ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) ) + // InternalRosParser.g:5128:1: ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) { - // InternalRos.g:5089:1: ( ( rule__AmentPackage__DependencyAssignment_5_3_1 ) ) - // InternalRos.g:5090:2: ( rule__AmentPackage__DependencyAssignment_5_3_1 ) + // InternalRosParser.g:5128:1: ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) + // InternalRosParser.g:5129:2: ( rule__ServiceSpec__RequestAssignment_5_1 ) { - before(grammarAccess.getAmentPackageAccess().getDependencyAssignment_5_3_1()); - // InternalRos.g:5091:2: ( rule__AmentPackage__DependencyAssignment_5_3_1 ) - // InternalRos.g:5091:3: rule__AmentPackage__DependencyAssignment_5_3_1 + before(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); + // InternalRosParser.g:5130:2: ( rule__ServiceSpec__RequestAssignment_5_1 ) + // InternalRosParser.g:5130:3: rule__ServiceSpec__RequestAssignment_5_1 { pushFollow(FOLLOW_2); - rule__AmentPackage__DependencyAssignment_5_3_1(); + rule__ServiceSpec__RequestAssignment_5_1(); state._fsp--; } - after(grammarAccess.getAmentPackageAccess().getDependencyAssignment_5_3_1()); + after(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); } @@ -15853,26 +15753,21 @@ public final void rule__AmentPackage__Group_5_3__1__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__AmentPackage__Group_5_3__1__Impl" + // $ANTLR end "rule__ServiceSpec__Group_5__1__Impl" - // $ANTLR start "rule__AmentPackage__Group_6__0" - // InternalRos.g:5100:1: rule__AmentPackage__Group_6__0 : rule__AmentPackage__Group_6__0__Impl rule__AmentPackage__Group_6__1 ; - public final void rule__AmentPackage__Group_6__0() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_5__2" + // InternalRosParser.g:5138:1: rule__ServiceSpec__Group_5__2 : rule__ServiceSpec__Group_5__2__Impl ; + public final void rule__ServiceSpec__Group_5__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5104:1: ( rule__AmentPackage__Group_6__0__Impl rule__AmentPackage__Group_6__1 ) - // InternalRos.g:5105:2: rule__AmentPackage__Group_6__0__Impl rule__AmentPackage__Group_6__1 + // InternalRosParser.g:5142:1: ( rule__ServiceSpec__Group_5__2__Impl ) + // InternalRosParser.g:5143:2: rule__ServiceSpec__Group_5__2__Impl { - pushFollow(FOLLOW_4); - rule__AmentPackage__Group_6__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__AmentPackage__Group_6__1(); + rule__ServiceSpec__Group_5__2__Impl(); state._fsp--; @@ -15891,25 +15786,25 @@ public final void rule__AmentPackage__Group_6__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_6__0" + // $ANTLR end "rule__ServiceSpec__Group_5__2" - // $ANTLR start "rule__AmentPackage__Group_6__0__Impl" - // InternalRos.g:5112:1: rule__AmentPackage__Group_6__0__Impl : ( 'Specs' ) ; - public final void rule__AmentPackage__Group_6__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_5__2__Impl" + // InternalRosParser.g:5149:1: rule__ServiceSpec__Group_5__2__Impl : ( RULE_END ) ; + public final void rule__ServiceSpec__Group_5__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5116:1: ( ( 'Specs' ) ) - // InternalRos.g:5117:1: ( 'Specs' ) + // InternalRosParser.g:5153:1: ( ( RULE_END ) ) + // InternalRosParser.g:5154:1: ( RULE_END ) { - // InternalRos.g:5117:1: ( 'Specs' ) - // InternalRos.g:5118:2: 'Specs' + // InternalRosParser.g:5154:1: ( RULE_END ) + // InternalRosParser.g:5155:2: RULE_END { - before(grammarAccess.getAmentPackageAccess().getSpecsKeyword_6_0()); - match(input,46,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getSpecsKeyword_6_0()); + before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); } @@ -15928,26 +15823,26 @@ public final void rule__AmentPackage__Group_6__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_6__0__Impl" + // $ANTLR end "rule__ServiceSpec__Group_5__2__Impl" - // $ANTLR start "rule__AmentPackage__Group_6__1" - // InternalRos.g:5127:1: rule__AmentPackage__Group_6__1 : rule__AmentPackage__Group_6__1__Impl rule__AmentPackage__Group_6__2 ; - public final void rule__AmentPackage__Group_6__1() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_7__0" + // InternalRosParser.g:5165:1: rule__ServiceSpec__Group_7__0 : rule__ServiceSpec__Group_7__0__Impl rule__ServiceSpec__Group_7__1 ; + public final void rule__ServiceSpec__Group_7__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5131:1: ( rule__AmentPackage__Group_6__1__Impl rule__AmentPackage__Group_6__2 ) - // InternalRos.g:5132:2: rule__AmentPackage__Group_6__1__Impl rule__AmentPackage__Group_6__2 + // InternalRosParser.g:5169:1: ( rule__ServiceSpec__Group_7__0__Impl rule__ServiceSpec__Group_7__1 ) + // InternalRosParser.g:5170:2: rule__ServiceSpec__Group_7__0__Impl rule__ServiceSpec__Group_7__1 { - pushFollow(FOLLOW_12); - rule__AmentPackage__Group_6__1__Impl(); + pushFollow(FOLLOW_24); + rule__ServiceSpec__Group_7__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group_6__2(); + rule__ServiceSpec__Group_7__1(); state._fsp--; @@ -15966,25 +15861,25 @@ public final void rule__AmentPackage__Group_6__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_6__1" + // $ANTLR end "rule__ServiceSpec__Group_7__0" - // $ANTLR start "rule__AmentPackage__Group_6__1__Impl" - // InternalRos.g:5139:1: rule__AmentPackage__Group_6__1__Impl : ( '{' ) ; - public final void rule__AmentPackage__Group_6__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_7__0__Impl" + // InternalRosParser.g:5177:1: rule__ServiceSpec__Group_7__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceSpec__Group_7__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5143:1: ( ( '{' ) ) - // InternalRos.g:5144:1: ( '{' ) + // InternalRosParser.g:5181:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:5182:1: ( RULE_BEGIN ) { - // InternalRos.g:5144:1: ( '{' ) - // InternalRos.g:5145:2: '{' + // InternalRosParser.g:5182:1: ( RULE_BEGIN ) + // InternalRosParser.g:5183:2: RULE_BEGIN { - before(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_6_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_6_1()); + before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); } @@ -16003,26 +15898,26 @@ public final void rule__AmentPackage__Group_6__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_6__1__Impl" + // $ANTLR end "rule__ServiceSpec__Group_7__0__Impl" - // $ANTLR start "rule__AmentPackage__Group_6__2" - // InternalRos.g:5154:1: rule__AmentPackage__Group_6__2 : rule__AmentPackage__Group_6__2__Impl rule__AmentPackage__Group_6__3 ; - public final void rule__AmentPackage__Group_6__2() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_7__1" + // InternalRosParser.g:5192:1: rule__ServiceSpec__Group_7__1 : rule__ServiceSpec__Group_7__1__Impl rule__ServiceSpec__Group_7__2 ; + public final void rule__ServiceSpec__Group_7__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5158:1: ( rule__AmentPackage__Group_6__2__Impl rule__AmentPackage__Group_6__3 ) - // InternalRos.g:5159:2: rule__AmentPackage__Group_6__2__Impl rule__AmentPackage__Group_6__3 + // InternalRosParser.g:5196:1: ( rule__ServiceSpec__Group_7__1__Impl rule__ServiceSpec__Group_7__2 ) + // InternalRosParser.g:5197:2: rule__ServiceSpec__Group_7__1__Impl rule__ServiceSpec__Group_7__2 { - pushFollow(FOLLOW_13); - rule__AmentPackage__Group_6__2__Impl(); + pushFollow(FOLLOW_25); + rule__ServiceSpec__Group_7__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group_6__3(); + rule__ServiceSpec__Group_7__2(); state._fsp--; @@ -16041,35 +15936,35 @@ public final void rule__AmentPackage__Group_6__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_6__2" + // $ANTLR end "rule__ServiceSpec__Group_7__1" - // $ANTLR start "rule__AmentPackage__Group_6__2__Impl" - // InternalRos.g:5166:1: rule__AmentPackage__Group_6__2__Impl : ( ( rule__AmentPackage__SpecAssignment_6_2 ) ) ; - public final void rule__AmentPackage__Group_6__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_7__1__Impl" + // InternalRosParser.g:5204:1: rule__ServiceSpec__Group_7__1__Impl : ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) ; + public final void rule__ServiceSpec__Group_7__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5170:1: ( ( ( rule__AmentPackage__SpecAssignment_6_2 ) ) ) - // InternalRos.g:5171:1: ( ( rule__AmentPackage__SpecAssignment_6_2 ) ) + // InternalRosParser.g:5208:1: ( ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) ) + // InternalRosParser.g:5209:1: ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) { - // InternalRos.g:5171:1: ( ( rule__AmentPackage__SpecAssignment_6_2 ) ) - // InternalRos.g:5172:2: ( rule__AmentPackage__SpecAssignment_6_2 ) + // InternalRosParser.g:5209:1: ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) + // InternalRosParser.g:5210:2: ( rule__ServiceSpec__ResponseAssignment_7_1 ) { - before(grammarAccess.getAmentPackageAccess().getSpecAssignment_6_2()); - // InternalRos.g:5173:2: ( rule__AmentPackage__SpecAssignment_6_2 ) - // InternalRos.g:5173:3: rule__AmentPackage__SpecAssignment_6_2 + before(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); + // InternalRosParser.g:5211:2: ( rule__ServiceSpec__ResponseAssignment_7_1 ) + // InternalRosParser.g:5211:3: rule__ServiceSpec__ResponseAssignment_7_1 { pushFollow(FOLLOW_2); - rule__AmentPackage__SpecAssignment_6_2(); + rule__ServiceSpec__ResponseAssignment_7_1(); state._fsp--; } - after(grammarAccess.getAmentPackageAccess().getSpecAssignment_6_2()); + after(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); } @@ -16088,26 +15983,21 @@ public final void rule__AmentPackage__Group_6__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_6__2__Impl" + // $ANTLR end "rule__ServiceSpec__Group_7__1__Impl" - // $ANTLR start "rule__AmentPackage__Group_6__3" - // InternalRos.g:5181:1: rule__AmentPackage__Group_6__3 : rule__AmentPackage__Group_6__3__Impl rule__AmentPackage__Group_6__4 ; - public final void rule__AmentPackage__Group_6__3() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_7__2" + // InternalRosParser.g:5219:1: rule__ServiceSpec__Group_7__2 : rule__ServiceSpec__Group_7__2__Impl ; + public final void rule__ServiceSpec__Group_7__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5185:1: ( rule__AmentPackage__Group_6__3__Impl rule__AmentPackage__Group_6__4 ) - // InternalRos.g:5186:2: rule__AmentPackage__Group_6__3__Impl rule__AmentPackage__Group_6__4 + // InternalRosParser.g:5223:1: ( rule__ServiceSpec__Group_7__2__Impl ) + // InternalRosParser.g:5224:2: rule__ServiceSpec__Group_7__2__Impl { - pushFollow(FOLLOW_13); - rule__AmentPackage__Group_6__3__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__AmentPackage__Group_6__4(); + rule__ServiceSpec__Group_7__2__Impl(); state._fsp--; @@ -16126,53 +16016,25 @@ public final void rule__AmentPackage__Group_6__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_6__3" + // $ANTLR end "rule__ServiceSpec__Group_7__2" - // $ANTLR start "rule__AmentPackage__Group_6__3__Impl" - // InternalRos.g:5193:1: rule__AmentPackage__Group_6__3__Impl : ( ( rule__AmentPackage__Group_6_3__0 )* ) ; - public final void rule__AmentPackage__Group_6__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__Group_7__2__Impl" + // InternalRosParser.g:5230:1: rule__ServiceSpec__Group_7__2__Impl : ( RULE_END ) ; + public final void rule__ServiceSpec__Group_7__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5197:1: ( ( ( rule__AmentPackage__Group_6_3__0 )* ) ) - // InternalRos.g:5198:1: ( ( rule__AmentPackage__Group_6_3__0 )* ) + // InternalRosParser.g:5234:1: ( ( RULE_END ) ) + // InternalRosParser.g:5235:1: ( RULE_END ) { - // InternalRos.g:5198:1: ( ( rule__AmentPackage__Group_6_3__0 )* ) - // InternalRos.g:5199:2: ( rule__AmentPackage__Group_6_3__0 )* + // InternalRosParser.g:5235:1: ( RULE_END ) + // InternalRosParser.g:5236:2: RULE_END { - before(grammarAccess.getAmentPackageAccess().getGroup_6_3()); - // InternalRos.g:5200:2: ( rule__AmentPackage__Group_6_3__0 )* - loop33: - do { - int alt33=2; - int LA33_0 = input.LA(1); - - if ( (LA33_0==43) ) { - alt33=1; - } - - - switch (alt33) { - case 1 : - // InternalRos.g:5200:3: rule__AmentPackage__Group_6_3__0 - { - pushFollow(FOLLOW_7); - rule__AmentPackage__Group_6_3__0(); - - state._fsp--; - - - } - break; - - default : - break loop33; - } - } while (true); - - after(grammarAccess.getAmentPackageAccess().getGroup_6_3()); + before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); } @@ -16191,21 +16053,26 @@ public final void rule__AmentPackage__Group_6__3__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_6__3__Impl" + // $ANTLR end "rule__ServiceSpec__Group_7__2__Impl" - // $ANTLR start "rule__AmentPackage__Group_6__4" - // InternalRos.g:5208:1: rule__AmentPackage__Group_6__4 : rule__AmentPackage__Group_6__4__Impl ; - public final void rule__AmentPackage__Group_6__4() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__0" + // InternalRosParser.g:5246:1: rule__ActionSpec__Group__0 : rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 ; + public final void rule__ActionSpec__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5212:1: ( rule__AmentPackage__Group_6__4__Impl ) - // InternalRos.g:5213:2: rule__AmentPackage__Group_6__4__Impl + // InternalRosParser.g:5250:1: ( rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 ) + // InternalRosParser.g:5251:2: rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 { + pushFollow(FOLLOW_29); + rule__ActionSpec__Group__0__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__AmentPackage__Group_6__4__Impl(); + rule__ActionSpec__Group__1(); state._fsp--; @@ -16224,25 +16091,29 @@ public final void rule__AmentPackage__Group_6__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_6__4" + // $ANTLR end "rule__ActionSpec__Group__0" - // $ANTLR start "rule__AmentPackage__Group_6__4__Impl" - // InternalRos.g:5219:1: rule__AmentPackage__Group_6__4__Impl : ( '}' ) ; - public final void rule__AmentPackage__Group_6__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__0__Impl" + // InternalRosParser.g:5258:1: rule__ActionSpec__Group__0__Impl : ( () ) ; + public final void rule__ActionSpec__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5223:1: ( ( '}' ) ) - // InternalRos.g:5224:1: ( '}' ) + // InternalRosParser.g:5262:1: ( ( () ) ) + // InternalRosParser.g:5263:1: ( () ) { - // InternalRos.g:5224:1: ( '}' ) - // InternalRos.g:5225:2: '}' + // InternalRosParser.g:5263:1: ( () ) + // InternalRosParser.g:5264:2: () + { + before(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); + // InternalRosParser.g:5265:2: () + // InternalRosParser.g:5265:3: { - before(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_6_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_6_4()); + } + + after(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); } @@ -16250,10 +16121,6 @@ public final void rule__AmentPackage__Group_6__4__Impl() throws RecognitionExcep } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -16261,26 +16128,26 @@ public final void rule__AmentPackage__Group_6__4__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_6__4__Impl" + // $ANTLR end "rule__ActionSpec__Group__0__Impl" - // $ANTLR start "rule__AmentPackage__Group_6_3__0" - // InternalRos.g:5235:1: rule__AmentPackage__Group_6_3__0 : rule__AmentPackage__Group_6_3__0__Impl rule__AmentPackage__Group_6_3__1 ; - public final void rule__AmentPackage__Group_6_3__0() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__1" + // InternalRosParser.g:5273:1: rule__ActionSpec__Group__1 : rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 ; + public final void rule__ActionSpec__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5239:1: ( rule__AmentPackage__Group_6_3__0__Impl rule__AmentPackage__Group_6_3__1 ) - // InternalRos.g:5240:2: rule__AmentPackage__Group_6_3__0__Impl rule__AmentPackage__Group_6_3__1 + // InternalRosParser.g:5277:1: ( rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 ) + // InternalRosParser.g:5278:2: rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 { - pushFollow(FOLLOW_12); - rule__AmentPackage__Group_6_3__0__Impl(); + pushFollow(FOLLOW_8); + rule__ActionSpec__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group_6_3__1(); + rule__ActionSpec__Group__2(); state._fsp--; @@ -16299,25 +16166,25 @@ public final void rule__AmentPackage__Group_6_3__0() throws RecognitionException } return ; } - // $ANTLR end "rule__AmentPackage__Group_6_3__0" + // $ANTLR end "rule__ActionSpec__Group__1" - // $ANTLR start "rule__AmentPackage__Group_6_3__0__Impl" - // InternalRos.g:5247:1: rule__AmentPackage__Group_6_3__0__Impl : ( ',' ) ; - public final void rule__AmentPackage__Group_6_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__1__Impl" + // InternalRosParser.g:5285:1: rule__ActionSpec__Group__1__Impl : ( Action_1 ) ; + public final void rule__ActionSpec__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5251:1: ( ( ',' ) ) - // InternalRos.g:5252:1: ( ',' ) + // InternalRosParser.g:5289:1: ( ( Action_1 ) ) + // InternalRosParser.g:5290:1: ( Action_1 ) { - // InternalRos.g:5252:1: ( ',' ) - // InternalRos.g:5253:2: ',' + // InternalRosParser.g:5290:1: ( Action_1 ) + // InternalRosParser.g:5291:2: Action_1 { - before(grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); + before(grammarAccess.getActionSpecAccess().getActionKeyword_1()); + match(input,Action_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getActionKeyword_1()); } @@ -16336,21 +16203,26 @@ public final void rule__AmentPackage__Group_6_3__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__AmentPackage__Group_6_3__0__Impl" + // $ANTLR end "rule__ActionSpec__Group__1__Impl" - // $ANTLR start "rule__AmentPackage__Group_6_3__1" - // InternalRos.g:5262:1: rule__AmentPackage__Group_6_3__1 : rule__AmentPackage__Group_6_3__1__Impl ; - public final void rule__AmentPackage__Group_6_3__1() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__2" + // InternalRosParser.g:5300:1: rule__ActionSpec__Group__2 : rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 ; + public final void rule__ActionSpec__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5266:1: ( rule__AmentPackage__Group_6_3__1__Impl ) - // InternalRos.g:5267:2: rule__AmentPackage__Group_6_3__1__Impl + // InternalRosParser.g:5304:1: ( rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 ) + // InternalRosParser.g:5305:2: rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 { + pushFollow(FOLLOW_6); + rule__ActionSpec__Group__2__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__AmentPackage__Group_6_3__1__Impl(); + rule__ActionSpec__Group__3(); state._fsp--; @@ -16369,35 +16241,35 @@ public final void rule__AmentPackage__Group_6_3__1() throws RecognitionException } return ; } - // $ANTLR end "rule__AmentPackage__Group_6_3__1" + // $ANTLR end "rule__ActionSpec__Group__2" - // $ANTLR start "rule__AmentPackage__Group_6_3__1__Impl" - // InternalRos.g:5273:1: rule__AmentPackage__Group_6_3__1__Impl : ( ( rule__AmentPackage__SpecAssignment_6_3_1 ) ) ; - public final void rule__AmentPackage__Group_6_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__2__Impl" + // InternalRosParser.g:5312:1: rule__ActionSpec__Group__2__Impl : ( ( rule__ActionSpec__NameAssignment_2 ) ) ; + public final void rule__ActionSpec__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5277:1: ( ( ( rule__AmentPackage__SpecAssignment_6_3_1 ) ) ) - // InternalRos.g:5278:1: ( ( rule__AmentPackage__SpecAssignment_6_3_1 ) ) + // InternalRosParser.g:5316:1: ( ( ( rule__ActionSpec__NameAssignment_2 ) ) ) + // InternalRosParser.g:5317:1: ( ( rule__ActionSpec__NameAssignment_2 ) ) { - // InternalRos.g:5278:1: ( ( rule__AmentPackage__SpecAssignment_6_3_1 ) ) - // InternalRos.g:5279:2: ( rule__AmentPackage__SpecAssignment_6_3_1 ) + // InternalRosParser.g:5317:1: ( ( rule__ActionSpec__NameAssignment_2 ) ) + // InternalRosParser.g:5318:2: ( rule__ActionSpec__NameAssignment_2 ) { - before(grammarAccess.getAmentPackageAccess().getSpecAssignment_6_3_1()); - // InternalRos.g:5280:2: ( rule__AmentPackage__SpecAssignment_6_3_1 ) - // InternalRos.g:5280:3: rule__AmentPackage__SpecAssignment_6_3_1 + before(grammarAccess.getActionSpecAccess().getNameAssignment_2()); + // InternalRosParser.g:5319:2: ( rule__ActionSpec__NameAssignment_2 ) + // InternalRosParser.g:5319:3: rule__ActionSpec__NameAssignment_2 { pushFollow(FOLLOW_2); - rule__AmentPackage__SpecAssignment_6_3_1(); + rule__ActionSpec__NameAssignment_2(); state._fsp--; } - after(grammarAccess.getAmentPackageAccess().getSpecAssignment_6_3_1()); + after(grammarAccess.getActionSpecAccess().getNameAssignment_2()); } @@ -16416,26 +16288,26 @@ public final void rule__AmentPackage__Group_6_3__1__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__AmentPackage__Group_6_3__1__Impl" + // $ANTLR end "rule__ActionSpec__Group__2__Impl" - // $ANTLR start "rule__AmentPackage__Group_7__0" - // InternalRos.g:5289:1: rule__AmentPackage__Group_7__0 : rule__AmentPackage__Group_7__0__Impl rule__AmentPackage__Group_7__1 ; - public final void rule__AmentPackage__Group_7__0() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__3" + // InternalRosParser.g:5327:1: rule__ActionSpec__Group__3 : rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 ; + public final void rule__ActionSpec__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5293:1: ( rule__AmentPackage__Group_7__0__Impl rule__AmentPackage__Group_7__1 ) - // InternalRos.g:5294:2: rule__AmentPackage__Group_7__0__Impl rule__AmentPackage__Group_7__1 + // InternalRosParser.g:5331:1: ( rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 ) + // InternalRosParser.g:5332:2: rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 { - pushFollow(FOLLOW_6); - rule__AmentPackage__Group_7__0__Impl(); + pushFollow(FOLLOW_30); + rule__ActionSpec__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group_7__1(); + rule__ActionSpec__Group__4(); state._fsp--; @@ -16454,35 +16326,100 @@ public final void rule__AmentPackage__Group_7__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_7__0" + // $ANTLR end "rule__ActionSpec__Group__3" - // $ANTLR start "rule__AmentPackage__Group_7__0__Impl" - // InternalRos.g:5301:1: rule__AmentPackage__Group_7__0__Impl : ( ( rule__AmentPackage__ArtifactAssignment_7_0 ) ) ; - public final void rule__AmentPackage__Group_7__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__3__Impl" + // InternalRosParser.g:5339:1: rule__ActionSpec__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5305:1: ( ( ( rule__AmentPackage__ArtifactAssignment_7_0 ) ) ) - // InternalRos.g:5306:1: ( ( rule__AmentPackage__ArtifactAssignment_7_0 ) ) + // InternalRosParser.g:5343:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:5344:1: ( RULE_BEGIN ) { - // InternalRos.g:5306:1: ( ( rule__AmentPackage__ArtifactAssignment_7_0 ) ) - // InternalRos.g:5307:2: ( rule__AmentPackage__ArtifactAssignment_7_0 ) + // InternalRosParser.g:5344:1: ( RULE_BEGIN ) + // InternalRosParser.g:5345:2: RULE_BEGIN { - before(grammarAccess.getAmentPackageAccess().getArtifactAssignment_7_0()); - // InternalRos.g:5308:2: ( rule__AmentPackage__ArtifactAssignment_7_0 ) - // InternalRos.g:5308:3: rule__AmentPackage__ArtifactAssignment_7_0 + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__3__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__4" + // InternalRosParser.g:5354:1: rule__ActionSpec__Group__4 : rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 ; + public final void rule__ActionSpec__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:5358:1: ( rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 ) + // InternalRosParser.g:5359:2: rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 { + pushFollow(FOLLOW_31); + rule__ActionSpec__Group__4__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__AmentPackage__ArtifactAssignment_7_0(); + rule__ActionSpec__Group__5(); state._fsp--; } - after(grammarAccess.getAmentPackageAccess().getArtifactAssignment_7_0()); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__4" + + + // $ANTLR start "rule__ActionSpec__Group__4__Impl" + // InternalRosParser.g:5366:1: rule__ActionSpec__Group__4__Impl : ( Goal_1 ) ; + public final void rule__ActionSpec__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:5370:1: ( ( Goal_1 ) ) + // InternalRosParser.g:5371:1: ( Goal_1 ) + { + // InternalRosParser.g:5371:1: ( Goal_1 ) + // InternalRosParser.g:5372:2: Goal_1 + { + before(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); + match(input,Goal_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); } @@ -16501,21 +16438,26 @@ public final void rule__AmentPackage__Group_7__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_7__0__Impl" + // $ANTLR end "rule__ActionSpec__Group__4__Impl" - // $ANTLR start "rule__AmentPackage__Group_7__1" - // InternalRos.g:5316:1: rule__AmentPackage__Group_7__1 : rule__AmentPackage__Group_7__1__Impl ; - public final void rule__AmentPackage__Group_7__1() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__5" + // InternalRosParser.g:5381:1: rule__ActionSpec__Group__5 : rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 ; + public final void rule__ActionSpec__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5320:1: ( rule__AmentPackage__Group_7__1__Impl ) - // InternalRos.g:5321:2: rule__AmentPackage__Group_7__1__Impl + // InternalRosParser.g:5385:1: ( rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 ) + // InternalRosParser.g:5386:2: rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 { + pushFollow(FOLLOW_31); + rule__ActionSpec__Group__5__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__AmentPackage__Group_7__1__Impl(); + rule__ActionSpec__Group__6(); state._fsp--; @@ -16534,56 +16476,87 @@ public final void rule__AmentPackage__Group_7__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__AmentPackage__Group_7__1" + // $ANTLR end "rule__ActionSpec__Group__5" - // $ANTLR start "rule__AmentPackage__Group_7__1__Impl" - // InternalRos.g:5327:1: rule__AmentPackage__Group_7__1__Impl : ( ( rule__AmentPackage__Group_7_1__0 )* ) ; - public final void rule__AmentPackage__Group_7__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__5__Impl" + // InternalRosParser.g:5393:1: rule__ActionSpec__Group__5__Impl : ( ( rule__ActionSpec__Group_5__0 )? ) ; + public final void rule__ActionSpec__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5331:1: ( ( ( rule__AmentPackage__Group_7_1__0 )* ) ) - // InternalRos.g:5332:1: ( ( rule__AmentPackage__Group_7_1__0 )* ) + // InternalRosParser.g:5397:1: ( ( ( rule__ActionSpec__Group_5__0 )? ) ) + // InternalRosParser.g:5398:1: ( ( rule__ActionSpec__Group_5__0 )? ) { - // InternalRos.g:5332:1: ( ( rule__AmentPackage__Group_7_1__0 )* ) - // InternalRos.g:5333:2: ( rule__AmentPackage__Group_7_1__0 )* + // InternalRosParser.g:5398:1: ( ( rule__ActionSpec__Group_5__0 )? ) + // InternalRosParser.g:5399:2: ( rule__ActionSpec__Group_5__0 )? { - before(grammarAccess.getAmentPackageAccess().getGroup_7_1()); - // InternalRos.g:5334:2: ( rule__AmentPackage__Group_7_1__0 )* - loop34: - do { - int alt34=2; - int LA34_0 = input.LA(1); + before(grammarAccess.getActionSpecAccess().getGroup_5()); + // InternalRosParser.g:5400:2: ( rule__ActionSpec__Group_5__0 )? + int alt31=2; + int LA31_0 = input.LA(1); - if ( (LA34_0==43) ) { - alt34=1; - } + if ( (LA31_0==RULE_BEGIN) ) { + alt31=1; + } + switch (alt31) { + case 1 : + // InternalRosParser.g:5400:3: rule__ActionSpec__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_5__0(); + state._fsp--; - switch (alt34) { - case 1 : - // InternalRos.g:5334:3: rule__AmentPackage__Group_7_1__0 - { - pushFollow(FOLLOW_7); - rule__AmentPackage__Group_7_1__0(); - state._fsp--; + } + break; + } - } - break; + after(grammarAccess.getActionSpecAccess().getGroup_5()); - default : - break loop34; - } - } while (true); + } - after(grammarAccess.getAmentPackageAccess().getGroup_7_1()); } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__5__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__6" + // InternalRosParser.g:5408:1: rule__ActionSpec__Group__6 : rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 ; + public final void rule__ActionSpec__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:5412:1: ( rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 ) + // InternalRosParser.g:5413:2: rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 + { + pushFollow(FOLLOW_32); + rule__ActionSpec__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__7(); + + state._fsp--; + } @@ -16599,26 +16572,63 @@ public final void rule__AmentPackage__Group_7__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__Group_7__1__Impl" + // $ANTLR end "rule__ActionSpec__Group__6" - // $ANTLR start "rule__AmentPackage__Group_7_1__0" - // InternalRos.g:5343:1: rule__AmentPackage__Group_7_1__0 : rule__AmentPackage__Group_7_1__0__Impl rule__AmentPackage__Group_7_1__1 ; - public final void rule__AmentPackage__Group_7_1__0() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__6__Impl" + // InternalRosParser.g:5420:1: rule__ActionSpec__Group__6__Impl : ( Result_1 ) ; + public final void rule__ActionSpec__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:5424:1: ( ( Result_1 ) ) + // InternalRosParser.g:5425:1: ( Result_1 ) + { + // InternalRosParser.g:5425:1: ( Result_1 ) + // InternalRosParser.g:5426:2: Result_1 + { + before(grammarAccess.getActionSpecAccess().getResultKeyword_6()); + match(input,Result_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getResultKeyword_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__6__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__7" + // InternalRosParser.g:5435:1: rule__ActionSpec__Group__7 : rule__ActionSpec__Group__7__Impl rule__ActionSpec__Group__8 ; + public final void rule__ActionSpec__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5347:1: ( rule__AmentPackage__Group_7_1__0__Impl rule__AmentPackage__Group_7_1__1 ) - // InternalRos.g:5348:2: rule__AmentPackage__Group_7_1__0__Impl rule__AmentPackage__Group_7_1__1 + // InternalRosParser.g:5439:1: ( rule__ActionSpec__Group__7__Impl rule__ActionSpec__Group__8 ) + // InternalRosParser.g:5440:2: rule__ActionSpec__Group__7__Impl rule__ActionSpec__Group__8 { - pushFollow(FOLLOW_14); - rule__AmentPackage__Group_7_1__0__Impl(); + pushFollow(FOLLOW_32); + rule__ActionSpec__Group__7__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__AmentPackage__Group_7_1__1(); + rule__ActionSpec__Group__8(); state._fsp--; @@ -16637,25 +16647,46 @@ public final void rule__AmentPackage__Group_7_1__0() throws RecognitionException } return ; } - // $ANTLR end "rule__AmentPackage__Group_7_1__0" + // $ANTLR end "rule__ActionSpec__Group__7" - // $ANTLR start "rule__AmentPackage__Group_7_1__0__Impl" - // InternalRos.g:5355:1: rule__AmentPackage__Group_7_1__0__Impl : ( ',' ) ; - public final void rule__AmentPackage__Group_7_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__7__Impl" + // InternalRosParser.g:5447:1: rule__ActionSpec__Group__7__Impl : ( ( rule__ActionSpec__Group_7__0 )? ) ; + public final void rule__ActionSpec__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5359:1: ( ( ',' ) ) - // InternalRos.g:5360:1: ( ',' ) + // InternalRosParser.g:5451:1: ( ( ( rule__ActionSpec__Group_7__0 )? ) ) + // InternalRosParser.g:5452:1: ( ( rule__ActionSpec__Group_7__0 )? ) { - // InternalRos.g:5360:1: ( ',' ) - // InternalRos.g:5361:2: ',' + // InternalRosParser.g:5452:1: ( ( rule__ActionSpec__Group_7__0 )? ) + // InternalRosParser.g:5453:2: ( rule__ActionSpec__Group_7__0 )? { - before(grammarAccess.getAmentPackageAccess().getCommaKeyword_7_1_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getAmentPackageAccess().getCommaKeyword_7_1_0()); + before(grammarAccess.getActionSpecAccess().getGroup_7()); + // InternalRosParser.g:5454:2: ( rule__ActionSpec__Group_7__0 )? + int alt32=2; + int LA32_0 = input.LA(1); + + if ( (LA32_0==RULE_BEGIN) ) { + alt32=1; + } + switch (alt32) { + case 1 : + // InternalRosParser.g:5454:3: rule__ActionSpec__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionSpecAccess().getGroup_7()); } @@ -16674,21 +16705,26 @@ public final void rule__AmentPackage__Group_7_1__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__AmentPackage__Group_7_1__0__Impl" + // $ANTLR end "rule__ActionSpec__Group__7__Impl" - // $ANTLR start "rule__AmentPackage__Group_7_1__1" - // InternalRos.g:5370:1: rule__AmentPackage__Group_7_1__1 : rule__AmentPackage__Group_7_1__1__Impl ; - public final void rule__AmentPackage__Group_7_1__1() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__8" + // InternalRosParser.g:5462:1: rule__ActionSpec__Group__8 : rule__ActionSpec__Group__8__Impl rule__ActionSpec__Group__9 ; + public final void rule__ActionSpec__Group__8() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5374:1: ( rule__AmentPackage__Group_7_1__1__Impl ) - // InternalRos.g:5375:2: rule__AmentPackage__Group_7_1__1__Impl + // InternalRosParser.g:5466:1: ( rule__ActionSpec__Group__8__Impl rule__ActionSpec__Group__9 ) + // InternalRosParser.g:5467:2: rule__ActionSpec__Group__8__Impl rule__ActionSpec__Group__9 { + pushFollow(FOLLOW_23); + rule__ActionSpec__Group__8__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__AmentPackage__Group_7_1__1__Impl(); + rule__ActionSpec__Group__9(); state._fsp--; @@ -16707,35 +16743,121 @@ public final void rule__AmentPackage__Group_7_1__1() throws RecognitionException } return ; } - // $ANTLR end "rule__AmentPackage__Group_7_1__1" + // $ANTLR end "rule__ActionSpec__Group__8" - // $ANTLR start "rule__AmentPackage__Group_7_1__1__Impl" - // InternalRos.g:5381:1: rule__AmentPackage__Group_7_1__1__Impl : ( ( rule__AmentPackage__ArtifactAssignment_7_1_1 ) ) ; - public final void rule__AmentPackage__Group_7_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__8__Impl" + // InternalRosParser.g:5474:1: rule__ActionSpec__Group__8__Impl : ( Feedback_1 ) ; + public final void rule__ActionSpec__Group__8__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5385:1: ( ( ( rule__AmentPackage__ArtifactAssignment_7_1_1 ) ) ) - // InternalRos.g:5386:1: ( ( rule__AmentPackage__ArtifactAssignment_7_1_1 ) ) + // InternalRosParser.g:5478:1: ( ( Feedback_1 ) ) + // InternalRosParser.g:5479:1: ( Feedback_1 ) { - // InternalRos.g:5386:1: ( ( rule__AmentPackage__ArtifactAssignment_7_1_1 ) ) - // InternalRos.g:5387:2: ( rule__AmentPackage__ArtifactAssignment_7_1_1 ) + // InternalRosParser.g:5479:1: ( Feedback_1 ) + // InternalRosParser.g:5480:2: Feedback_1 { - before(grammarAccess.getAmentPackageAccess().getArtifactAssignment_7_1_1()); - // InternalRos.g:5388:2: ( rule__AmentPackage__ArtifactAssignment_7_1_1 ) - // InternalRos.g:5388:3: rule__AmentPackage__ArtifactAssignment_7_1_1 + before(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + match(input,Feedback_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__8__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__9" + // InternalRosParser.g:5489:1: rule__ActionSpec__Group__9 : rule__ActionSpec__Group__9__Impl rule__ActionSpec__Group__10 ; + public final void rule__ActionSpec__Group__9() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:5493:1: ( rule__ActionSpec__Group__9__Impl rule__ActionSpec__Group__10 ) + // InternalRosParser.g:5494:2: rule__ActionSpec__Group__9__Impl rule__ActionSpec__Group__10 { + pushFollow(FOLLOW_23); + rule__ActionSpec__Group__9__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__AmentPackage__ArtifactAssignment_7_1_1(); + rule__ActionSpec__Group__10(); state._fsp--; } - after(grammarAccess.getAmentPackageAccess().getArtifactAssignment_7_1_1()); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__9" + + + // $ANTLR start "rule__ActionSpec__Group__9__Impl" + // InternalRosParser.g:5501:1: rule__ActionSpec__Group__9__Impl : ( ( rule__ActionSpec__Group_9__0 )? ) ; + public final void rule__ActionSpec__Group__9__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:5505:1: ( ( ( rule__ActionSpec__Group_9__0 )? ) ) + // InternalRosParser.g:5506:1: ( ( rule__ActionSpec__Group_9__0 )? ) + { + // InternalRosParser.g:5506:1: ( ( rule__ActionSpec__Group_9__0 )? ) + // InternalRosParser.g:5507:2: ( rule__ActionSpec__Group_9__0 )? + { + before(grammarAccess.getActionSpecAccess().getGroup_9()); + // InternalRosParser.g:5508:2: ( rule__ActionSpec__Group_9__0 )? + int alt33=2; + int LA33_0 = input.LA(1); + + if ( (LA33_0==RULE_BEGIN) ) { + alt33=1; + } + switch (alt33) { + case 1 : + // InternalRosParser.g:5508:3: rule__ActionSpec__Group_9__0 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_9__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionSpecAccess().getGroup_9()); } @@ -16754,26 +16876,21 @@ public final void rule__AmentPackage__Group_7_1__1__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__AmentPackage__Group_7_1__1__Impl" + // $ANTLR end "rule__ActionSpec__Group__9__Impl" - // $ANTLR start "rule__ServiceSpec__Group__0" - // InternalRos.g:5397:1: rule__ServiceSpec__Group__0 : rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 ; - public final void rule__ServiceSpec__Group__0() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__10" + // InternalRosParser.g:5516:1: rule__ActionSpec__Group__10 : rule__ActionSpec__Group__10__Impl ; + public final void rule__ActionSpec__Group__10() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5401:1: ( rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 ) - // InternalRos.g:5402:2: rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 + // InternalRosParser.g:5520:1: ( rule__ActionSpec__Group__10__Impl ) + // InternalRosParser.g:5521:2: rule__ActionSpec__Group__10__Impl { - pushFollow(FOLLOW_20); - rule__ServiceSpec__Group__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ServiceSpec__Group__1(); + rule__ActionSpec__Group__10__Impl(); state._fsp--; @@ -16792,29 +16909,25 @@ public final void rule__ServiceSpec__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceSpec__Group__0" + // $ANTLR end "rule__ActionSpec__Group__10" - // $ANTLR start "rule__ServiceSpec__Group__0__Impl" - // InternalRos.g:5409:1: rule__ServiceSpec__Group__0__Impl : ( () ) ; - public final void rule__ServiceSpec__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group__10__Impl" + // InternalRosParser.g:5527:1: rule__ActionSpec__Group__10__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group__10__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5413:1: ( ( () ) ) - // InternalRos.g:5414:1: ( () ) + // InternalRosParser.g:5531:1: ( ( RULE_END ) ) + // InternalRosParser.g:5532:1: ( RULE_END ) { - // InternalRos.g:5414:1: ( () ) - // InternalRos.g:5415:2: () + // InternalRosParser.g:5532:1: ( RULE_END ) + // InternalRosParser.g:5533:2: RULE_END { - before(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); - // InternalRos.g:5416:2: () - // InternalRos.g:5416:3: - { - } - - after(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); } @@ -16822,6 +16935,10 @@ public final void rule__ServiceSpec__Group__0__Impl() throws RecognitionExceptio } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -16829,26 +16946,26 @@ public final void rule__ServiceSpec__Group__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ServiceSpec__Group__0__Impl" + // $ANTLR end "rule__ActionSpec__Group__10__Impl" - // $ANTLR start "rule__ServiceSpec__Group__1" - // InternalRos.g:5424:1: rule__ServiceSpec__Group__1 : rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 ; - public final void rule__ServiceSpec__Group__1() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_5__0" + // InternalRosParser.g:5543:1: rule__ActionSpec__Group_5__0 : rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 ; + public final void rule__ActionSpec__Group_5__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5428:1: ( rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 ) - // InternalRos.g:5429:2: rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 + // InternalRosParser.g:5547:1: ( rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 ) + // InternalRosParser.g:5548:2: rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 { - pushFollow(FOLLOW_10); - rule__ServiceSpec__Group__1__Impl(); + pushFollow(FOLLOW_24); + rule__ActionSpec__Group_5__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceSpec__Group__2(); + rule__ActionSpec__Group_5__1(); state._fsp--; @@ -16867,25 +16984,25 @@ public final void rule__ServiceSpec__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceSpec__Group__1" + // $ANTLR end "rule__ActionSpec__Group_5__0" - // $ANTLR start "rule__ServiceSpec__Group__1__Impl" - // InternalRos.g:5436:1: rule__ServiceSpec__Group__1__Impl : ( 'ServiceSpec' ) ; - public final void rule__ServiceSpec__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_5__0__Impl" + // InternalRosParser.g:5555:1: rule__ActionSpec__Group_5__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group_5__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5440:1: ( ( 'ServiceSpec' ) ) - // InternalRos.g:5441:1: ( 'ServiceSpec' ) + // InternalRosParser.g:5559:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:5560:1: ( RULE_BEGIN ) { - // InternalRos.g:5441:1: ( 'ServiceSpec' ) - // InternalRos.g:5442:2: 'ServiceSpec' + // InternalRosParser.g:5560:1: ( RULE_BEGIN ) + // InternalRosParser.g:5561:2: RULE_BEGIN { - before(grammarAccess.getServiceSpecAccess().getServiceSpecKeyword_1()); - match(input,51,FOLLOW_2); - after(grammarAccess.getServiceSpecAccess().getServiceSpecKeyword_1()); + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); } @@ -16904,26 +17021,26 @@ public final void rule__ServiceSpec__Group__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ServiceSpec__Group__1__Impl" + // $ANTLR end "rule__ActionSpec__Group_5__0__Impl" - // $ANTLR start "rule__ServiceSpec__Group__2" - // InternalRos.g:5451:1: rule__ServiceSpec__Group__2 : rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 ; - public final void rule__ServiceSpec__Group__2() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_5__1" + // InternalRosParser.g:5570:1: rule__ActionSpec__Group_5__1 : rule__ActionSpec__Group_5__1__Impl rule__ActionSpec__Group_5__2 ; + public final void rule__ActionSpec__Group_5__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5455:1: ( rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 ) - // InternalRos.g:5456:2: rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 + // InternalRosParser.g:5574:1: ( rule__ActionSpec__Group_5__1__Impl rule__ActionSpec__Group_5__2 ) + // InternalRosParser.g:5575:2: rule__ActionSpec__Group_5__1__Impl rule__ActionSpec__Group_5__2 { - pushFollow(FOLLOW_4); - rule__ServiceSpec__Group__2__Impl(); + pushFollow(FOLLOW_25); + rule__ActionSpec__Group_5__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceSpec__Group__3(); + rule__ActionSpec__Group_5__2(); state._fsp--; @@ -16942,35 +17059,35 @@ public final void rule__ServiceSpec__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceSpec__Group__2" + // $ANTLR end "rule__ActionSpec__Group_5__1" - // $ANTLR start "rule__ServiceSpec__Group__2__Impl" - // InternalRos.g:5463:1: rule__ServiceSpec__Group__2__Impl : ( ( rule__ServiceSpec__NameAssignment_2 ) ) ; - public final void rule__ServiceSpec__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_5__1__Impl" + // InternalRosParser.g:5582:1: rule__ActionSpec__Group_5__1__Impl : ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) ; + public final void rule__ActionSpec__Group_5__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5467:1: ( ( ( rule__ServiceSpec__NameAssignment_2 ) ) ) - // InternalRos.g:5468:1: ( ( rule__ServiceSpec__NameAssignment_2 ) ) + // InternalRosParser.g:5586:1: ( ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) ) + // InternalRosParser.g:5587:1: ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) { - // InternalRos.g:5468:1: ( ( rule__ServiceSpec__NameAssignment_2 ) ) - // InternalRos.g:5469:2: ( rule__ServiceSpec__NameAssignment_2 ) + // InternalRosParser.g:5587:1: ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) + // InternalRosParser.g:5588:2: ( rule__ActionSpec__GoalAssignment_5_1 ) { - before(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); - // InternalRos.g:5470:2: ( rule__ServiceSpec__NameAssignment_2 ) - // InternalRos.g:5470:3: rule__ServiceSpec__NameAssignment_2 + before(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); + // InternalRosParser.g:5589:2: ( rule__ActionSpec__GoalAssignment_5_1 ) + // InternalRosParser.g:5589:3: rule__ActionSpec__GoalAssignment_5_1 { pushFollow(FOLLOW_2); - rule__ServiceSpec__NameAssignment_2(); + rule__ActionSpec__GoalAssignment_5_1(); state._fsp--; } - after(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); + after(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); } @@ -16989,26 +17106,21 @@ public final void rule__ServiceSpec__Group__2__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ServiceSpec__Group__2__Impl" + // $ANTLR end "rule__ActionSpec__Group_5__1__Impl" - // $ANTLR start "rule__ServiceSpec__Group__3" - // InternalRos.g:5478:1: rule__ServiceSpec__Group__3 : rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 ; - public final void rule__ServiceSpec__Group__3() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_5__2" + // InternalRosParser.g:5597:1: rule__ActionSpec__Group_5__2 : rule__ActionSpec__Group_5__2__Impl ; + public final void rule__ActionSpec__Group_5__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5482:1: ( rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 ) - // InternalRos.g:5483:2: rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 + // InternalRosParser.g:5601:1: ( rule__ActionSpec__Group_5__2__Impl ) + // InternalRosParser.g:5602:2: rule__ActionSpec__Group_5__2__Impl { - pushFollow(FOLLOW_21); - rule__ServiceSpec__Group__3__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ServiceSpec__Group__4(); + rule__ActionSpec__Group_5__2__Impl(); state._fsp--; @@ -17027,25 +17139,25 @@ public final void rule__ServiceSpec__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceSpec__Group__3" + // $ANTLR end "rule__ActionSpec__Group_5__2" - // $ANTLR start "rule__ServiceSpec__Group__3__Impl" - // InternalRos.g:5490:1: rule__ServiceSpec__Group__3__Impl : ( '{' ) ; - public final void rule__ServiceSpec__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_5__2__Impl" + // InternalRosParser.g:5608:1: rule__ActionSpec__Group_5__2__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group_5__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5494:1: ( ( '{' ) ) - // InternalRos.g:5495:1: ( '{' ) + // InternalRosParser.g:5612:1: ( ( RULE_END ) ) + // InternalRosParser.g:5613:1: ( RULE_END ) { - // InternalRos.g:5495:1: ( '{' ) - // InternalRos.g:5496:2: '{' + // InternalRosParser.g:5613:1: ( RULE_END ) + // InternalRosParser.g:5614:2: RULE_END { - before(grammarAccess.getServiceSpecAccess().getLeftCurlyBracketKeyword_3()); - match(input,41,FOLLOW_2); - after(grammarAccess.getServiceSpecAccess().getLeftCurlyBracketKeyword_3()); + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); } @@ -17064,26 +17176,26 @@ public final void rule__ServiceSpec__Group__3__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ServiceSpec__Group__3__Impl" + // $ANTLR end "rule__ActionSpec__Group_5__2__Impl" - // $ANTLR start "rule__ServiceSpec__Group__4" - // InternalRos.g:5505:1: rule__ServiceSpec__Group__4 : rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 ; - public final void rule__ServiceSpec__Group__4() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_7__0" + // InternalRosParser.g:5624:1: rule__ActionSpec__Group_7__0 : rule__ActionSpec__Group_7__0__Impl rule__ActionSpec__Group_7__1 ; + public final void rule__ActionSpec__Group_7__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5509:1: ( rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 ) - // InternalRos.g:5510:2: rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 + // InternalRosParser.g:5628:1: ( rule__ActionSpec__Group_7__0__Impl rule__ActionSpec__Group_7__1 ) + // InternalRosParser.g:5629:2: rule__ActionSpec__Group_7__0__Impl rule__ActionSpec__Group_7__1 { - pushFollow(FOLLOW_21); - rule__ServiceSpec__Group__4__Impl(); + pushFollow(FOLLOW_24); + rule__ActionSpec__Group_7__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceSpec__Group__5(); + rule__ActionSpec__Group_7__1(); state._fsp--; @@ -17102,48 +17214,65 @@ public final void rule__ServiceSpec__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceSpec__Group__4" + // $ANTLR end "rule__ActionSpec__Group_7__0" - // $ANTLR start "rule__ServiceSpec__Group__4__Impl" - // InternalRos.g:5517:1: rule__ServiceSpec__Group__4__Impl : ( ( rule__ServiceSpec__Group_4__0 )? ) ; - public final void rule__ServiceSpec__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_7__0__Impl" + // InternalRosParser.g:5636:1: rule__ActionSpec__Group_7__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group_7__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5521:1: ( ( ( rule__ServiceSpec__Group_4__0 )? ) ) - // InternalRos.g:5522:1: ( ( rule__ServiceSpec__Group_4__0 )? ) + // InternalRosParser.g:5640:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:5641:1: ( RULE_BEGIN ) { - // InternalRos.g:5522:1: ( ( rule__ServiceSpec__Group_4__0 )? ) - // InternalRos.g:5523:2: ( rule__ServiceSpec__Group_4__0 )? + // InternalRosParser.g:5641:1: ( RULE_BEGIN ) + // InternalRosParser.g:5642:2: RULE_BEGIN { - before(grammarAccess.getServiceSpecAccess().getGroup_4()); - // InternalRos.g:5524:2: ( rule__ServiceSpec__Group_4__0 )? - int alt35=2; - int LA35_0 = input.LA(1); + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); - if ( (LA35_0==52) ) { - alt35=1; } - switch (alt35) { - case 1 : - // InternalRos.g:5524:3: rule__ServiceSpec__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__ServiceSpec__Group_4__0(); - state._fsp--; + } - } - break; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); - after(grammarAccess.getServiceSpecAccess().getGroup_4()); + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__0__Impl" - } + + // $ANTLR start "rule__ActionSpec__Group_7__1" + // InternalRosParser.g:5651:1: rule__ActionSpec__Group_7__1 : rule__ActionSpec__Group_7__1__Impl rule__ActionSpec__Group_7__2 ; + public final void rule__ActionSpec__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:5655:1: ( rule__ActionSpec__Group_7__1__Impl rule__ActionSpec__Group_7__2 ) + // InternalRosParser.g:5656:2: rule__ActionSpec__Group_7__1__Impl rule__ActionSpec__Group_7__2 + { + pushFollow(FOLLOW_25); + rule__ActionSpec__Group_7__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_7__2(); + + state._fsp--; } @@ -17160,28 +17289,37 @@ public final void rule__ServiceSpec__Group__4__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ServiceSpec__Group__4__Impl" + // $ANTLR end "rule__ActionSpec__Group_7__1" - // $ANTLR start "rule__ServiceSpec__Group__5" - // InternalRos.g:5532:1: rule__ServiceSpec__Group__5 : rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 ; - public final void rule__ServiceSpec__Group__5() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_7__1__Impl" + // InternalRosParser.g:5663:1: rule__ActionSpec__Group_7__1__Impl : ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) ; + public final void rule__ActionSpec__Group_7__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5536:1: ( rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 ) - // InternalRos.g:5537:2: rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 + // InternalRosParser.g:5667:1: ( ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) ) + // InternalRosParser.g:5668:1: ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) { - pushFollow(FOLLOW_21); - rule__ServiceSpec__Group__5__Impl(); + // InternalRosParser.g:5668:1: ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) + // InternalRosParser.g:5669:2: ( rule__ActionSpec__ResultAssignment_7_1 ) + { + before(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); + // InternalRosParser.g:5670:2: ( rule__ActionSpec__ResultAssignment_7_1 ) + // InternalRosParser.g:5670:3: rule__ActionSpec__ResultAssignment_7_1 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__ResultAssignment_7_1(); state._fsp--; - pushFollow(FOLLOW_2); - rule__ServiceSpec__Group__6(); - state._fsp--; + } + + after(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); + + } } @@ -17198,46 +17336,58 @@ public final void rule__ServiceSpec__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceSpec__Group__5" + // $ANTLR end "rule__ActionSpec__Group_7__1__Impl" - // $ANTLR start "rule__ServiceSpec__Group__5__Impl" - // InternalRos.g:5544:1: rule__ServiceSpec__Group__5__Impl : ( ( rule__ServiceSpec__Group_5__0 )? ) ; - public final void rule__ServiceSpec__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_7__2" + // InternalRosParser.g:5678:1: rule__ActionSpec__Group_7__2 : rule__ActionSpec__Group_7__2__Impl ; + public final void rule__ActionSpec__Group_7__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5548:1: ( ( ( rule__ServiceSpec__Group_5__0 )? ) ) - // InternalRos.g:5549:1: ( ( rule__ServiceSpec__Group_5__0 )? ) + // InternalRosParser.g:5682:1: ( rule__ActionSpec__Group_7__2__Impl ) + // InternalRosParser.g:5683:2: rule__ActionSpec__Group_7__2__Impl { - // InternalRos.g:5549:1: ( ( rule__ServiceSpec__Group_5__0 )? ) - // InternalRos.g:5550:2: ( rule__ServiceSpec__Group_5__0 )? - { - before(grammarAccess.getServiceSpecAccess().getGroup_5()); - // InternalRos.g:5551:2: ( rule__ServiceSpec__Group_5__0 )? - int alt36=2; - int LA36_0 = input.LA(1); + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_7__2__Impl(); + + state._fsp--; + - if ( (LA36_0==53) ) { - alt36=1; } - switch (alt36) { - case 1 : - // InternalRos.g:5551:3: rule__ServiceSpec__Group_5__0 - { - pushFollow(FOLLOW_2); - rule__ServiceSpec__Group_5__0(); - state._fsp--; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__2" - } - break; - } + // $ANTLR start "rule__ActionSpec__Group_7__2__Impl" + // InternalRosParser.g:5689:1: rule__ActionSpec__Group_7__2__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group_7__2__Impl() throws RecognitionException { - after(grammarAccess.getServiceSpecAccess().getGroup_5()); + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:5693:1: ( ( RULE_END ) ) + // InternalRosParser.g:5694:1: ( RULE_END ) + { + // InternalRosParser.g:5694:1: ( RULE_END ) + // InternalRosParser.g:5695:2: RULE_END + { + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); } @@ -17256,21 +17406,26 @@ public final void rule__ServiceSpec__Group__5__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ServiceSpec__Group__5__Impl" + // $ANTLR end "rule__ActionSpec__Group_7__2__Impl" - // $ANTLR start "rule__ServiceSpec__Group__6" - // InternalRos.g:5559:1: rule__ServiceSpec__Group__6 : rule__ServiceSpec__Group__6__Impl ; - public final void rule__ServiceSpec__Group__6() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_9__0" + // InternalRosParser.g:5705:1: rule__ActionSpec__Group_9__0 : rule__ActionSpec__Group_9__0__Impl rule__ActionSpec__Group_9__1 ; + public final void rule__ActionSpec__Group_9__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5563:1: ( rule__ServiceSpec__Group__6__Impl ) - // InternalRos.g:5564:2: rule__ServiceSpec__Group__6__Impl + // InternalRosParser.g:5709:1: ( rule__ActionSpec__Group_9__0__Impl rule__ActionSpec__Group_9__1 ) + // InternalRosParser.g:5710:2: rule__ActionSpec__Group_9__0__Impl rule__ActionSpec__Group_9__1 { + pushFollow(FOLLOW_24); + rule__ActionSpec__Group_9__0__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__ServiceSpec__Group__6__Impl(); + rule__ActionSpec__Group_9__1(); state._fsp--; @@ -17289,25 +17444,25 @@ public final void rule__ServiceSpec__Group__6() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceSpec__Group__6" + // $ANTLR end "rule__ActionSpec__Group_9__0" - // $ANTLR start "rule__ServiceSpec__Group__6__Impl" - // InternalRos.g:5570:1: rule__ServiceSpec__Group__6__Impl : ( '}' ) ; - public final void rule__ServiceSpec__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_9__0__Impl" + // InternalRosParser.g:5717:1: rule__ActionSpec__Group_9__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group_9__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5574:1: ( ( '}' ) ) - // InternalRos.g:5575:1: ( '}' ) + // InternalRosParser.g:5721:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:5722:1: ( RULE_BEGIN ) { - // InternalRos.g:5575:1: ( '}' ) - // InternalRos.g:5576:2: '}' + // InternalRosParser.g:5722:1: ( RULE_BEGIN ) + // InternalRosParser.g:5723:2: RULE_BEGIN { - before(grammarAccess.getServiceSpecAccess().getRightCurlyBracketKeyword_6()); - match(input,42,FOLLOW_2); - after(grammarAccess.getServiceSpecAccess().getRightCurlyBracketKeyword_6()); + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); } @@ -17326,26 +17481,26 @@ public final void rule__ServiceSpec__Group__6__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ServiceSpec__Group__6__Impl" + // $ANTLR end "rule__ActionSpec__Group_9__0__Impl" - // $ANTLR start "rule__ServiceSpec__Group_4__0" - // InternalRos.g:5586:1: rule__ServiceSpec__Group_4__0 : rule__ServiceSpec__Group_4__0__Impl rule__ServiceSpec__Group_4__1 ; - public final void rule__ServiceSpec__Group_4__0() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_9__1" + // InternalRosParser.g:5732:1: rule__ActionSpec__Group_9__1 : rule__ActionSpec__Group_9__1__Impl rule__ActionSpec__Group_9__2 ; + public final void rule__ActionSpec__Group_9__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5590:1: ( rule__ServiceSpec__Group_4__0__Impl rule__ServiceSpec__Group_4__1 ) - // InternalRos.g:5591:2: rule__ServiceSpec__Group_4__0__Impl rule__ServiceSpec__Group_4__1 + // InternalRosParser.g:5736:1: ( rule__ActionSpec__Group_9__1__Impl rule__ActionSpec__Group_9__2 ) + // InternalRosParser.g:5737:2: rule__ActionSpec__Group_9__1__Impl rule__ActionSpec__Group_9__2 { - pushFollow(FOLLOW_4); - rule__ServiceSpec__Group_4__0__Impl(); + pushFollow(FOLLOW_25); + rule__ActionSpec__Group_9__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceSpec__Group_4__1(); + rule__ActionSpec__Group_9__2(); state._fsp--; @@ -17364,25 +17519,35 @@ public final void rule__ServiceSpec__Group_4__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceSpec__Group_4__0" + // $ANTLR end "rule__ActionSpec__Group_9__1" - // $ANTLR start "rule__ServiceSpec__Group_4__0__Impl" - // InternalRos.g:5598:1: rule__ServiceSpec__Group_4__0__Impl : ( 'request' ) ; - public final void rule__ServiceSpec__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_9__1__Impl" + // InternalRosParser.g:5744:1: rule__ActionSpec__Group_9__1__Impl : ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) ; + public final void rule__ActionSpec__Group_9__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5602:1: ( ( 'request' ) ) - // InternalRos.g:5603:1: ( 'request' ) + // InternalRosParser.g:5748:1: ( ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) ) + // InternalRosParser.g:5749:1: ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) + { + // InternalRosParser.g:5749:1: ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) + // InternalRosParser.g:5750:2: ( rule__ActionSpec__FeedbackAssignment_9_1 ) { - // InternalRos.g:5603:1: ( 'request' ) - // InternalRos.g:5604:2: 'request' + before(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); + // InternalRosParser.g:5751:2: ( rule__ActionSpec__FeedbackAssignment_9_1 ) + // InternalRosParser.g:5751:3: rule__ActionSpec__FeedbackAssignment_9_1 { - before(grammarAccess.getServiceSpecAccess().getRequestKeyword_4_0()); - match(input,52,FOLLOW_2); - after(grammarAccess.getServiceSpecAccess().getRequestKeyword_4_0()); + pushFollow(FOLLOW_2); + rule__ActionSpec__FeedbackAssignment_9_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); } @@ -17401,21 +17566,21 @@ public final void rule__ServiceSpec__Group_4__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceSpec__Group_4__0__Impl" + // $ANTLR end "rule__ActionSpec__Group_9__1__Impl" - // $ANTLR start "rule__ServiceSpec__Group_4__1" - // InternalRos.g:5613:1: rule__ServiceSpec__Group_4__1 : rule__ServiceSpec__Group_4__1__Impl ; - public final void rule__ServiceSpec__Group_4__1() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_9__2" + // InternalRosParser.g:5759:1: rule__ActionSpec__Group_9__2 : rule__ActionSpec__Group_9__2__Impl ; + public final void rule__ActionSpec__Group_9__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5617:1: ( rule__ServiceSpec__Group_4__1__Impl ) - // InternalRos.g:5618:2: rule__ServiceSpec__Group_4__1__Impl + // InternalRosParser.g:5763:1: ( rule__ActionSpec__Group_9__2__Impl ) + // InternalRosParser.g:5764:2: rule__ActionSpec__Group_9__2__Impl { pushFollow(FOLLOW_2); - rule__ServiceSpec__Group_4__1__Impl(); + rule__ActionSpec__Group_9__2__Impl(); state._fsp--; @@ -17434,35 +17599,25 @@ public final void rule__ServiceSpec__Group_4__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceSpec__Group_4__1" + // $ANTLR end "rule__ActionSpec__Group_9__2" - // $ANTLR start "rule__ServiceSpec__Group_4__1__Impl" - // InternalRos.g:5624:1: rule__ServiceSpec__Group_4__1__Impl : ( ( rule__ServiceSpec__RequestAssignment_4_1 ) ) ; - public final void rule__ServiceSpec__Group_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__Group_9__2__Impl" + // InternalRosParser.g:5770:1: rule__ActionSpec__Group_9__2__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group_9__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5628:1: ( ( ( rule__ServiceSpec__RequestAssignment_4_1 ) ) ) - // InternalRos.g:5629:1: ( ( rule__ServiceSpec__RequestAssignment_4_1 ) ) - { - // InternalRos.g:5629:1: ( ( rule__ServiceSpec__RequestAssignment_4_1 ) ) - // InternalRos.g:5630:2: ( rule__ServiceSpec__RequestAssignment_4_1 ) + // InternalRosParser.g:5774:1: ( ( RULE_END ) ) + // InternalRosParser.g:5775:1: ( RULE_END ) { - before(grammarAccess.getServiceSpecAccess().getRequestAssignment_4_1()); - // InternalRos.g:5631:2: ( rule__ServiceSpec__RequestAssignment_4_1 ) - // InternalRos.g:5631:3: rule__ServiceSpec__RequestAssignment_4_1 + // InternalRosParser.g:5775:1: ( RULE_END ) + // InternalRosParser.g:5776:2: RULE_END { - pushFollow(FOLLOW_2); - rule__ServiceSpec__RequestAssignment_4_1(); - - state._fsp--; - - - } - - after(grammarAccess.getServiceSpecAccess().getRequestAssignment_4_1()); + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); } @@ -17481,26 +17636,26 @@ public final void rule__ServiceSpec__Group_4__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceSpec__Group_4__1__Impl" + // $ANTLR end "rule__ActionSpec__Group_9__2__Impl" - // $ANTLR start "rule__ServiceSpec__Group_5__0" - // InternalRos.g:5640:1: rule__ServiceSpec__Group_5__0 : rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 ; - public final void rule__ServiceSpec__Group_5__0() throws RecognitionException { + // $ANTLR start "rule__MessageDefinition__Group__0" + // InternalRosParser.g:5786:1: rule__MessageDefinition__Group__0 : rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 ; + public final void rule__MessageDefinition__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5644:1: ( rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 ) - // InternalRos.g:5645:2: rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 + // InternalRosParser.g:5790:1: ( rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 ) + // InternalRosParser.g:5791:2: rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 { - pushFollow(FOLLOW_4); - rule__ServiceSpec__Group_5__0__Impl(); + pushFollow(FOLLOW_24); + rule__MessageDefinition__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceSpec__Group_5__1(); + rule__MessageDefinition__Group__1(); state._fsp--; @@ -17519,25 +17674,29 @@ public final void rule__ServiceSpec__Group_5__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceSpec__Group_5__0" + // $ANTLR end "rule__MessageDefinition__Group__0" - // $ANTLR start "rule__ServiceSpec__Group_5__0__Impl" - // InternalRos.g:5652:1: rule__ServiceSpec__Group_5__0__Impl : ( 'response' ) ; - public final void rule__ServiceSpec__Group_5__0__Impl() throws RecognitionException { + // $ANTLR start "rule__MessageDefinition__Group__0__Impl" + // InternalRosParser.g:5798:1: rule__MessageDefinition__Group__0__Impl : ( () ) ; + public final void rule__MessageDefinition__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5656:1: ( ( 'response' ) ) - // InternalRos.g:5657:1: ( 'response' ) + // InternalRosParser.g:5802:1: ( ( () ) ) + // InternalRosParser.g:5803:1: ( () ) { - // InternalRos.g:5657:1: ( 'response' ) - // InternalRos.g:5658:2: 'response' + // InternalRosParser.g:5803:1: ( () ) + // InternalRosParser.g:5804:2: () { - before(grammarAccess.getServiceSpecAccess().getResponseKeyword_5_0()); - match(input,53,FOLLOW_2); - after(grammarAccess.getServiceSpecAccess().getResponseKeyword_5_0()); + before(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); + // InternalRosParser.g:5805:2: () + // InternalRosParser.g:5805:3: + { + } + + after(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); } @@ -17545,10 +17704,6 @@ public final void rule__ServiceSpec__Group_5__0__Impl() throws RecognitionExcept } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -17556,21 +17711,21 @@ public final void rule__ServiceSpec__Group_5__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceSpec__Group_5__0__Impl" + // $ANTLR end "rule__MessageDefinition__Group__0__Impl" - // $ANTLR start "rule__ServiceSpec__Group_5__1" - // InternalRos.g:5667:1: rule__ServiceSpec__Group_5__1 : rule__ServiceSpec__Group_5__1__Impl ; - public final void rule__ServiceSpec__Group_5__1() throws RecognitionException { + // $ANTLR start "rule__MessageDefinition__Group__1" + // InternalRosParser.g:5813:1: rule__MessageDefinition__Group__1 : rule__MessageDefinition__Group__1__Impl ; + public final void rule__MessageDefinition__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5671:1: ( rule__ServiceSpec__Group_5__1__Impl ) - // InternalRos.g:5672:2: rule__ServiceSpec__Group_5__1__Impl + // InternalRosParser.g:5817:1: ( rule__MessageDefinition__Group__1__Impl ) + // InternalRosParser.g:5818:2: rule__MessageDefinition__Group__1__Impl { pushFollow(FOLLOW_2); - rule__ServiceSpec__Group_5__1__Impl(); + rule__MessageDefinition__Group__1__Impl(); state._fsp--; @@ -17589,75 +17744,55 @@ public final void rule__ServiceSpec__Group_5__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceSpec__Group_5__1" + // $ANTLR end "rule__MessageDefinition__Group__1" - // $ANTLR start "rule__ServiceSpec__Group_5__1__Impl" - // InternalRos.g:5678:1: rule__ServiceSpec__Group_5__1__Impl : ( ( rule__ServiceSpec__ResponseAssignment_5_1 ) ) ; - public final void rule__ServiceSpec__Group_5__1__Impl() throws RecognitionException { + // $ANTLR start "rule__MessageDefinition__Group__1__Impl" + // InternalRosParser.g:5824:1: rule__MessageDefinition__Group__1__Impl : ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) ; + public final void rule__MessageDefinition__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5682:1: ( ( ( rule__ServiceSpec__ResponseAssignment_5_1 ) ) ) - // InternalRos.g:5683:1: ( ( rule__ServiceSpec__ResponseAssignment_5_1 ) ) - { - // InternalRos.g:5683:1: ( ( rule__ServiceSpec__ResponseAssignment_5_1 ) ) - // InternalRos.g:5684:2: ( rule__ServiceSpec__ResponseAssignment_5_1 ) + // InternalRosParser.g:5828:1: ( ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) ) + // InternalRosParser.g:5829:1: ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) { - before(grammarAccess.getServiceSpecAccess().getResponseAssignment_5_1()); - // InternalRos.g:5685:2: ( rule__ServiceSpec__ResponseAssignment_5_1 ) - // InternalRos.g:5685:3: rule__ServiceSpec__ResponseAssignment_5_1 + // InternalRosParser.g:5829:1: ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) + // InternalRosParser.g:5830:2: ( rule__MessageDefinition__MessagePartAssignment_1 )* { - pushFollow(FOLLOW_2); - rule__ServiceSpec__ResponseAssignment_5_1(); - - state._fsp--; - - - } - - after(grammarAccess.getServiceSpecAccess().getResponseAssignment_5_1()); - - } - - - } + before(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); + // InternalRosParser.g:5831:2: ( rule__MessageDefinition__MessagePartAssignment_1 )* + loop34: + do { + int alt34=2; + int LA34_0 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( ((LA34_0>=Float32_1 && LA34_0<=Float64_1)||LA34_0==Duration||(LA34_0>=String_2 && LA34_0<=Uint64_1)||(LA34_0>=Float32 && LA34_0<=Int64_1)||LA34_0==Uint8_1||LA34_0==Header||(LA34_0>=Bool_1 && LA34_0<=Int8_1)||(LA34_0>=String_1 && LA34_0<=Uint64)||(LA34_0>=Int16 && LA34_0<=Int64)||LA34_0==Uint8||(LA34_0>=Bool && LA34_0<=Byte)||LA34_0==Int8||LA34_0==Time||LA34_0==RULE_ID||LA34_0==RULE_STRING) ) { + alt34=1; + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__ServiceSpec__Group_5__1__Impl" + switch (alt34) { + case 1 : + // InternalRosParser.g:5831:3: rule__MessageDefinition__MessagePartAssignment_1 + { + pushFollow(FOLLOW_33); + rule__MessageDefinition__MessagePartAssignment_1(); + state._fsp--; - // $ANTLR start "rule__TopicSpec__Group__0" - // InternalRos.g:5694:1: rule__TopicSpec__Group__0 : rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 ; - public final void rule__TopicSpec__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalRos.g:5698:1: ( rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 ) - // InternalRos.g:5699:2: rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 - { - pushFollow(FOLLOW_22); - rule__TopicSpec__Group__0__Impl(); + } + break; - state._fsp--; + default : + break loop34; + } + } while (true); - pushFollow(FOLLOW_2); - rule__TopicSpec__Group__1(); + after(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); - state._fsp--; + } } @@ -17674,63 +17809,26 @@ public final void rule__TopicSpec__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__TopicSpec__Group__0" - - - // $ANTLR start "rule__TopicSpec__Group__0__Impl" - // InternalRos.g:5706:1: rule__TopicSpec__Group__0__Impl : ( () ) ; - public final void rule__TopicSpec__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:5710:1: ( ( () ) ) - // InternalRos.g:5711:1: ( () ) - { - // InternalRos.g:5711:1: ( () ) - // InternalRos.g:5712:2: () - { - before(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); - // InternalRos.g:5713:2: () - // InternalRos.g:5713:3: - { - } - - after(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); - - } - - - } - - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__TopicSpec__Group__0__Impl" + // $ANTLR end "rule__MessageDefinition__Group__1__Impl" - // $ANTLR start "rule__TopicSpec__Group__1" - // InternalRos.g:5721:1: rule__TopicSpec__Group__1 : rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 ; - public final void rule__TopicSpec__Group__1() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__0" + // InternalRosParser.g:5840: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 { - // InternalRos.g:5725:1: ( rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 ) - // InternalRos.g:5726:2: rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 + // InternalRosParser.g:5844:1: ( rule__Publisher__Group__0__Impl rule__Publisher__Group__1 ) + // InternalRosParser.g:5845:2: rule__Publisher__Group__0__Impl rule__Publisher__Group__1 { - pushFollow(FOLLOW_23); - rule__TopicSpec__Group__1__Impl(); + pushFollow(FOLLOW_8); + rule__Publisher__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__TopicSpec__Group__2(); + rule__Publisher__Group__1(); state._fsp--; @@ -17749,25 +17847,29 @@ public final void rule__TopicSpec__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__TopicSpec__Group__1" + // $ANTLR end "rule__Publisher__Group__0" - // $ANTLR start "rule__TopicSpec__Group__1__Impl" - // InternalRos.g:5733:1: rule__TopicSpec__Group__1__Impl : ( 'TopicSpec' ) ; - public final void rule__TopicSpec__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__0__Impl" + // InternalRosParser.g:5852:1: rule__Publisher__Group__0__Impl : ( () ) ; + public final void rule__Publisher__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5737:1: ( ( 'TopicSpec' ) ) - // InternalRos.g:5738:1: ( 'TopicSpec' ) + // InternalRosParser.g:5856:1: ( ( () ) ) + // InternalRosParser.g:5857:1: ( () ) { - // InternalRos.g:5738:1: ( 'TopicSpec' ) - // InternalRos.g:5739:2: 'TopicSpec' + // InternalRosParser.g:5857:1: ( () ) + // InternalRosParser.g:5858:2: () { - before(grammarAccess.getTopicSpecAccess().getTopicSpecKeyword_1()); - match(input,54,FOLLOW_2); - after(grammarAccess.getTopicSpecAccess().getTopicSpecKeyword_1()); + before(grammarAccess.getPublisherAccess().getPublisherAction_0()); + // InternalRosParser.g:5859:2: () + // InternalRosParser.g:5859:3: + { + } + + after(grammarAccess.getPublisherAccess().getPublisherAction_0()); } @@ -17775,10 +17877,6 @@ public final void rule__TopicSpec__Group__1__Impl() throws RecognitionException } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -17786,26 +17884,26 @@ public final void rule__TopicSpec__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__TopicSpec__Group__1__Impl" + // $ANTLR end "rule__Publisher__Group__0__Impl" - // $ANTLR start "rule__TopicSpec__Group__2" - // InternalRos.g:5748:1: rule__TopicSpec__Group__2 : rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 ; - public final void rule__TopicSpec__Group__2() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__1" + // InternalRosParser.g:5867: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 { - // InternalRos.g:5752:1: ( rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 ) - // InternalRos.g:5753:2: rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 + // InternalRosParser.g:5871:1: ( rule__Publisher__Group__1__Impl rule__Publisher__Group__2 ) + // InternalRosParser.g:5872:2: rule__Publisher__Group__1__Impl rule__Publisher__Group__2 { - pushFollow(FOLLOW_4); - rule__TopicSpec__Group__2__Impl(); + pushFollow(FOLLOW_5); + rule__Publisher__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__TopicSpec__Group__3(); + rule__Publisher__Group__2(); state._fsp--; @@ -17824,35 +17922,35 @@ public final void rule__TopicSpec__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__TopicSpec__Group__2" + // $ANTLR end "rule__Publisher__Group__1" - // $ANTLR start "rule__TopicSpec__Group__2__Impl" - // InternalRos.g:5760:1: rule__TopicSpec__Group__2__Impl : ( ( rule__TopicSpec__NameAssignment_2 ) ) ; - public final void rule__TopicSpec__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__1__Impl" + // InternalRosParser.g:5879:1: rule__Publisher__Group__1__Impl : ( ( rule__Publisher__NameAssignment_1 ) ) ; + public final void rule__Publisher__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5764:1: ( ( ( rule__TopicSpec__NameAssignment_2 ) ) ) - // InternalRos.g:5765:1: ( ( rule__TopicSpec__NameAssignment_2 ) ) + // InternalRosParser.g:5883:1: ( ( ( rule__Publisher__NameAssignment_1 ) ) ) + // InternalRosParser.g:5884:1: ( ( rule__Publisher__NameAssignment_1 ) ) { - // InternalRos.g:5765:1: ( ( rule__TopicSpec__NameAssignment_2 ) ) - // InternalRos.g:5766:2: ( rule__TopicSpec__NameAssignment_2 ) + // InternalRosParser.g:5884:1: ( ( rule__Publisher__NameAssignment_1 ) ) + // InternalRosParser.g:5885:2: ( rule__Publisher__NameAssignment_1 ) { - before(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); - // InternalRos.g:5767:2: ( rule__TopicSpec__NameAssignment_2 ) - // InternalRos.g:5767:3: rule__TopicSpec__NameAssignment_2 + before(grammarAccess.getPublisherAccess().getNameAssignment_1()); + // InternalRosParser.g:5886:2: ( rule__Publisher__NameAssignment_1 ) + // InternalRosParser.g:5886:3: rule__Publisher__NameAssignment_1 { pushFollow(FOLLOW_2); - rule__TopicSpec__NameAssignment_2(); + rule__Publisher__NameAssignment_1(); state._fsp--; } - after(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); + after(grammarAccess.getPublisherAccess().getNameAssignment_1()); } @@ -17871,26 +17969,26 @@ public final void rule__TopicSpec__Group__2__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__TopicSpec__Group__2__Impl" + // $ANTLR end "rule__Publisher__Group__1__Impl" - // $ANTLR start "rule__TopicSpec__Group__3" - // InternalRos.g:5775:1: rule__TopicSpec__Group__3 : rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 ; - public final void rule__TopicSpec__Group__3() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__2" + // InternalRosParser.g:5894: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 { - // InternalRos.g:5779:1: ( rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 ) - // InternalRos.g:5780:2: rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 + // InternalRosParser.g:5898:1: ( rule__Publisher__Group__2__Impl rule__Publisher__Group__3 ) + // InternalRosParser.g:5899:2: rule__Publisher__Group__2__Impl rule__Publisher__Group__3 { - pushFollow(FOLLOW_24); - rule__TopicSpec__Group__3__Impl(); + pushFollow(FOLLOW_6); + rule__Publisher__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__TopicSpec__Group__4(); + rule__Publisher__Group__3(); state._fsp--; @@ -17909,25 +18007,25 @@ public final void rule__TopicSpec__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__TopicSpec__Group__3" + // $ANTLR end "rule__Publisher__Group__2" - // $ANTLR start "rule__TopicSpec__Group__3__Impl" - // InternalRos.g:5787:1: rule__TopicSpec__Group__3__Impl : ( '{' ) ; - public final void rule__TopicSpec__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__2__Impl" + // InternalRosParser.g:5906:1: rule__Publisher__Group__2__Impl : ( Colon ) ; + public final void rule__Publisher__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5791:1: ( ( '{' ) ) - // InternalRos.g:5792:1: ( '{' ) + // InternalRosParser.g:5910:1: ( ( Colon ) ) + // InternalRosParser.g:5911:1: ( Colon ) { - // InternalRos.g:5792:1: ( '{' ) - // InternalRos.g:5793:2: '{' + // InternalRosParser.g:5911:1: ( Colon ) + // InternalRosParser.g:5912:2: Colon { - before(grammarAccess.getTopicSpecAccess().getLeftCurlyBracketKeyword_3()); - match(input,41,FOLLOW_2); - after(grammarAccess.getTopicSpecAccess().getLeftCurlyBracketKeyword_3()); + before(grammarAccess.getPublisherAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getColonKeyword_2()); } @@ -17946,26 +18044,26 @@ public final void rule__TopicSpec__Group__3__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__TopicSpec__Group__3__Impl" + // $ANTLR end "rule__Publisher__Group__2__Impl" - // $ANTLR start "rule__TopicSpec__Group__4" - // InternalRos.g:5802:1: rule__TopicSpec__Group__4 : rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 ; - public final void rule__TopicSpec__Group__4() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__3" + // InternalRosParser.g:5921: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 { - // InternalRos.g:5806:1: ( rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 ) - // InternalRos.g:5807:2: rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 + // InternalRosParser.g:5925:1: ( rule__Publisher__Group__3__Impl rule__Publisher__Group__4 ) + // InternalRosParser.g:5926:2: rule__Publisher__Group__3__Impl rule__Publisher__Group__4 { - pushFollow(FOLLOW_24); - rule__TopicSpec__Group__4__Impl(); + pushFollow(FOLLOW_34); + rule__Publisher__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__TopicSpec__Group__5(); + rule__Publisher__Group__4(); state._fsp--; @@ -17984,46 +18082,25 @@ public final void rule__TopicSpec__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__TopicSpec__Group__4" + // $ANTLR end "rule__Publisher__Group__3" - // $ANTLR start "rule__TopicSpec__Group__4__Impl" - // InternalRos.g:5814:1: rule__TopicSpec__Group__4__Impl : ( ( rule__TopicSpec__Group_4__0 )? ) ; - public final void rule__TopicSpec__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__3__Impl" + // InternalRosParser.g:5933:1: rule__Publisher__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Publisher__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5818:1: ( ( ( rule__TopicSpec__Group_4__0 )? ) ) - // InternalRos.g:5819:1: ( ( rule__TopicSpec__Group_4__0 )? ) + // InternalRosParser.g:5937:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:5938:1: ( RULE_BEGIN ) { - // InternalRos.g:5819:1: ( ( rule__TopicSpec__Group_4__0 )? ) - // InternalRos.g:5820:2: ( rule__TopicSpec__Group_4__0 )? + // InternalRosParser.g:5938:1: ( RULE_BEGIN ) + // InternalRosParser.g:5939:2: RULE_BEGIN { - before(grammarAccess.getTopicSpecAccess().getGroup_4()); - // InternalRos.g:5821:2: ( rule__TopicSpec__Group_4__0 )? - int alt37=2; - int LA37_0 = input.LA(1); - - if ( (LA37_0==30) ) { - alt37=1; - } - switch (alt37) { - case 1 : - // InternalRos.g:5821:3: rule__TopicSpec__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__TopicSpec__Group_4__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getTopicSpecAccess().getGroup_4()); + before(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); } @@ -18042,21 +18119,26 @@ public final void rule__TopicSpec__Group__4__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__TopicSpec__Group__4__Impl" + // $ANTLR end "rule__Publisher__Group__3__Impl" - // $ANTLR start "rule__TopicSpec__Group__5" - // InternalRos.g:5829:1: rule__TopicSpec__Group__5 : rule__TopicSpec__Group__5__Impl ; - public final void rule__TopicSpec__Group__5() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__4" + // InternalRosParser.g:5948: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 { - // InternalRos.g:5833:1: ( rule__TopicSpec__Group__5__Impl ) - // InternalRos.g:5834:2: rule__TopicSpec__Group__5__Impl + // InternalRosParser.g:5952:1: ( rule__Publisher__Group__4__Impl rule__Publisher__Group__5 ) + // InternalRosParser.g:5953:2: rule__Publisher__Group__4__Impl rule__Publisher__Group__5 { + pushFollow(FOLLOW_8); + rule__Publisher__Group__4__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__TopicSpec__Group__5__Impl(); + rule__Publisher__Group__5(); state._fsp--; @@ -18075,25 +18157,25 @@ public final void rule__TopicSpec__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__TopicSpec__Group__5" + // $ANTLR end "rule__Publisher__Group__4" - // $ANTLR start "rule__TopicSpec__Group__5__Impl" - // InternalRos.g:5840:1: rule__TopicSpec__Group__5__Impl : ( '}' ) ; - public final void rule__TopicSpec__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__4__Impl" + // InternalRosParser.g:5960:1: rule__Publisher__Group__4__Impl : ( Type_1 ) ; + public final void rule__Publisher__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5844:1: ( ( '}' ) ) - // InternalRos.g:5845:1: ( '}' ) + // InternalRosParser.g:5964:1: ( ( Type_1 ) ) + // InternalRosParser.g:5965:1: ( Type_1 ) { - // InternalRos.g:5845:1: ( '}' ) - // InternalRos.g:5846:2: '}' + // InternalRosParser.g:5965:1: ( Type_1 ) + // InternalRosParser.g:5966:2: Type_1 { - before(grammarAccess.getTopicSpecAccess().getRightCurlyBracketKeyword_5()); - match(input,42,FOLLOW_2); - after(grammarAccess.getTopicSpecAccess().getRightCurlyBracketKeyword_5()); + before(grammarAccess.getPublisherAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getTypeKeyword_4()); } @@ -18112,26 +18194,26 @@ public final void rule__TopicSpec__Group__5__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__TopicSpec__Group__5__Impl" + // $ANTLR end "rule__Publisher__Group__4__Impl" - // $ANTLR start "rule__TopicSpec__Group_4__0" - // InternalRos.g:5856:1: rule__TopicSpec__Group_4__0 : rule__TopicSpec__Group_4__0__Impl rule__TopicSpec__Group_4__1 ; - public final void rule__TopicSpec__Group_4__0() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__5" + // InternalRosParser.g:5975: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 { - // InternalRos.g:5860:1: ( rule__TopicSpec__Group_4__0__Impl rule__TopicSpec__Group_4__1 ) - // InternalRos.g:5861:2: rule__TopicSpec__Group_4__0__Impl rule__TopicSpec__Group_4__1 + // InternalRosParser.g:5979:1: ( rule__Publisher__Group__5__Impl rule__Publisher__Group__6 ) + // InternalRosParser.g:5980:2: rule__Publisher__Group__5__Impl rule__Publisher__Group__6 { - pushFollow(FOLLOW_4); - rule__TopicSpec__Group_4__0__Impl(); + pushFollow(FOLLOW_35); + rule__Publisher__Group__5__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__TopicSpec__Group_4__1(); + rule__Publisher__Group__6(); state._fsp--; @@ -18150,25 +18232,35 @@ public final void rule__TopicSpec__Group_4__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__TopicSpec__Group_4__0" + // $ANTLR end "rule__Publisher__Group__5" - // $ANTLR start "rule__TopicSpec__Group_4__0__Impl" - // InternalRos.g:5868:1: rule__TopicSpec__Group_4__0__Impl : ( 'message' ) ; - public final void rule__TopicSpec__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__5__Impl" + // InternalRosParser.g:5987:1: rule__Publisher__Group__5__Impl : ( ( rule__Publisher__MessageAssignment_5 ) ) ; + public final void rule__Publisher__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5872:1: ( ( 'message' ) ) - // InternalRos.g:5873:1: ( 'message' ) + // InternalRosParser.g:5991:1: ( ( ( rule__Publisher__MessageAssignment_5 ) ) ) + // InternalRosParser.g:5992:1: ( ( rule__Publisher__MessageAssignment_5 ) ) + { + // InternalRosParser.g:5992:1: ( ( rule__Publisher__MessageAssignment_5 ) ) + // InternalRosParser.g:5993:2: ( rule__Publisher__MessageAssignment_5 ) { - // InternalRos.g:5873:1: ( 'message' ) - // InternalRos.g:5874:2: 'message' + before(grammarAccess.getPublisherAccess().getMessageAssignment_5()); + // InternalRosParser.g:5994:2: ( rule__Publisher__MessageAssignment_5 ) + // InternalRosParser.g:5994:3: rule__Publisher__MessageAssignment_5 { - before(grammarAccess.getTopicSpecAccess().getMessageKeyword_4_0()); - match(input,30,FOLLOW_2); - after(grammarAccess.getTopicSpecAccess().getMessageKeyword_4_0()); + pushFollow(FOLLOW_2); + rule__Publisher__MessageAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getPublisherAccess().getMessageAssignment_5()); } @@ -18187,21 +18279,26 @@ public final void rule__TopicSpec__Group_4__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__TopicSpec__Group_4__0__Impl" + // $ANTLR end "rule__Publisher__Group__5__Impl" - // $ANTLR start "rule__TopicSpec__Group_4__1" - // InternalRos.g:5883:1: rule__TopicSpec__Group_4__1 : rule__TopicSpec__Group_4__1__Impl ; - public final void rule__TopicSpec__Group_4__1() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__6" + // InternalRosParser.g:6002:1: rule__Publisher__Group__6 : rule__Publisher__Group__6__Impl rule__Publisher__Group__7 ; + public final void rule__Publisher__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5887:1: ( rule__TopicSpec__Group_4__1__Impl ) - // InternalRos.g:5888:2: rule__TopicSpec__Group_4__1__Impl + // InternalRosParser.g:6006:1: ( rule__Publisher__Group__6__Impl rule__Publisher__Group__7 ) + // InternalRosParser.g:6007:2: rule__Publisher__Group__6__Impl rule__Publisher__Group__7 { + pushFollow(FOLLOW_35); + rule__Publisher__Group__6__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__TopicSpec__Group_4__1__Impl(); + rule__Publisher__Group__7(); state._fsp--; @@ -18220,35 +18317,46 @@ public final void rule__TopicSpec__Group_4__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__TopicSpec__Group_4__1" + // $ANTLR end "rule__Publisher__Group__6" - // $ANTLR start "rule__TopicSpec__Group_4__1__Impl" - // InternalRos.g:5894:1: rule__TopicSpec__Group_4__1__Impl : ( ( rule__TopicSpec__MessageAssignment_4_1 ) ) ; - public final void rule__TopicSpec__Group_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__6__Impl" + // InternalRosParser.g:6014:1: rule__Publisher__Group__6__Impl : ( ( rule__Publisher__Group_6__0 )? ) ; + public final void rule__Publisher__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5898:1: ( ( ( rule__TopicSpec__MessageAssignment_4_1 ) ) ) - // InternalRos.g:5899:1: ( ( rule__TopicSpec__MessageAssignment_4_1 ) ) + // InternalRosParser.g:6018:1: ( ( ( rule__Publisher__Group_6__0 )? ) ) + // InternalRosParser.g:6019:1: ( ( rule__Publisher__Group_6__0 )? ) { - // InternalRos.g:5899:1: ( ( rule__TopicSpec__MessageAssignment_4_1 ) ) - // InternalRos.g:5900:2: ( rule__TopicSpec__MessageAssignment_4_1 ) + // InternalRosParser.g:6019:1: ( ( rule__Publisher__Group_6__0 )? ) + // InternalRosParser.g:6020:2: ( rule__Publisher__Group_6__0 )? { - before(grammarAccess.getTopicSpecAccess().getMessageAssignment_4_1()); - // InternalRos.g:5901:2: ( rule__TopicSpec__MessageAssignment_4_1 ) - // InternalRos.g:5901:3: rule__TopicSpec__MessageAssignment_4_1 - { - pushFollow(FOLLOW_2); - rule__TopicSpec__MessageAssignment_4_1(); + before(grammarAccess.getPublisherAccess().getGroup_6()); + // InternalRosParser.g:6021:2: ( rule__Publisher__Group_6__0 )? + int alt35=2; + int LA35_0 = input.LA(1); - state._fsp--; + if ( (LA35_0==Ns) ) { + alt35=1; + } + switch (alt35) { + case 1 : + // InternalRosParser.g:6021:3: rule__Publisher__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Publisher__Group_6__0(); + + state._fsp--; + } + break; + } - after(grammarAccess.getTopicSpecAccess().getMessageAssignment_4_1()); + after(grammarAccess.getPublisherAccess().getGroup_6()); } @@ -18267,26 +18375,21 @@ public final void rule__TopicSpec__Group_4__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__TopicSpec__Group_4__1__Impl" + // $ANTLR end "rule__Publisher__Group__6__Impl" - // $ANTLR start "rule__ActionSpec__Group__0" - // InternalRos.g:5910:1: rule__ActionSpec__Group__0 : rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 ; - public final void rule__ActionSpec__Group__0() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__7" + // InternalRosParser.g:6029:1: rule__Publisher__Group__7 : rule__Publisher__Group__7__Impl ; + public final void rule__Publisher__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5914:1: ( rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 ) - // InternalRos.g:5915:2: rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 + // InternalRosParser.g:6033:1: ( rule__Publisher__Group__7__Impl ) + // InternalRosParser.g:6034:2: rule__Publisher__Group__7__Impl { - pushFollow(FOLLOW_12); - rule__ActionSpec__Group__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ActionSpec__Group__1(); + rule__Publisher__Group__7__Impl(); state._fsp--; @@ -18305,29 +18408,25 @@ public final void rule__ActionSpec__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group__0" + // $ANTLR end "rule__Publisher__Group__7" - // $ANTLR start "rule__ActionSpec__Group__0__Impl" - // InternalRos.g:5922:1: rule__ActionSpec__Group__0__Impl : ( () ) ; - public final void rule__ActionSpec__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group__7__Impl" + // InternalRosParser.g:6040:1: rule__Publisher__Group__7__Impl : ( RULE_END ) ; + public final void rule__Publisher__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5926:1: ( ( () ) ) - // InternalRos.g:5927:1: ( () ) - { - // InternalRos.g:5927:1: ( () ) - // InternalRos.g:5928:2: () + // InternalRosParser.g:6044:1: ( ( RULE_END ) ) + // InternalRosParser.g:6045:1: ( RULE_END ) { - before(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); - // InternalRos.g:5929:2: () - // InternalRos.g:5929:3: + // InternalRosParser.g:6045:1: ( RULE_END ) + // InternalRosParser.g:6046:2: RULE_END { - } - - after(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); + before(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); } @@ -18335,6 +18434,10 @@ public final void rule__ActionSpec__Group__0__Impl() throws RecognitionException } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -18342,26 +18445,26 @@ public final void rule__ActionSpec__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ActionSpec__Group__0__Impl" + // $ANTLR end "rule__Publisher__Group__7__Impl" - // $ANTLR start "rule__ActionSpec__Group__1" - // InternalRos.g:5937:1: rule__ActionSpec__Group__1 : rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 ; - public final void rule__ActionSpec__Group__1() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group_6__0" + // InternalRosParser.g:6056:1: rule__Publisher__Group_6__0 : rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 ; + public final void rule__Publisher__Group_6__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5941:1: ( rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 ) - // InternalRos.g:5942:2: rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 + // InternalRosParser.g:6060:1: ( rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 ) + // InternalRosParser.g:6061:2: rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 { - pushFollow(FOLLOW_10); - rule__ActionSpec__Group__1__Impl(); + pushFollow(FOLLOW_36); + rule__Publisher__Group_6__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ActionSpec__Group__2(); + rule__Publisher__Group_6__1(); state._fsp--; @@ -18380,25 +18483,25 @@ public final void rule__ActionSpec__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group__1" + // $ANTLR end "rule__Publisher__Group_6__0" - // $ANTLR start "rule__ActionSpec__Group__1__Impl" - // InternalRos.g:5949:1: rule__ActionSpec__Group__1__Impl : ( 'ActionSpec' ) ; - public final void rule__ActionSpec__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group_6__0__Impl" + // InternalRosParser.g:6068:1: rule__Publisher__Group_6__0__Impl : ( Ns ) ; + public final void rule__Publisher__Group_6__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5953:1: ( ( 'ActionSpec' ) ) - // InternalRos.g:5954:1: ( 'ActionSpec' ) + // InternalRosParser.g:6072:1: ( ( Ns ) ) + // InternalRosParser.g:6073:1: ( Ns ) { - // InternalRos.g:5954:1: ( 'ActionSpec' ) - // InternalRos.g:5955:2: 'ActionSpec' + // InternalRosParser.g:6073:1: ( Ns ) + // InternalRosParser.g:6074:2: Ns { - before(grammarAccess.getActionSpecAccess().getActionSpecKeyword_1()); - match(input,55,FOLLOW_2); - after(grammarAccess.getActionSpecAccess().getActionSpecKeyword_1()); + before(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); } @@ -18417,26 +18520,21 @@ public final void rule__ActionSpec__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ActionSpec__Group__1__Impl" + // $ANTLR end "rule__Publisher__Group_6__0__Impl" - // $ANTLR start "rule__ActionSpec__Group__2" - // InternalRos.g:5964:1: rule__ActionSpec__Group__2 : rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 ; - public final void rule__ActionSpec__Group__2() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group_6__1" + // InternalRosParser.g:6083:1: rule__Publisher__Group_6__1 : rule__Publisher__Group_6__1__Impl ; + public final void rule__Publisher__Group_6__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5968:1: ( rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 ) - // InternalRos.g:5969:2: rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 + // InternalRosParser.g:6087:1: ( rule__Publisher__Group_6__1__Impl ) + // InternalRosParser.g:6088:2: rule__Publisher__Group_6__1__Impl { - pushFollow(FOLLOW_4); - rule__ActionSpec__Group__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ActionSpec__Group__3(); + rule__Publisher__Group_6__1__Impl(); state._fsp--; @@ -18455,35 +18553,35 @@ public final void rule__ActionSpec__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group__2" + // $ANTLR end "rule__Publisher__Group_6__1" - // $ANTLR start "rule__ActionSpec__Group__2__Impl" - // InternalRos.g:5976:1: rule__ActionSpec__Group__2__Impl : ( ( rule__ActionSpec__NameAssignment_2 ) ) ; - public final void rule__ActionSpec__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Publisher__Group_6__1__Impl" + // InternalRosParser.g:6094:1: rule__Publisher__Group_6__1__Impl : ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) ; + public final void rule__Publisher__Group_6__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:5980:1: ( ( ( rule__ActionSpec__NameAssignment_2 ) ) ) - // InternalRos.g:5981:1: ( ( rule__ActionSpec__NameAssignment_2 ) ) + // InternalRosParser.g:6098:1: ( ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) ) + // InternalRosParser.g:6099:1: ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) { - // InternalRos.g:5981:1: ( ( rule__ActionSpec__NameAssignment_2 ) ) - // InternalRos.g:5982:2: ( rule__ActionSpec__NameAssignment_2 ) + // InternalRosParser.g:6099:1: ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) + // InternalRosParser.g:6100:2: ( rule__Publisher__NamespaceAssignment_6_1 ) { - before(grammarAccess.getActionSpecAccess().getNameAssignment_2()); - // InternalRos.g:5983:2: ( rule__ActionSpec__NameAssignment_2 ) - // InternalRos.g:5983:3: rule__ActionSpec__NameAssignment_2 + before(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); + // InternalRosParser.g:6101:2: ( rule__Publisher__NamespaceAssignment_6_1 ) + // InternalRosParser.g:6101:3: rule__Publisher__NamespaceAssignment_6_1 { pushFollow(FOLLOW_2); - rule__ActionSpec__NameAssignment_2(); + rule__Publisher__NamespaceAssignment_6_1(); state._fsp--; } - after(grammarAccess.getActionSpecAccess().getNameAssignment_2()); + after(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); } @@ -18502,26 +18600,26 @@ public final void rule__ActionSpec__Group__2__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ActionSpec__Group__2__Impl" + // $ANTLR end "rule__Publisher__Group_6__1__Impl" - // $ANTLR start "rule__ActionSpec__Group__3" - // InternalRos.g:5991:1: rule__ActionSpec__Group__3 : rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 ; - public final void rule__ActionSpec__Group__3() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__0" + // InternalRosParser.g:6110: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 { - // InternalRos.g:5995:1: ( rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 ) - // InternalRos.g:5996:2: rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 + // InternalRosParser.g:6114:1: ( rule__Subscriber__Group__0__Impl rule__Subscriber__Group__1 ) + // InternalRosParser.g:6115:2: rule__Subscriber__Group__0__Impl rule__Subscriber__Group__1 { - pushFollow(FOLLOW_25); - rule__ActionSpec__Group__3__Impl(); + pushFollow(FOLLOW_8); + rule__Subscriber__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ActionSpec__Group__4(); + rule__Subscriber__Group__1(); state._fsp--; @@ -18540,25 +18638,29 @@ public final void rule__ActionSpec__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group__3" + // $ANTLR end "rule__Subscriber__Group__0" - // $ANTLR start "rule__ActionSpec__Group__3__Impl" - // InternalRos.g:6003:1: rule__ActionSpec__Group__3__Impl : ( '{' ) ; - public final void rule__ActionSpec__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__0__Impl" + // InternalRosParser.g:6122:1: rule__Subscriber__Group__0__Impl : ( () ) ; + public final void rule__Subscriber__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6007:1: ( ( '{' ) ) - // InternalRos.g:6008:1: ( '{' ) + // InternalRosParser.g:6126:1: ( ( () ) ) + // InternalRosParser.g:6127:1: ( () ) + { + // InternalRosParser.g:6127:1: ( () ) + // InternalRosParser.g:6128:2: () { - // InternalRos.g:6008:1: ( '{' ) - // InternalRos.g:6009:2: '{' + before(grammarAccess.getSubscriberAccess().getSubscriberAction_0()); + // InternalRosParser.g:6129:2: () + // InternalRosParser.g:6129:3: { - before(grammarAccess.getActionSpecAccess().getLeftCurlyBracketKeyword_3()); - match(input,41,FOLLOW_2); - after(grammarAccess.getActionSpecAccess().getLeftCurlyBracketKeyword_3()); + } + + after(grammarAccess.getSubscriberAccess().getSubscriberAction_0()); } @@ -18566,10 +18668,6 @@ public final void rule__ActionSpec__Group__3__Impl() throws RecognitionException } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -18577,26 +18675,26 @@ public final void rule__ActionSpec__Group__3__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ActionSpec__Group__3__Impl" + // $ANTLR end "rule__Subscriber__Group__0__Impl" - // $ANTLR start "rule__ActionSpec__Group__4" - // InternalRos.g:6018:1: rule__ActionSpec__Group__4 : rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 ; - public final void rule__ActionSpec__Group__4() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__1" + // InternalRosParser.g:6137: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 { - // InternalRos.g:6022:1: ( rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 ) - // InternalRos.g:6023:2: rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 + // InternalRosParser.g:6141:1: ( rule__Subscriber__Group__1__Impl rule__Subscriber__Group__2 ) + // InternalRosParser.g:6142:2: rule__Subscriber__Group__1__Impl rule__Subscriber__Group__2 { - pushFollow(FOLLOW_25); - rule__ActionSpec__Group__4__Impl(); + pushFollow(FOLLOW_5); + rule__Subscriber__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ActionSpec__Group__5(); + rule__Subscriber__Group__2(); state._fsp--; @@ -18615,46 +18713,35 @@ public final void rule__ActionSpec__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group__4" + // $ANTLR end "rule__Subscriber__Group__1" - // $ANTLR start "rule__ActionSpec__Group__4__Impl" - // InternalRos.g:6030:1: rule__ActionSpec__Group__4__Impl : ( ( rule__ActionSpec__Group_4__0 )? ) ; - public final void rule__ActionSpec__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__1__Impl" + // InternalRosParser.g:6149:1: rule__Subscriber__Group__1__Impl : ( ( rule__Subscriber__NameAssignment_1 ) ) ; + public final void rule__Subscriber__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6034:1: ( ( ( rule__ActionSpec__Group_4__0 )? ) ) - // InternalRos.g:6035:1: ( ( rule__ActionSpec__Group_4__0 )? ) + // InternalRosParser.g:6153:1: ( ( ( rule__Subscriber__NameAssignment_1 ) ) ) + // InternalRosParser.g:6154:1: ( ( rule__Subscriber__NameAssignment_1 ) ) { - // InternalRos.g:6035:1: ( ( rule__ActionSpec__Group_4__0 )? ) - // InternalRos.g:6036:2: ( rule__ActionSpec__Group_4__0 )? + // InternalRosParser.g:6154:1: ( ( rule__Subscriber__NameAssignment_1 ) ) + // InternalRosParser.g:6155:2: ( rule__Subscriber__NameAssignment_1 ) { - before(grammarAccess.getActionSpecAccess().getGroup_4()); - // InternalRos.g:6037:2: ( rule__ActionSpec__Group_4__0 )? - int alt38=2; - int LA38_0 = input.LA(1); - - if ( (LA38_0==29) ) { - alt38=1; - } - switch (alt38) { - case 1 : - // InternalRos.g:6037:3: rule__ActionSpec__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__ActionSpec__Group_4__0(); - - state._fsp--; + before(grammarAccess.getSubscriberAccess().getNameAssignment_1()); + // InternalRosParser.g:6156:2: ( rule__Subscriber__NameAssignment_1 ) + // InternalRosParser.g:6156:3: rule__Subscriber__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Subscriber__NameAssignment_1(); + state._fsp--; - } - break; } - after(grammarAccess.getActionSpecAccess().getGroup_4()); + after(grammarAccess.getSubscriberAccess().getNameAssignment_1()); } @@ -18673,26 +18760,26 @@ public final void rule__ActionSpec__Group__4__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ActionSpec__Group__4__Impl" + // $ANTLR end "rule__Subscriber__Group__1__Impl" - // $ANTLR start "rule__ActionSpec__Group__5" - // InternalRos.g:6045:1: rule__ActionSpec__Group__5 : rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 ; - public final void rule__ActionSpec__Group__5() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__2" + // InternalRosParser.g:6164: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 { - // InternalRos.g:6049:1: ( rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 ) - // InternalRos.g:6050:2: rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 + // InternalRosParser.g:6168:1: ( rule__Subscriber__Group__2__Impl rule__Subscriber__Group__3 ) + // InternalRosParser.g:6169:2: rule__Subscriber__Group__2__Impl rule__Subscriber__Group__3 { - pushFollow(FOLLOW_25); - rule__ActionSpec__Group__5__Impl(); + pushFollow(FOLLOW_6); + rule__Subscriber__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ActionSpec__Group__6(); + rule__Subscriber__Group__3(); state._fsp--; @@ -18711,46 +18798,25 @@ public final void rule__ActionSpec__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group__5" + // $ANTLR end "rule__Subscriber__Group__2" - // $ANTLR start "rule__ActionSpec__Group__5__Impl" - // InternalRos.g:6057:1: rule__ActionSpec__Group__5__Impl : ( ( rule__ActionSpec__Group_5__0 )? ) ; - public final void rule__ActionSpec__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__2__Impl" + // InternalRosParser.g:6176:1: rule__Subscriber__Group__2__Impl : ( Colon ) ; + public final void rule__Subscriber__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6061:1: ( ( ( rule__ActionSpec__Group_5__0 )? ) ) - // InternalRos.g:6062:1: ( ( rule__ActionSpec__Group_5__0 )? ) + // InternalRosParser.g:6180:1: ( ( Colon ) ) + // InternalRosParser.g:6181:1: ( Colon ) { - // InternalRos.g:6062:1: ( ( rule__ActionSpec__Group_5__0 )? ) - // InternalRos.g:6063:2: ( rule__ActionSpec__Group_5__0 )? + // InternalRosParser.g:6181:1: ( Colon ) + // InternalRosParser.g:6182:2: Colon { - before(grammarAccess.getActionSpecAccess().getGroup_5()); - // InternalRos.g:6064:2: ( rule__ActionSpec__Group_5__0 )? - int alt39=2; - int LA39_0 = input.LA(1); - - if ( (LA39_0==31) ) { - alt39=1; - } - switch (alt39) { - case 1 : - // InternalRos.g:6064:3: rule__ActionSpec__Group_5__0 - { - pushFollow(FOLLOW_2); - rule__ActionSpec__Group_5__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getActionSpecAccess().getGroup_5()); + before(grammarAccess.getSubscriberAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getColonKeyword_2()); } @@ -18769,26 +18835,26 @@ public final void rule__ActionSpec__Group__5__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ActionSpec__Group__5__Impl" + // $ANTLR end "rule__Subscriber__Group__2__Impl" - // $ANTLR start "rule__ActionSpec__Group__6" - // InternalRos.g:6072:1: rule__ActionSpec__Group__6 : rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 ; - public final void rule__ActionSpec__Group__6() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__3" + // InternalRosParser.g:6191: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 { - // InternalRos.g:6076:1: ( rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 ) - // InternalRos.g:6077:2: rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 + // InternalRosParser.g:6195:1: ( rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 ) + // InternalRosParser.g:6196:2: rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 { - pushFollow(FOLLOW_25); - rule__ActionSpec__Group__6__Impl(); + pushFollow(FOLLOW_34); + rule__Subscriber__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ActionSpec__Group__7(); + rule__Subscriber__Group__4(); state._fsp--; @@ -18807,46 +18873,25 @@ public final void rule__ActionSpec__Group__6() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group__6" + // $ANTLR end "rule__Subscriber__Group__3" - // $ANTLR start "rule__ActionSpec__Group__6__Impl" - // InternalRos.g:6084:1: rule__ActionSpec__Group__6__Impl : ( ( rule__ActionSpec__Group_6__0 )? ) ; - public final void rule__ActionSpec__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__3__Impl" + // InternalRosParser.g:6203:1: rule__Subscriber__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Subscriber__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6088:1: ( ( ( rule__ActionSpec__Group_6__0 )? ) ) - // InternalRos.g:6089:1: ( ( rule__ActionSpec__Group_6__0 )? ) + // InternalRosParser.g:6207:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:6208:1: ( RULE_BEGIN ) { - // InternalRos.g:6089:1: ( ( rule__ActionSpec__Group_6__0 )? ) - // InternalRos.g:6090:2: ( rule__ActionSpec__Group_6__0 )? + // InternalRosParser.g:6208:1: ( RULE_BEGIN ) + // InternalRosParser.g:6209:2: RULE_BEGIN { - before(grammarAccess.getActionSpecAccess().getGroup_6()); - // InternalRos.g:6091:2: ( rule__ActionSpec__Group_6__0 )? - int alt40=2; - int LA40_0 = input.LA(1); - - if ( (LA40_0==32) ) { - alt40=1; - } - switch (alt40) { - case 1 : - // InternalRos.g:6091:3: rule__ActionSpec__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__ActionSpec__Group_6__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getActionSpecAccess().getGroup_6()); + before(grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); } @@ -18865,21 +18910,26 @@ public final void rule__ActionSpec__Group__6__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ActionSpec__Group__6__Impl" + // $ANTLR end "rule__Subscriber__Group__3__Impl" - // $ANTLR start "rule__ActionSpec__Group__7" - // InternalRos.g:6099:1: rule__ActionSpec__Group__7 : rule__ActionSpec__Group__7__Impl ; - public final void rule__ActionSpec__Group__7() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__4" + // InternalRosParser.g:6218: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 { - // InternalRos.g:6103:1: ( rule__ActionSpec__Group__7__Impl ) - // InternalRos.g:6104:2: rule__ActionSpec__Group__7__Impl + // InternalRosParser.g:6222:1: ( rule__Subscriber__Group__4__Impl rule__Subscriber__Group__5 ) + // InternalRosParser.g:6223:2: rule__Subscriber__Group__4__Impl rule__Subscriber__Group__5 { + pushFollow(FOLLOW_8); + rule__Subscriber__Group__4__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__ActionSpec__Group__7__Impl(); + rule__Subscriber__Group__5(); state._fsp--; @@ -18898,25 +18948,25 @@ public final void rule__ActionSpec__Group__7() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group__7" + // $ANTLR end "rule__Subscriber__Group__4" - // $ANTLR start "rule__ActionSpec__Group__7__Impl" - // InternalRos.g:6110:1: rule__ActionSpec__Group__7__Impl : ( '}' ) ; - public final void rule__ActionSpec__Group__7__Impl() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__4__Impl" + // InternalRosParser.g:6230:1: rule__Subscriber__Group__4__Impl : ( Type_1 ) ; + public final void rule__Subscriber__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6114:1: ( ( '}' ) ) - // InternalRos.g:6115:1: ( '}' ) + // InternalRosParser.g:6234:1: ( ( Type_1 ) ) + // InternalRosParser.g:6235:1: ( Type_1 ) { - // InternalRos.g:6115:1: ( '}' ) - // InternalRos.g:6116:2: '}' + // InternalRosParser.g:6235:1: ( Type_1 ) + // InternalRosParser.g:6236:2: Type_1 { - before(grammarAccess.getActionSpecAccess().getRightCurlyBracketKeyword_7()); - match(input,42,FOLLOW_2); - after(grammarAccess.getActionSpecAccess().getRightCurlyBracketKeyword_7()); + before(grammarAccess.getSubscriberAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getTypeKeyword_4()); } @@ -18935,96 +18985,26 @@ public final void rule__ActionSpec__Group__7__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ActionSpec__Group__7__Impl" + // $ANTLR end "rule__Subscriber__Group__4__Impl" - // $ANTLR start "rule__ActionSpec__Group_4__0" - // InternalRos.g:6126:1: rule__ActionSpec__Group_4__0 : rule__ActionSpec__Group_4__0__Impl rule__ActionSpec__Group_4__1 ; - public final void rule__ActionSpec__Group_4__0() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__5" + // InternalRosParser.g:6245: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 { - // InternalRos.g:6130:1: ( rule__ActionSpec__Group_4__0__Impl rule__ActionSpec__Group_4__1 ) - // InternalRos.g:6131:2: rule__ActionSpec__Group_4__0__Impl rule__ActionSpec__Group_4__1 + // InternalRosParser.g:6249:1: ( rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 ) + // InternalRosParser.g:6250:2: rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 { - pushFollow(FOLLOW_4); - rule__ActionSpec__Group_4__0__Impl(); + pushFollow(FOLLOW_35); + rule__Subscriber__Group__5__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ActionSpec__Group_4__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionSpec__Group_4__0" - - - // $ANTLR start "rule__ActionSpec__Group_4__0__Impl" - // InternalRos.g:6138:1: rule__ActionSpec__Group_4__0__Impl : ( 'goal' ) ; - public final void rule__ActionSpec__Group_4__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:6142:1: ( ( 'goal' ) ) - // InternalRos.g:6143:1: ( 'goal' ) - { - // InternalRos.g:6143:1: ( 'goal' ) - // InternalRos.g:6144:2: 'goal' - { - before(grammarAccess.getActionSpecAccess().getGoalKeyword_4_0()); - match(input,29,FOLLOW_2); - after(grammarAccess.getActionSpecAccess().getGoalKeyword_4_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionSpec__Group_4__0__Impl" - - - // $ANTLR start "rule__ActionSpec__Group_4__1" - // InternalRos.g:6153:1: rule__ActionSpec__Group_4__1 : rule__ActionSpec__Group_4__1__Impl ; - public final void rule__ActionSpec__Group_4__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:6157:1: ( rule__ActionSpec__Group_4__1__Impl ) - // InternalRos.g:6158:2: rule__ActionSpec__Group_4__1__Impl - { - pushFollow(FOLLOW_2); - rule__ActionSpec__Group_4__1__Impl(); + rule__Subscriber__Group__6(); state._fsp--; @@ -19043,35 +19023,35 @@ public final void rule__ActionSpec__Group_4__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group_4__1" + // $ANTLR end "rule__Subscriber__Group__5" - // $ANTLR start "rule__ActionSpec__Group_4__1__Impl" - // InternalRos.g:6164:1: rule__ActionSpec__Group_4__1__Impl : ( ( rule__ActionSpec__GoalAssignment_4_1 ) ) ; - public final void rule__ActionSpec__Group_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__5__Impl" + // InternalRosParser.g:6257:1: rule__Subscriber__Group__5__Impl : ( ( rule__Subscriber__MessageAssignment_5 ) ) ; + public final void rule__Subscriber__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6168:1: ( ( ( rule__ActionSpec__GoalAssignment_4_1 ) ) ) - // InternalRos.g:6169:1: ( ( rule__ActionSpec__GoalAssignment_4_1 ) ) + // InternalRosParser.g:6261:1: ( ( ( rule__Subscriber__MessageAssignment_5 ) ) ) + // InternalRosParser.g:6262:1: ( ( rule__Subscriber__MessageAssignment_5 ) ) { - // InternalRos.g:6169:1: ( ( rule__ActionSpec__GoalAssignment_4_1 ) ) - // InternalRos.g:6170:2: ( rule__ActionSpec__GoalAssignment_4_1 ) + // InternalRosParser.g:6262:1: ( ( rule__Subscriber__MessageAssignment_5 ) ) + // InternalRosParser.g:6263:2: ( rule__Subscriber__MessageAssignment_5 ) { - before(grammarAccess.getActionSpecAccess().getGoalAssignment_4_1()); - // InternalRos.g:6171:2: ( rule__ActionSpec__GoalAssignment_4_1 ) - // InternalRos.g:6171:3: rule__ActionSpec__GoalAssignment_4_1 + before(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); + // InternalRosParser.g:6264:2: ( rule__Subscriber__MessageAssignment_5 ) + // InternalRosParser.g:6264:3: rule__Subscriber__MessageAssignment_5 { pushFollow(FOLLOW_2); - rule__ActionSpec__GoalAssignment_4_1(); + rule__Subscriber__MessageAssignment_5(); state._fsp--; } - after(grammarAccess.getActionSpecAccess().getGoalAssignment_4_1()); + after(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); } @@ -19090,26 +19070,26 @@ public final void rule__ActionSpec__Group_4__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ActionSpec__Group_4__1__Impl" + // $ANTLR end "rule__Subscriber__Group__5__Impl" - // $ANTLR start "rule__ActionSpec__Group_5__0" - // InternalRos.g:6180:1: rule__ActionSpec__Group_5__0 : rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 ; - public final void rule__ActionSpec__Group_5__0() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__6" + // InternalRosParser.g:6272:1: rule__Subscriber__Group__6 : rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 ; + public final void rule__Subscriber__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6184:1: ( rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 ) - // InternalRos.g:6185:2: rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 + // InternalRosParser.g:6276:1: ( rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 ) + // InternalRosParser.g:6277:2: rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 { - pushFollow(FOLLOW_4); - rule__ActionSpec__Group_5__0__Impl(); + pushFollow(FOLLOW_35); + rule__Subscriber__Group__6__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ActionSpec__Group_5__1(); + rule__Subscriber__Group__7(); state._fsp--; @@ -19128,25 +19108,46 @@ public final void rule__ActionSpec__Group_5__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group_5__0" + // $ANTLR end "rule__Subscriber__Group__6" - // $ANTLR start "rule__ActionSpec__Group_5__0__Impl" - // InternalRos.g:6192:1: rule__ActionSpec__Group_5__0__Impl : ( 'result' ) ; - public final void rule__ActionSpec__Group_5__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__6__Impl" + // InternalRosParser.g:6284:1: rule__Subscriber__Group__6__Impl : ( ( rule__Subscriber__Group_6__0 )? ) ; + public final void rule__Subscriber__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6196:1: ( ( 'result' ) ) - // InternalRos.g:6197:1: ( 'result' ) + // InternalRosParser.g:6288:1: ( ( ( rule__Subscriber__Group_6__0 )? ) ) + // InternalRosParser.g:6289:1: ( ( rule__Subscriber__Group_6__0 )? ) { - // InternalRos.g:6197:1: ( 'result' ) - // InternalRos.g:6198:2: 'result' + // InternalRosParser.g:6289:1: ( ( rule__Subscriber__Group_6__0 )? ) + // InternalRosParser.g:6290:2: ( rule__Subscriber__Group_6__0 )? { - before(grammarAccess.getActionSpecAccess().getResultKeyword_5_0()); - match(input,31,FOLLOW_2); - after(grammarAccess.getActionSpecAccess().getResultKeyword_5_0()); + before(grammarAccess.getSubscriberAccess().getGroup_6()); + // InternalRosParser.g:6291:2: ( rule__Subscriber__Group_6__0 )? + int alt36=2; + int LA36_0 = input.LA(1); + + if ( (LA36_0==Ns) ) { + alt36=1; + } + switch (alt36) { + case 1 : + // InternalRosParser.g:6291:3: rule__Subscriber__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Subscriber__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getSubscriberAccess().getGroup_6()); } @@ -19165,21 +19166,21 @@ public final void rule__ActionSpec__Group_5__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ActionSpec__Group_5__0__Impl" + // $ANTLR end "rule__Subscriber__Group__6__Impl" - // $ANTLR start "rule__ActionSpec__Group_5__1" - // InternalRos.g:6207:1: rule__ActionSpec__Group_5__1 : rule__ActionSpec__Group_5__1__Impl ; - public final void rule__ActionSpec__Group_5__1() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__7" + // InternalRosParser.g:6299:1: rule__Subscriber__Group__7 : rule__Subscriber__Group__7__Impl ; + public final void rule__Subscriber__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6211:1: ( rule__ActionSpec__Group_5__1__Impl ) - // InternalRos.g:6212:2: rule__ActionSpec__Group_5__1__Impl + // InternalRosParser.g:6303:1: ( rule__Subscriber__Group__7__Impl ) + // InternalRosParser.g:6304:2: rule__Subscriber__Group__7__Impl { pushFollow(FOLLOW_2); - rule__ActionSpec__Group_5__1__Impl(); + rule__Subscriber__Group__7__Impl(); state._fsp--; @@ -19198,35 +19199,25 @@ public final void rule__ActionSpec__Group_5__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group_5__1" + // $ANTLR end "rule__Subscriber__Group__7" - // $ANTLR start "rule__ActionSpec__Group_5__1__Impl" - // InternalRos.g:6218:1: rule__ActionSpec__Group_5__1__Impl : ( ( rule__ActionSpec__ResultAssignment_5_1 ) ) ; - public final void rule__ActionSpec__Group_5__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group__7__Impl" + // InternalRosParser.g:6310:1: rule__Subscriber__Group__7__Impl : ( RULE_END ) ; + public final void rule__Subscriber__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6222:1: ( ( ( rule__ActionSpec__ResultAssignment_5_1 ) ) ) - // InternalRos.g:6223:1: ( ( rule__ActionSpec__ResultAssignment_5_1 ) ) - { - // InternalRos.g:6223:1: ( ( rule__ActionSpec__ResultAssignment_5_1 ) ) - // InternalRos.g:6224:2: ( rule__ActionSpec__ResultAssignment_5_1 ) + // InternalRosParser.g:6314:1: ( ( RULE_END ) ) + // InternalRosParser.g:6315:1: ( RULE_END ) { - before(grammarAccess.getActionSpecAccess().getResultAssignment_5_1()); - // InternalRos.g:6225:2: ( rule__ActionSpec__ResultAssignment_5_1 ) - // InternalRos.g:6225:3: rule__ActionSpec__ResultAssignment_5_1 + // InternalRosParser.g:6315:1: ( RULE_END ) + // InternalRosParser.g:6316:2: RULE_END { - pushFollow(FOLLOW_2); - rule__ActionSpec__ResultAssignment_5_1(); - - state._fsp--; - - - } - - after(grammarAccess.getActionSpecAccess().getResultAssignment_5_1()); + before(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); } @@ -19245,26 +19236,26 @@ public final void rule__ActionSpec__Group_5__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ActionSpec__Group_5__1__Impl" + // $ANTLR end "rule__Subscriber__Group__7__Impl" - // $ANTLR start "rule__ActionSpec__Group_6__0" - // InternalRos.g:6234:1: rule__ActionSpec__Group_6__0 : rule__ActionSpec__Group_6__0__Impl rule__ActionSpec__Group_6__1 ; - public final void rule__ActionSpec__Group_6__0() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group_6__0" + // InternalRosParser.g:6326:1: rule__Subscriber__Group_6__0 : rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 ; + public final void rule__Subscriber__Group_6__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6238:1: ( rule__ActionSpec__Group_6__0__Impl rule__ActionSpec__Group_6__1 ) - // InternalRos.g:6239:2: rule__ActionSpec__Group_6__0__Impl rule__ActionSpec__Group_6__1 + // InternalRosParser.g:6330:1: ( rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 ) + // InternalRosParser.g:6331:2: rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 { - pushFollow(FOLLOW_4); - rule__ActionSpec__Group_6__0__Impl(); + pushFollow(FOLLOW_36); + rule__Subscriber__Group_6__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ActionSpec__Group_6__1(); + rule__Subscriber__Group_6__1(); state._fsp--; @@ -19283,25 +19274,25 @@ public final void rule__ActionSpec__Group_6__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group_6__0" + // $ANTLR end "rule__Subscriber__Group_6__0" - // $ANTLR start "rule__ActionSpec__Group_6__0__Impl" - // InternalRos.g:6246:1: rule__ActionSpec__Group_6__0__Impl : ( 'feedback' ) ; - public final void rule__ActionSpec__Group_6__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group_6__0__Impl" + // InternalRosParser.g:6338:1: rule__Subscriber__Group_6__0__Impl : ( Ns ) ; + public final void rule__Subscriber__Group_6__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6250:1: ( ( 'feedback' ) ) - // InternalRos.g:6251:1: ( 'feedback' ) + // InternalRosParser.g:6342:1: ( ( Ns ) ) + // InternalRosParser.g:6343:1: ( Ns ) { - // InternalRos.g:6251:1: ( 'feedback' ) - // InternalRos.g:6252:2: 'feedback' + // InternalRosParser.g:6343:1: ( Ns ) + // InternalRosParser.g:6344:2: Ns { - before(grammarAccess.getActionSpecAccess().getFeedbackKeyword_6_0()); - match(input,32,FOLLOW_2); - after(grammarAccess.getActionSpecAccess().getFeedbackKeyword_6_0()); + before(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); } @@ -19320,21 +19311,21 @@ public final void rule__ActionSpec__Group_6__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ActionSpec__Group_6__0__Impl" + // $ANTLR end "rule__Subscriber__Group_6__0__Impl" - // $ANTLR start "rule__ActionSpec__Group_6__1" - // InternalRos.g:6261:1: rule__ActionSpec__Group_6__1 : rule__ActionSpec__Group_6__1__Impl ; - public final void rule__ActionSpec__Group_6__1() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group_6__1" + // InternalRosParser.g:6353:1: rule__Subscriber__Group_6__1 : rule__Subscriber__Group_6__1__Impl ; + public final void rule__Subscriber__Group_6__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6265:1: ( rule__ActionSpec__Group_6__1__Impl ) - // InternalRos.g:6266:2: rule__ActionSpec__Group_6__1__Impl + // InternalRosParser.g:6357:1: ( rule__Subscriber__Group_6__1__Impl ) + // InternalRosParser.g:6358:2: rule__Subscriber__Group_6__1__Impl { pushFollow(FOLLOW_2); - rule__ActionSpec__Group_6__1__Impl(); + rule__Subscriber__Group_6__1__Impl(); state._fsp--; @@ -19353,35 +19344,35 @@ public final void rule__ActionSpec__Group_6__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ActionSpec__Group_6__1" + // $ANTLR end "rule__Subscriber__Group_6__1" - // $ANTLR start "rule__ActionSpec__Group_6__1__Impl" - // InternalRos.g:6272:1: rule__ActionSpec__Group_6__1__Impl : ( ( rule__ActionSpec__FeedbackAssignment_6_1 ) ) ; - public final void rule__ActionSpec__Group_6__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Subscriber__Group_6__1__Impl" + // InternalRosParser.g:6364:1: rule__Subscriber__Group_6__1__Impl : ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) ; + public final void rule__Subscriber__Group_6__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6276:1: ( ( ( rule__ActionSpec__FeedbackAssignment_6_1 ) ) ) - // InternalRos.g:6277:1: ( ( rule__ActionSpec__FeedbackAssignment_6_1 ) ) + // InternalRosParser.g:6368:1: ( ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) ) + // InternalRosParser.g:6369:1: ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) { - // InternalRos.g:6277:1: ( ( rule__ActionSpec__FeedbackAssignment_6_1 ) ) - // InternalRos.g:6278:2: ( rule__ActionSpec__FeedbackAssignment_6_1 ) + // InternalRosParser.g:6369:1: ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) + // InternalRosParser.g:6370:2: ( rule__Subscriber__NamespaceAssignment_6_1 ) { - before(grammarAccess.getActionSpecAccess().getFeedbackAssignment_6_1()); - // InternalRos.g:6279:2: ( rule__ActionSpec__FeedbackAssignment_6_1 ) - // InternalRos.g:6279:3: rule__ActionSpec__FeedbackAssignment_6_1 + before(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); + // InternalRosParser.g:6371:2: ( rule__Subscriber__NamespaceAssignment_6_1 ) + // InternalRosParser.g:6371:3: rule__Subscriber__NamespaceAssignment_6_1 { pushFollow(FOLLOW_2); - rule__ActionSpec__FeedbackAssignment_6_1(); + rule__Subscriber__NamespaceAssignment_6_1(); state._fsp--; } - after(grammarAccess.getActionSpecAccess().getFeedbackAssignment_6_1()); + after(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); } @@ -19400,26 +19391,26 @@ public final void rule__ActionSpec__Group_6__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ActionSpec__Group_6__1__Impl" + // $ANTLR end "rule__Subscriber__Group_6__1__Impl" - // $ANTLR start "rule__MessageDefinition__Group__0" - // InternalRos.g:6288:1: rule__MessageDefinition__Group__0 : rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 ; - public final void rule__MessageDefinition__Group__0() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__0" + // InternalRosParser.g:6380:1: rule__ServiceServer__Group__0 : rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 ; + public final void rule__ServiceServer__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6292:1: ( rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 ) - // InternalRos.g:6293:2: rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 + // InternalRosParser.g:6384:1: ( rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 ) + // InternalRosParser.g:6385:2: rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 { - pushFollow(FOLLOW_4); - rule__MessageDefinition__Group__0__Impl(); + pushFollow(FOLLOW_8); + rule__ServiceServer__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__MessageDefinition__Group__1(); + rule__ServiceServer__Group__1(); state._fsp--; @@ -19438,29 +19429,29 @@ public final void rule__MessageDefinition__Group__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__MessageDefinition__Group__0" + // $ANTLR end "rule__ServiceServer__Group__0" - // $ANTLR start "rule__MessageDefinition__Group__0__Impl" - // InternalRos.g:6300:1: rule__MessageDefinition__Group__0__Impl : ( () ) ; - public final void rule__MessageDefinition__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__0__Impl" + // InternalRosParser.g:6392:1: rule__ServiceServer__Group__0__Impl : ( () ) ; + public final void rule__ServiceServer__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6304:1: ( ( () ) ) - // InternalRos.g:6305:1: ( () ) + // InternalRosParser.g:6396:1: ( ( () ) ) + // InternalRosParser.g:6397:1: ( () ) { - // InternalRos.g:6305:1: ( () ) - // InternalRos.g:6306:2: () + // InternalRosParser.g:6397:1: ( () ) + // InternalRosParser.g:6398:2: () { - before(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); - // InternalRos.g:6307:2: () - // InternalRos.g:6307:3: + before(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); + // InternalRosParser.g:6399:2: () + // InternalRosParser.g:6399:3: { } - after(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); + after(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); } @@ -19475,26 +19466,26 @@ public final void rule__MessageDefinition__Group__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__MessageDefinition__Group__0__Impl" + // $ANTLR end "rule__ServiceServer__Group__0__Impl" - // $ANTLR start "rule__MessageDefinition__Group__1" - // InternalRos.g:6315:1: rule__MessageDefinition__Group__1 : rule__MessageDefinition__Group__1__Impl rule__MessageDefinition__Group__2 ; - public final void rule__MessageDefinition__Group__1() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__1" + // InternalRosParser.g:6407:1: rule__ServiceServer__Group__1 : rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 ; + public final void rule__ServiceServer__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6319:1: ( rule__MessageDefinition__Group__1__Impl rule__MessageDefinition__Group__2 ) - // InternalRos.g:6320:2: rule__MessageDefinition__Group__1__Impl rule__MessageDefinition__Group__2 + // InternalRosParser.g:6411:1: ( rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 ) + // InternalRosParser.g:6412:2: rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 { - pushFollow(FOLLOW_26); - rule__MessageDefinition__Group__1__Impl(); + pushFollow(FOLLOW_5); + rule__ServiceServer__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__MessageDefinition__Group__2(); + rule__ServiceServer__Group__2(); state._fsp--; @@ -19513,121 +19504,35 @@ public final void rule__MessageDefinition__Group__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__MessageDefinition__Group__1" + // $ANTLR end "rule__ServiceServer__Group__1" - // $ANTLR start "rule__MessageDefinition__Group__1__Impl" - // InternalRos.g:6327:1: rule__MessageDefinition__Group__1__Impl : ( '{' ) ; - public final void rule__MessageDefinition__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__1__Impl" + // InternalRosParser.g:6419:1: rule__ServiceServer__Group__1__Impl : ( ( rule__ServiceServer__NameAssignment_1 ) ) ; + public final void rule__ServiceServer__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6331:1: ( ( '{' ) ) - // InternalRos.g:6332:1: ( '{' ) + // InternalRosParser.g:6423:1: ( ( ( rule__ServiceServer__NameAssignment_1 ) ) ) + // InternalRosParser.g:6424:1: ( ( rule__ServiceServer__NameAssignment_1 ) ) { - // InternalRos.g:6332:1: ( '{' ) - // InternalRos.g:6333:2: '{' + // InternalRosParser.g:6424:1: ( ( rule__ServiceServer__NameAssignment_1 ) ) + // InternalRosParser.g:6425:2: ( rule__ServiceServer__NameAssignment_1 ) { - before(grammarAccess.getMessageDefinitionAccess().getLeftCurlyBracketKeyword_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getMessageDefinitionAccess().getLeftCurlyBracketKeyword_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__MessageDefinition__Group__1__Impl" - - - // $ANTLR start "rule__MessageDefinition__Group__2" - // InternalRos.g:6342:1: rule__MessageDefinition__Group__2 : rule__MessageDefinition__Group__2__Impl rule__MessageDefinition__Group__3 ; - public final void rule__MessageDefinition__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:6346:1: ( rule__MessageDefinition__Group__2__Impl rule__MessageDefinition__Group__3 ) - // InternalRos.g:6347:2: rule__MessageDefinition__Group__2__Impl rule__MessageDefinition__Group__3 + before(grammarAccess.getServiceServerAccess().getNameAssignment_1()); + // InternalRosParser.g:6426:2: ( rule__ServiceServer__NameAssignment_1 ) + // InternalRosParser.g:6426:3: rule__ServiceServer__NameAssignment_1 { - pushFollow(FOLLOW_26); - rule__MessageDefinition__Group__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__MessageDefinition__Group__3(); + rule__ServiceServer__NameAssignment_1(); state._fsp--; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__MessageDefinition__Group__2" - - - // $ANTLR start "rule__MessageDefinition__Group__2__Impl" - // InternalRos.g:6354:1: rule__MessageDefinition__Group__2__Impl : ( ( rule__MessageDefinition__Group_2__0 )? ) ; - public final void rule__MessageDefinition__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:6358:1: ( ( ( rule__MessageDefinition__Group_2__0 )? ) ) - // InternalRos.g:6359:1: ( ( rule__MessageDefinition__Group_2__0 )? ) - { - // InternalRos.g:6359:1: ( ( rule__MessageDefinition__Group_2__0 )? ) - // InternalRos.g:6360:2: ( rule__MessageDefinition__Group_2__0 )? - { - before(grammarAccess.getMessageDefinitionAccess().getGroup_2()); - // InternalRos.g:6361:2: ( rule__MessageDefinition__Group_2__0 )? - int alt41=2; - int LA41_0 = input.LA(1); - - if ( ((LA41_0>=RULE_STRING && LA41_0<=RULE_ID)||LA41_0==27||(LA41_0>=38 && LA41_0<=39)||(LA41_0>=87 && LA41_0<=112)) ) { - alt41=1; - } - switch (alt41) { - case 1 : - // InternalRos.g:6361:3: rule__MessageDefinition__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__MessageDefinition__Group_2__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getMessageDefinitionAccess().getGroup_2()); + after(grammarAccess.getServiceServerAccess().getNameAssignment_1()); } @@ -19646,21 +19551,26 @@ public final void rule__MessageDefinition__Group__2__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__MessageDefinition__Group__2__Impl" + // $ANTLR end "rule__ServiceServer__Group__1__Impl" - // $ANTLR start "rule__MessageDefinition__Group__3" - // InternalRos.g:6369:1: rule__MessageDefinition__Group__3 : rule__MessageDefinition__Group__3__Impl ; - public final void rule__MessageDefinition__Group__3() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__2" + // InternalRosParser.g:6434:1: rule__ServiceServer__Group__2 : rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 ; + public final void rule__ServiceServer__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6373:1: ( rule__MessageDefinition__Group__3__Impl ) - // InternalRos.g:6374:2: rule__MessageDefinition__Group__3__Impl + // InternalRosParser.g:6438:1: ( rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 ) + // InternalRosParser.g:6439:2: rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 { + pushFollow(FOLLOW_6); + rule__ServiceServer__Group__2__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__MessageDefinition__Group__3__Impl(); + rule__ServiceServer__Group__3(); state._fsp--; @@ -19679,25 +19589,25 @@ public final void rule__MessageDefinition__Group__3() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__MessageDefinition__Group__3" + // $ANTLR end "rule__ServiceServer__Group__2" - // $ANTLR start "rule__MessageDefinition__Group__3__Impl" - // InternalRos.g:6380:1: rule__MessageDefinition__Group__3__Impl : ( '}' ) ; - public final void rule__MessageDefinition__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__2__Impl" + // InternalRosParser.g:6446:1: rule__ServiceServer__Group__2__Impl : ( Colon ) ; + public final void rule__ServiceServer__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6384:1: ( ( '}' ) ) - // InternalRos.g:6385:1: ( '}' ) + // InternalRosParser.g:6450:1: ( ( Colon ) ) + // InternalRosParser.g:6451:1: ( Colon ) { - // InternalRos.g:6385:1: ( '}' ) - // InternalRos.g:6386:2: '}' + // InternalRosParser.g:6451:1: ( Colon ) + // InternalRosParser.g:6452:2: Colon { - before(grammarAccess.getMessageDefinitionAccess().getRightCurlyBracketKeyword_3()); - match(input,42,FOLLOW_2); - after(grammarAccess.getMessageDefinitionAccess().getRightCurlyBracketKeyword_3()); + before(grammarAccess.getServiceServerAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getColonKeyword_2()); } @@ -19716,26 +19626,26 @@ public final void rule__MessageDefinition__Group__3__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__MessageDefinition__Group__3__Impl" + // $ANTLR end "rule__ServiceServer__Group__2__Impl" - // $ANTLR start "rule__MessageDefinition__Group_2__0" - // InternalRos.g:6396:1: rule__MessageDefinition__Group_2__0 : rule__MessageDefinition__Group_2__0__Impl rule__MessageDefinition__Group_2__1 ; - public final void rule__MessageDefinition__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__3" + // InternalRosParser.g:6461:1: rule__ServiceServer__Group__3 : rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 ; + public final void rule__ServiceServer__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6400:1: ( rule__MessageDefinition__Group_2__0__Impl rule__MessageDefinition__Group_2__1 ) - // InternalRos.g:6401:2: rule__MessageDefinition__Group_2__0__Impl rule__MessageDefinition__Group_2__1 + // InternalRosParser.g:6465:1: ( rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 ) + // InternalRosParser.g:6466:2: rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 { - pushFollow(FOLLOW_27); - rule__MessageDefinition__Group_2__0__Impl(); + pushFollow(FOLLOW_34); + rule__ServiceServer__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__MessageDefinition__Group_2__1(); + rule__ServiceServer__Group__4(); state._fsp--; @@ -19754,35 +19664,100 @@ public final void rule__MessageDefinition__Group_2__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__MessageDefinition__Group_2__0" + // $ANTLR end "rule__ServiceServer__Group__3" - // $ANTLR start "rule__MessageDefinition__Group_2__0__Impl" - // InternalRos.g:6408:1: rule__MessageDefinition__Group_2__0__Impl : ( ( rule__MessageDefinition__MessagePartAssignment_2_0 ) ) ; - public final void rule__MessageDefinition__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__3__Impl" + // InternalRosParser.g:6473:1: rule__ServiceServer__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceServer__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6412:1: ( ( ( rule__MessageDefinition__MessagePartAssignment_2_0 ) ) ) - // InternalRos.g:6413:1: ( ( rule__MessageDefinition__MessagePartAssignment_2_0 ) ) + // InternalRosParser.g:6477:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:6478:1: ( RULE_BEGIN ) { - // InternalRos.g:6413:1: ( ( rule__MessageDefinition__MessagePartAssignment_2_0 ) ) - // InternalRos.g:6414:2: ( rule__MessageDefinition__MessagePartAssignment_2_0 ) + // InternalRosParser.g:6478:1: ( RULE_BEGIN ) + // InternalRosParser.g:6479:2: RULE_BEGIN { - before(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_2_0()); - // InternalRos.g:6415:2: ( rule__MessageDefinition__MessagePartAssignment_2_0 ) - // InternalRos.g:6415:3: rule__MessageDefinition__MessagePartAssignment_2_0 + before(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__3__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__4" + // InternalRosParser.g:6488:1: rule__ServiceServer__Group__4 : rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 ; + public final void rule__ServiceServer__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:6492:1: ( rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 ) + // InternalRosParser.g:6493:2: rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 { + pushFollow(FOLLOW_8); + rule__ServiceServer__Group__4__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__MessageDefinition__MessagePartAssignment_2_0(); + rule__ServiceServer__Group__5(); state._fsp--; } - after(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_2_0()); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__4" + + + // $ANTLR start "rule__ServiceServer__Group__4__Impl" + // InternalRosParser.g:6500:1: rule__ServiceServer__Group__4__Impl : ( Type_1 ) ; + public final void rule__ServiceServer__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:6504:1: ( ( Type_1 ) ) + // InternalRosParser.g:6505:1: ( Type_1 ) + { + // InternalRosParser.g:6505:1: ( Type_1 ) + // InternalRosParser.g:6506:2: Type_1 + { + before(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); } @@ -19801,21 +19776,26 @@ public final void rule__MessageDefinition__Group_2__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__MessageDefinition__Group_2__0__Impl" + // $ANTLR end "rule__ServiceServer__Group__4__Impl" - // $ANTLR start "rule__MessageDefinition__Group_2__1" - // InternalRos.g:6423:1: rule__MessageDefinition__Group_2__1 : rule__MessageDefinition__Group_2__1__Impl ; - public final void rule__MessageDefinition__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__5" + // InternalRosParser.g:6515:1: rule__ServiceServer__Group__5 : rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 ; + public final void rule__ServiceServer__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6427:1: ( rule__MessageDefinition__Group_2__1__Impl ) - // InternalRos.g:6428:2: rule__MessageDefinition__Group_2__1__Impl + // InternalRosParser.g:6519:1: ( rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 ) + // InternalRosParser.g:6520:2: rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 { + pushFollow(FOLLOW_35); + rule__ServiceServer__Group__5__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__MessageDefinition__Group_2__1__Impl(); + rule__ServiceServer__Group__6(); state._fsp--; @@ -19834,53 +19814,35 @@ public final void rule__MessageDefinition__Group_2__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__MessageDefinition__Group_2__1" + // $ANTLR end "rule__ServiceServer__Group__5" - // $ANTLR start "rule__MessageDefinition__Group_2__1__Impl" - // InternalRos.g:6434:1: rule__MessageDefinition__Group_2__1__Impl : ( ( rule__MessageDefinition__MessagePartAssignment_2_1 )* ) ; - public final void rule__MessageDefinition__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__5__Impl" + // InternalRosParser.g:6527:1: rule__ServiceServer__Group__5__Impl : ( ( rule__ServiceServer__ServiceAssignment_5 ) ) ; + public final void rule__ServiceServer__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6438:1: ( ( ( rule__MessageDefinition__MessagePartAssignment_2_1 )* ) ) - // InternalRos.g:6439:1: ( ( rule__MessageDefinition__MessagePartAssignment_2_1 )* ) + // InternalRosParser.g:6531:1: ( ( ( rule__ServiceServer__ServiceAssignment_5 ) ) ) + // InternalRosParser.g:6532:1: ( ( rule__ServiceServer__ServiceAssignment_5 ) ) { - // InternalRos.g:6439:1: ( ( rule__MessageDefinition__MessagePartAssignment_2_1 )* ) - // InternalRos.g:6440:2: ( rule__MessageDefinition__MessagePartAssignment_2_1 )* + // InternalRosParser.g:6532:1: ( ( rule__ServiceServer__ServiceAssignment_5 ) ) + // InternalRosParser.g:6533:2: ( rule__ServiceServer__ServiceAssignment_5 ) { - before(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_2_1()); - // InternalRos.g:6441:2: ( rule__MessageDefinition__MessagePartAssignment_2_1 )* - loop42: - do { - int alt42=2; - int LA42_0 = input.LA(1); - - if ( ((LA42_0>=RULE_STRING && LA42_0<=RULE_ID)||LA42_0==27||(LA42_0>=38 && LA42_0<=39)||(LA42_0>=87 && LA42_0<=112)) ) { - alt42=1; - } - - - switch (alt42) { - case 1 : - // InternalRos.g:6441:3: rule__MessageDefinition__MessagePartAssignment_2_1 - { - pushFollow(FOLLOW_28); - rule__MessageDefinition__MessagePartAssignment_2_1(); - - state._fsp--; + before(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); + // InternalRosParser.g:6534:2: ( rule__ServiceServer__ServiceAssignment_5 ) + // InternalRosParser.g:6534:3: rule__ServiceServer__ServiceAssignment_5 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__ServiceAssignment_5(); + state._fsp--; - } - break; - default : - break loop42; - } - } while (true); + } - after(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_2_1()); + after(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); } @@ -19899,26 +19861,26 @@ public final void rule__MessageDefinition__Group_2__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__MessageDefinition__Group_2__1__Impl" + // $ANTLR end "rule__ServiceServer__Group__5__Impl" - // $ANTLR start "rule__Node__Group__0" - // InternalRos.g:6450:1: rule__Node__Group__0 : rule__Node__Group__0__Impl rule__Node__Group__1 ; - public final void rule__Node__Group__0() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__6" + // InternalRosParser.g:6542:1: rule__ServiceServer__Group__6 : rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 ; + public final void rule__ServiceServer__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6454:1: ( rule__Node__Group__0__Impl rule__Node__Group__1 ) - // InternalRos.g:6455:2: rule__Node__Group__0__Impl rule__Node__Group__1 + // InternalRosParser.g:6546:1: ( rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 ) + // InternalRosParser.g:6547:2: rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 { - pushFollow(FOLLOW_4); - rule__Node__Group__0__Impl(); + pushFollow(FOLLOW_35); + rule__ServiceServer__Group__6__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group__1(); + rule__ServiceServer__Group__7(); state._fsp--; @@ -19937,25 +19899,46 @@ public final void rule__Node__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__0" + // $ANTLR end "rule__ServiceServer__Group__6" - // $ANTLR start "rule__Node__Group__0__Impl" - // InternalRos.g:6462:1: rule__Node__Group__0__Impl : ( 'Node' ) ; - public final void rule__Node__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__6__Impl" + // InternalRosParser.g:6554:1: rule__ServiceServer__Group__6__Impl : ( ( rule__ServiceServer__Group_6__0 )? ) ; + public final void rule__ServiceServer__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6466:1: ( ( 'Node' ) ) - // InternalRos.g:6467:1: ( 'Node' ) + // InternalRosParser.g:6558:1: ( ( ( rule__ServiceServer__Group_6__0 )? ) ) + // InternalRosParser.g:6559:1: ( ( rule__ServiceServer__Group_6__0 )? ) { - // InternalRos.g:6467:1: ( 'Node' ) - // InternalRos.g:6468:2: 'Node' + // InternalRosParser.g:6559:1: ( ( rule__ServiceServer__Group_6__0 )? ) + // InternalRosParser.g:6560:2: ( rule__ServiceServer__Group_6__0 )? { - before(grammarAccess.getNodeAccess().getNodeKeyword_0()); - match(input,56,FOLLOW_2); - after(grammarAccess.getNodeAccess().getNodeKeyword_0()); + before(grammarAccess.getServiceServerAccess().getGroup_6()); + // InternalRosParser.g:6561:2: ( rule__ServiceServer__Group_6__0 )? + int alt37=2; + int LA37_0 = input.LA(1); + + if ( (LA37_0==Ns) ) { + alt37=1; + } + switch (alt37) { + case 1 : + // InternalRosParser.g:6561:3: rule__ServiceServer__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceServerAccess().getGroup_6()); } @@ -19974,26 +19957,21 @@ public final void rule__Node__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__0__Impl" + // $ANTLR end "rule__ServiceServer__Group__6__Impl" - // $ANTLR start "rule__Node__Group__1" - // InternalRos.g:6477:1: rule__Node__Group__1 : rule__Node__Group__1__Impl rule__Node__Group__2 ; - public final void rule__Node__Group__1() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__7" + // InternalRosParser.g:6569:1: rule__ServiceServer__Group__7 : rule__ServiceServer__Group__7__Impl ; + public final void rule__ServiceServer__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6481:1: ( rule__Node__Group__1__Impl rule__Node__Group__2 ) - // InternalRos.g:6482:2: rule__Node__Group__1__Impl rule__Node__Group__2 + // InternalRosParser.g:6573:1: ( rule__ServiceServer__Group__7__Impl ) + // InternalRosParser.g:6574:2: rule__ServiceServer__Group__7__Impl { - pushFollow(FOLLOW_29); - rule__Node__Group__1__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Node__Group__2(); + rule__ServiceServer__Group__7__Impl(); state._fsp--; @@ -20012,25 +19990,25 @@ public final void rule__Node__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__1" + // $ANTLR end "rule__ServiceServer__Group__7" - // $ANTLR start "rule__Node__Group__1__Impl" - // InternalRos.g:6489:1: rule__Node__Group__1__Impl : ( '{' ) ; - public final void rule__Node__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group__7__Impl" + // InternalRosParser.g:6580:1: rule__ServiceServer__Group__7__Impl : ( RULE_END ) ; + public final void rule__ServiceServer__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6493:1: ( ( '{' ) ) - // InternalRos.g:6494:1: ( '{' ) + // InternalRosParser.g:6584:1: ( ( RULE_END ) ) + // InternalRosParser.g:6585:1: ( RULE_END ) { - // InternalRos.g:6494:1: ( '{' ) - // InternalRos.g:6495:2: '{' + // InternalRosParser.g:6585:1: ( RULE_END ) + // InternalRosParser.g:6586:2: RULE_END { - before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_1()); + before(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); } @@ -20049,26 +20027,26 @@ public final void rule__Node__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__1__Impl" + // $ANTLR end "rule__ServiceServer__Group__7__Impl" - // $ANTLR start "rule__Node__Group__2" - // InternalRos.g:6504:1: rule__Node__Group__2 : rule__Node__Group__2__Impl rule__Node__Group__3 ; - public final void rule__Node__Group__2() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group_6__0" + // InternalRosParser.g:6596:1: rule__ServiceServer__Group_6__0 : rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 ; + public final void rule__ServiceServer__Group_6__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6508:1: ( rule__Node__Group__2__Impl rule__Node__Group__3 ) - // InternalRos.g:6509:2: rule__Node__Group__2__Impl rule__Node__Group__3 + // InternalRosParser.g:6600:1: ( rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 ) + // InternalRosParser.g:6601:2: rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 { - pushFollow(FOLLOW_15); - rule__Node__Group__2__Impl(); + pushFollow(FOLLOW_36); + rule__ServiceServer__Group_6__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group__3(); + rule__ServiceServer__Group_6__1(); state._fsp--; @@ -20087,25 +20065,25 @@ public final void rule__Node__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__2" + // $ANTLR end "rule__ServiceServer__Group_6__0" - // $ANTLR start "rule__Node__Group__2__Impl" - // InternalRos.g:6516:1: rule__Node__Group__2__Impl : ( 'name' ) ; - public final void rule__Node__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group_6__0__Impl" + // InternalRosParser.g:6608:1: rule__ServiceServer__Group_6__0__Impl : ( Ns ) ; + public final void rule__ServiceServer__Group_6__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6520:1: ( ( 'name' ) ) - // InternalRos.g:6521:1: ( 'name' ) + // InternalRosParser.g:6612:1: ( ( Ns ) ) + // InternalRosParser.g:6613:1: ( Ns ) { - // InternalRos.g:6521:1: ( 'name' ) - // InternalRos.g:6522:2: 'name' + // InternalRosParser.g:6613:1: ( Ns ) + // InternalRosParser.g:6614:2: Ns { - before(grammarAccess.getNodeAccess().getNameKeyword_2()); - match(input,33,FOLLOW_2); - after(grammarAccess.getNodeAccess().getNameKeyword_2()); + before(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); } @@ -20124,26 +20102,21 @@ public final void rule__Node__Group__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__2__Impl" + // $ANTLR end "rule__ServiceServer__Group_6__0__Impl" - // $ANTLR start "rule__Node__Group__3" - // InternalRos.g:6531:1: rule__Node__Group__3 : rule__Node__Group__3__Impl rule__Node__Group__4 ; - public final void rule__Node__Group__3() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group_6__1" + // InternalRosParser.g:6623:1: rule__ServiceServer__Group_6__1 : rule__ServiceServer__Group_6__1__Impl ; + public final void rule__ServiceServer__Group_6__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6535:1: ( rule__Node__Group__3__Impl rule__Node__Group__4 ) - // InternalRos.g:6536:2: rule__Node__Group__3__Impl rule__Node__Group__4 + // InternalRosParser.g:6627:1: ( rule__ServiceServer__Group_6__1__Impl ) + // InternalRosParser.g:6628:2: rule__ServiceServer__Group_6__1__Impl { - pushFollow(FOLLOW_30); - rule__Node__Group__3__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Node__Group__4(); + rule__ServiceServer__Group_6__1__Impl(); state._fsp--; @@ -20162,35 +20135,35 @@ public final void rule__Node__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__3" + // $ANTLR end "rule__ServiceServer__Group_6__1" - // $ANTLR start "rule__Node__Group__3__Impl" - // InternalRos.g:6543:1: rule__Node__Group__3__Impl : ( ( rule__Node__NameAssignment_3 ) ) ; - public final void rule__Node__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__Group_6__1__Impl" + // InternalRosParser.g:6634:1: rule__ServiceServer__Group_6__1__Impl : ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) ; + public final void rule__ServiceServer__Group_6__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6547:1: ( ( ( rule__Node__NameAssignment_3 ) ) ) - // InternalRos.g:6548:1: ( ( rule__Node__NameAssignment_3 ) ) + // InternalRosParser.g:6638:1: ( ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) ) + // InternalRosParser.g:6639:1: ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) { - // InternalRos.g:6548:1: ( ( rule__Node__NameAssignment_3 ) ) - // InternalRos.g:6549:2: ( rule__Node__NameAssignment_3 ) + // InternalRosParser.g:6639:1: ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) + // InternalRosParser.g:6640:2: ( rule__ServiceServer__NamespaceAssignment_6_1 ) { - before(grammarAccess.getNodeAccess().getNameAssignment_3()); - // InternalRos.g:6550:2: ( rule__Node__NameAssignment_3 ) - // InternalRos.g:6550:3: rule__Node__NameAssignment_3 + before(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); + // InternalRosParser.g:6641:2: ( rule__ServiceServer__NamespaceAssignment_6_1 ) + // InternalRosParser.g:6641:3: rule__ServiceServer__NamespaceAssignment_6_1 { pushFollow(FOLLOW_2); - rule__Node__NameAssignment_3(); + rule__ServiceServer__NamespaceAssignment_6_1(); state._fsp--; } - after(grammarAccess.getNodeAccess().getNameAssignment_3()); + after(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); } @@ -20209,26 +20182,26 @@ public final void rule__Node__Group__3__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__3__Impl" + // $ANTLR end "rule__ServiceServer__Group_6__1__Impl" - // $ANTLR start "rule__Node__Group__4" - // InternalRos.g:6558:1: rule__Node__Group__4 : rule__Node__Group__4__Impl rule__Node__Group__5 ; - public final void rule__Node__Group__4() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__0" + // InternalRosParser.g:6650:1: rule__ServiceClient__Group__0 : rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 ; + public final void rule__ServiceClient__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6562:1: ( rule__Node__Group__4__Impl rule__Node__Group__5 ) - // InternalRos.g:6563:2: rule__Node__Group__4__Impl rule__Node__Group__5 + // InternalRosParser.g:6654:1: ( rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 ) + // InternalRosParser.g:6655:2: rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 { - pushFollow(FOLLOW_30); - rule__Node__Group__4__Impl(); + pushFollow(FOLLOW_8); + rule__ServiceClient__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group__5(); + rule__ServiceClient__Group__1(); state._fsp--; @@ -20247,46 +20220,29 @@ public final void rule__Node__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__4" + // $ANTLR end "rule__ServiceClient__Group__0" - // $ANTLR start "rule__Node__Group__4__Impl" - // InternalRos.g:6570:1: rule__Node__Group__4__Impl : ( ( rule__Node__Group_4__0 )? ) ; - public final void rule__Node__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__0__Impl" + // InternalRosParser.g:6662:1: rule__ServiceClient__Group__0__Impl : ( () ) ; + public final void rule__ServiceClient__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6574:1: ( ( ( rule__Node__Group_4__0 )? ) ) - // InternalRos.g:6575:1: ( ( rule__Node__Group_4__0 )? ) + // InternalRosParser.g:6666:1: ( ( () ) ) + // InternalRosParser.g:6667:1: ( () ) { - // InternalRos.g:6575:1: ( ( rule__Node__Group_4__0 )? ) - // InternalRos.g:6576:2: ( rule__Node__Group_4__0 )? + // InternalRosParser.g:6667:1: ( () ) + // InternalRosParser.g:6668:2: () + { + before(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); + // InternalRosParser.g:6669:2: () + // InternalRosParser.g:6669:3: { - before(grammarAccess.getNodeAccess().getGroup_4()); - // InternalRos.g:6577:2: ( rule__Node__Group_4__0 )? - int alt43=2; - int LA43_0 = input.LA(1); - - if ( (LA43_0==57) ) { - alt43=1; - } - switch (alt43) { - case 1 : - // InternalRos.g:6577:3: rule__Node__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__Node__Group_4__0(); - - state._fsp--; - - - } - break; - } - after(grammarAccess.getNodeAccess().getGroup_4()); + after(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); } @@ -20294,10 +20250,6 @@ public final void rule__Node__Group__4__Impl() throws RecognitionException { } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -20305,26 +20257,26 @@ public final void rule__Node__Group__4__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__4__Impl" + // $ANTLR end "rule__ServiceClient__Group__0__Impl" - // $ANTLR start "rule__Node__Group__5" - // InternalRos.g:6585:1: rule__Node__Group__5 : rule__Node__Group__5__Impl rule__Node__Group__6 ; - public final void rule__Node__Group__5() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__1" + // InternalRosParser.g:6677:1: rule__ServiceClient__Group__1 : rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 ; + public final void rule__ServiceClient__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6589:1: ( rule__Node__Group__5__Impl rule__Node__Group__6 ) - // InternalRos.g:6590:2: rule__Node__Group__5__Impl rule__Node__Group__6 + // InternalRosParser.g:6681:1: ( rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 ) + // InternalRosParser.g:6682:2: rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 { - pushFollow(FOLLOW_30); - rule__Node__Group__5__Impl(); + pushFollow(FOLLOW_5); + rule__ServiceClient__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group__6(); + rule__ServiceClient__Group__2(); state._fsp--; @@ -20343,46 +20295,35 @@ public final void rule__Node__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__5" + // $ANTLR end "rule__ServiceClient__Group__1" - // $ANTLR start "rule__Node__Group__5__Impl" - // InternalRos.g:6597:1: rule__Node__Group__5__Impl : ( ( rule__Node__Group_5__0 )? ) ; - public final void rule__Node__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__1__Impl" + // InternalRosParser.g:6689:1: rule__ServiceClient__Group__1__Impl : ( ( rule__ServiceClient__NameAssignment_1 ) ) ; + public final void rule__ServiceClient__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6601:1: ( ( ( rule__Node__Group_5__0 )? ) ) - // InternalRos.g:6602:1: ( ( rule__Node__Group_5__0 )? ) + // InternalRosParser.g:6693:1: ( ( ( rule__ServiceClient__NameAssignment_1 ) ) ) + // InternalRosParser.g:6694:1: ( ( rule__ServiceClient__NameAssignment_1 ) ) { - // InternalRos.g:6602:1: ( ( rule__Node__Group_5__0 )? ) - // InternalRos.g:6603:2: ( rule__Node__Group_5__0 )? + // InternalRosParser.g:6694:1: ( ( rule__ServiceClient__NameAssignment_1 ) ) + // InternalRosParser.g:6695:2: ( rule__ServiceClient__NameAssignment_1 ) { - before(grammarAccess.getNodeAccess().getGroup_5()); - // InternalRos.g:6604:2: ( rule__Node__Group_5__0 )? - int alt44=2; - int LA44_0 = input.LA(1); - - if ( (LA44_0==58) ) { - alt44=1; - } - switch (alt44) { - case 1 : - // InternalRos.g:6604:3: rule__Node__Group_5__0 - { - pushFollow(FOLLOW_2); - rule__Node__Group_5__0(); - - state._fsp--; + before(grammarAccess.getServiceClientAccess().getNameAssignment_1()); + // InternalRosParser.g:6696:2: ( rule__ServiceClient__NameAssignment_1 ) + // InternalRosParser.g:6696:3: rule__ServiceClient__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__NameAssignment_1(); + state._fsp--; - } - break; } - after(grammarAccess.getNodeAccess().getGroup_5()); + after(grammarAccess.getServiceClientAccess().getNameAssignment_1()); } @@ -20401,26 +20342,26 @@ public final void rule__Node__Group__5__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__5__Impl" + // $ANTLR end "rule__ServiceClient__Group__1__Impl" - // $ANTLR start "rule__Node__Group__6" - // InternalRos.g:6612:1: rule__Node__Group__6 : rule__Node__Group__6__Impl rule__Node__Group__7 ; - public final void rule__Node__Group__6() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__2" + // InternalRosParser.g:6704:1: rule__ServiceClient__Group__2 : rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 ; + public final void rule__ServiceClient__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6616:1: ( rule__Node__Group__6__Impl rule__Node__Group__7 ) - // InternalRos.g:6617:2: rule__Node__Group__6__Impl rule__Node__Group__7 + // InternalRosParser.g:6708:1: ( rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 ) + // InternalRosParser.g:6709:2: rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 { - pushFollow(FOLLOW_30); - rule__Node__Group__6__Impl(); + pushFollow(FOLLOW_6); + rule__ServiceClient__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group__7(); + rule__ServiceClient__Group__3(); state._fsp--; @@ -20439,46 +20380,25 @@ public final void rule__Node__Group__6() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__6" + // $ANTLR end "rule__ServiceClient__Group__2" - // $ANTLR start "rule__Node__Group__6__Impl" - // InternalRos.g:6624:1: rule__Node__Group__6__Impl : ( ( rule__Node__Group_6__0 )? ) ; - public final void rule__Node__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__2__Impl" + // InternalRosParser.g:6716:1: rule__ServiceClient__Group__2__Impl : ( Colon ) ; + public final void rule__ServiceClient__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6628:1: ( ( ( rule__Node__Group_6__0 )? ) ) - // InternalRos.g:6629:1: ( ( rule__Node__Group_6__0 )? ) + // InternalRosParser.g:6720:1: ( ( Colon ) ) + // InternalRosParser.g:6721:1: ( Colon ) { - // InternalRos.g:6629:1: ( ( rule__Node__Group_6__0 )? ) - // InternalRos.g:6630:2: ( rule__Node__Group_6__0 )? + // InternalRosParser.g:6721:1: ( Colon ) + // InternalRosParser.g:6722:2: Colon { - before(grammarAccess.getNodeAccess().getGroup_6()); - // InternalRos.g:6631:2: ( rule__Node__Group_6__0 )? - int alt45=2; - int LA45_0 = input.LA(1); - - if ( (LA45_0==59) ) { - alt45=1; - } - switch (alt45) { - case 1 : - // InternalRos.g:6631:3: rule__Node__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__Node__Group_6__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getNodeAccess().getGroup_6()); + before(grammarAccess.getServiceClientAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getColonKeyword_2()); } @@ -20497,26 +20417,26 @@ public final void rule__Node__Group__6__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__6__Impl" + // $ANTLR end "rule__ServiceClient__Group__2__Impl" - // $ANTLR start "rule__Node__Group__7" - // InternalRos.g:6639:1: rule__Node__Group__7 : rule__Node__Group__7__Impl rule__Node__Group__8 ; - public final void rule__Node__Group__7() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__3" + // InternalRosParser.g:6731:1: rule__ServiceClient__Group__3 : rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 ; + public final void rule__ServiceClient__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6643:1: ( rule__Node__Group__7__Impl rule__Node__Group__8 ) - // InternalRos.g:6644:2: rule__Node__Group__7__Impl rule__Node__Group__8 + // InternalRosParser.g:6735:1: ( rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 ) + // InternalRosParser.g:6736:2: rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 { - pushFollow(FOLLOW_30); - rule__Node__Group__7__Impl(); + pushFollow(FOLLOW_34); + rule__ServiceClient__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group__8(); + rule__ServiceClient__Group__4(); state._fsp--; @@ -20535,46 +20455,25 @@ public final void rule__Node__Group__7() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__7" + // $ANTLR end "rule__ServiceClient__Group__3" - // $ANTLR start "rule__Node__Group__7__Impl" - // InternalRos.g:6651:1: rule__Node__Group__7__Impl : ( ( rule__Node__Group_7__0 )? ) ; - public final void rule__Node__Group__7__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__3__Impl" + // InternalRosParser.g:6743:1: rule__ServiceClient__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceClient__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6655:1: ( ( ( rule__Node__Group_7__0 )? ) ) - // InternalRos.g:6656:1: ( ( rule__Node__Group_7__0 )? ) + // InternalRosParser.g:6747:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:6748:1: ( RULE_BEGIN ) { - // InternalRos.g:6656:1: ( ( rule__Node__Group_7__0 )? ) - // InternalRos.g:6657:2: ( rule__Node__Group_7__0 )? + // InternalRosParser.g:6748:1: ( RULE_BEGIN ) + // InternalRosParser.g:6749:2: RULE_BEGIN { - before(grammarAccess.getNodeAccess().getGroup_7()); - // InternalRos.g:6658:2: ( rule__Node__Group_7__0 )? - int alt46=2; - int LA46_0 = input.LA(1); - - if ( (LA46_0==60) ) { - alt46=1; - } - switch (alt46) { - case 1 : - // InternalRos.g:6658:3: rule__Node__Group_7__0 - { - pushFollow(FOLLOW_2); - rule__Node__Group_7__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getNodeAccess().getGroup_7()); + before(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); } @@ -20593,26 +20492,26 @@ public final void rule__Node__Group__7__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__7__Impl" + // $ANTLR end "rule__ServiceClient__Group__3__Impl" - // $ANTLR start "rule__Node__Group__8" - // InternalRos.g:6666:1: rule__Node__Group__8 : rule__Node__Group__8__Impl rule__Node__Group__9 ; - public final void rule__Node__Group__8() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__4" + // InternalRosParser.g:6758:1: rule__ServiceClient__Group__4 : rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 ; + public final void rule__ServiceClient__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6670:1: ( rule__Node__Group__8__Impl rule__Node__Group__9 ) - // InternalRos.g:6671:2: rule__Node__Group__8__Impl rule__Node__Group__9 + // InternalRosParser.g:6762:1: ( rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 ) + // InternalRosParser.g:6763:2: rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 { - pushFollow(FOLLOW_30); - rule__Node__Group__8__Impl(); + pushFollow(FOLLOW_8); + rule__ServiceClient__Group__4__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group__9(); + rule__ServiceClient__Group__5(); state._fsp--; @@ -20631,46 +20530,25 @@ public final void rule__Node__Group__8() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__8" + // $ANTLR end "rule__ServiceClient__Group__4" - // $ANTLR start "rule__Node__Group__8__Impl" - // InternalRos.g:6678:1: rule__Node__Group__8__Impl : ( ( rule__Node__Group_8__0 )? ) ; - public final void rule__Node__Group__8__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__4__Impl" + // InternalRosParser.g:6770:1: rule__ServiceClient__Group__4__Impl : ( Type_1 ) ; + public final void rule__ServiceClient__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6682:1: ( ( ( rule__Node__Group_8__0 )? ) ) - // InternalRos.g:6683:1: ( ( rule__Node__Group_8__0 )? ) + // InternalRosParser.g:6774:1: ( ( Type_1 ) ) + // InternalRosParser.g:6775:1: ( Type_1 ) { - // InternalRos.g:6683:1: ( ( rule__Node__Group_8__0 )? ) - // InternalRos.g:6684:2: ( rule__Node__Group_8__0 )? + // InternalRosParser.g:6775:1: ( Type_1 ) + // InternalRosParser.g:6776:2: Type_1 { - before(grammarAccess.getNodeAccess().getGroup_8()); - // InternalRos.g:6685:2: ( rule__Node__Group_8__0 )? - int alt47=2; - int LA47_0 = input.LA(1); - - if ( (LA47_0==61) ) { - alt47=1; - } - switch (alt47) { - case 1 : - // InternalRos.g:6685:3: rule__Node__Group_8__0 - { - pushFollow(FOLLOW_2); - rule__Node__Group_8__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getNodeAccess().getGroup_8()); + before(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); } @@ -20689,26 +20567,26 @@ public final void rule__Node__Group__8__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__8__Impl" + // $ANTLR end "rule__ServiceClient__Group__4__Impl" - // $ANTLR start "rule__Node__Group__9" - // InternalRos.g:6693:1: rule__Node__Group__9 : rule__Node__Group__9__Impl rule__Node__Group__10 ; - public final void rule__Node__Group__9() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__5" + // InternalRosParser.g:6785:1: rule__ServiceClient__Group__5 : rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 ; + public final void rule__ServiceClient__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6697:1: ( rule__Node__Group__9__Impl rule__Node__Group__10 ) - // InternalRos.g:6698:2: rule__Node__Group__9__Impl rule__Node__Group__10 + // InternalRosParser.g:6789:1: ( rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 ) + // InternalRosParser.g:6790:2: rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 { - pushFollow(FOLLOW_30); - rule__Node__Group__9__Impl(); + pushFollow(FOLLOW_35); + rule__ServiceClient__Group__5__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group__10(); + rule__ServiceClient__Group__6(); state._fsp--; @@ -20727,46 +20605,35 @@ public final void rule__Node__Group__9() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__9" + // $ANTLR end "rule__ServiceClient__Group__5" - // $ANTLR start "rule__Node__Group__9__Impl" - // InternalRos.g:6705:1: rule__Node__Group__9__Impl : ( ( rule__Node__Group_9__0 )? ) ; - public final void rule__Node__Group__9__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__5__Impl" + // InternalRosParser.g:6797:1: rule__ServiceClient__Group__5__Impl : ( ( rule__ServiceClient__ServiceAssignment_5 ) ) ; + public final void rule__ServiceClient__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6709:1: ( ( ( rule__Node__Group_9__0 )? ) ) - // InternalRos.g:6710:1: ( ( rule__Node__Group_9__0 )? ) + // InternalRosParser.g:6801:1: ( ( ( rule__ServiceClient__ServiceAssignment_5 ) ) ) + // InternalRosParser.g:6802:1: ( ( rule__ServiceClient__ServiceAssignment_5 ) ) { - // InternalRos.g:6710:1: ( ( rule__Node__Group_9__0 )? ) - // InternalRos.g:6711:2: ( rule__Node__Group_9__0 )? + // InternalRosParser.g:6802:1: ( ( rule__ServiceClient__ServiceAssignment_5 ) ) + // InternalRosParser.g:6803:2: ( rule__ServiceClient__ServiceAssignment_5 ) { - before(grammarAccess.getNodeAccess().getGroup_9()); - // InternalRos.g:6712:2: ( rule__Node__Group_9__0 )? - int alt48=2; - int LA48_0 = input.LA(1); - - if ( (LA48_0==62) ) { - alt48=1; - } - switch (alt48) { - case 1 : - // InternalRos.g:6712:3: rule__Node__Group_9__0 - { - pushFollow(FOLLOW_2); - rule__Node__Group_9__0(); - - state._fsp--; + before(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); + // InternalRosParser.g:6804:2: ( rule__ServiceClient__ServiceAssignment_5 ) + // InternalRosParser.g:6804:3: rule__ServiceClient__ServiceAssignment_5 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__ServiceAssignment_5(); + state._fsp--; - } - break; } - after(grammarAccess.getNodeAccess().getGroup_9()); + after(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); } @@ -20785,26 +20652,26 @@ public final void rule__Node__Group__9__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__9__Impl" + // $ANTLR end "rule__ServiceClient__Group__5__Impl" - // $ANTLR start "rule__Node__Group__10" - // InternalRos.g:6720:1: rule__Node__Group__10 : rule__Node__Group__10__Impl rule__Node__Group__11 ; - public final void rule__Node__Group__10() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__6" + // InternalRosParser.g:6812:1: rule__ServiceClient__Group__6 : rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 ; + public final void rule__ServiceClient__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6724:1: ( rule__Node__Group__10__Impl rule__Node__Group__11 ) - // InternalRos.g:6725:2: rule__Node__Group__10__Impl rule__Node__Group__11 + // InternalRosParser.g:6816:1: ( rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 ) + // InternalRosParser.g:6817:2: rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 { - pushFollow(FOLLOW_30); - rule__Node__Group__10__Impl(); + pushFollow(FOLLOW_35); + rule__ServiceClient__Group__6__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group__11(); + rule__ServiceClient__Group__7(); state._fsp--; @@ -20823,36 +20690,36 @@ public final void rule__Node__Group__10() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__10" + // $ANTLR end "rule__ServiceClient__Group__6" - // $ANTLR start "rule__Node__Group__10__Impl" - // InternalRos.g:6732:1: rule__Node__Group__10__Impl : ( ( rule__Node__Group_10__0 )? ) ; - public final void rule__Node__Group__10__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__6__Impl" + // InternalRosParser.g:6824:1: rule__ServiceClient__Group__6__Impl : ( ( rule__ServiceClient__Group_6__0 )? ) ; + public final void rule__ServiceClient__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6736:1: ( ( ( rule__Node__Group_10__0 )? ) ) - // InternalRos.g:6737:1: ( ( rule__Node__Group_10__0 )? ) + // InternalRosParser.g:6828:1: ( ( ( rule__ServiceClient__Group_6__0 )? ) ) + // InternalRosParser.g:6829:1: ( ( rule__ServiceClient__Group_6__0 )? ) { - // InternalRos.g:6737:1: ( ( rule__Node__Group_10__0 )? ) - // InternalRos.g:6738:2: ( rule__Node__Group_10__0 )? + // InternalRosParser.g:6829:1: ( ( rule__ServiceClient__Group_6__0 )? ) + // InternalRosParser.g:6830:2: ( rule__ServiceClient__Group_6__0 )? { - before(grammarAccess.getNodeAccess().getGroup_10()); - // InternalRos.g:6739:2: ( rule__Node__Group_10__0 )? - int alt49=2; - int LA49_0 = input.LA(1); + before(grammarAccess.getServiceClientAccess().getGroup_6()); + // InternalRosParser.g:6831:2: ( rule__ServiceClient__Group_6__0 )? + int alt38=2; + int LA38_0 = input.LA(1); - if ( (LA49_0==63) ) { - alt49=1; + if ( (LA38_0==Ns) ) { + alt38=1; } - switch (alt49) { + switch (alt38) { case 1 : - // InternalRos.g:6739:3: rule__Node__Group_10__0 + // InternalRosParser.g:6831:3: rule__ServiceClient__Group_6__0 { pushFollow(FOLLOW_2); - rule__Node__Group_10__0(); + rule__ServiceClient__Group_6__0(); state._fsp--; @@ -20862,7 +20729,7 @@ public final void rule__Node__Group__10__Impl() throws RecognitionException { } - after(grammarAccess.getNodeAccess().getGroup_10()); + after(grammarAccess.getServiceClientAccess().getGroup_6()); } @@ -20881,21 +20748,21 @@ public final void rule__Node__Group__10__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__10__Impl" + // $ANTLR end "rule__ServiceClient__Group__6__Impl" - // $ANTLR start "rule__Node__Group__11" - // InternalRos.g:6747:1: rule__Node__Group__11 : rule__Node__Group__11__Impl ; - public final void rule__Node__Group__11() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__7" + // InternalRosParser.g:6839:1: rule__ServiceClient__Group__7 : rule__ServiceClient__Group__7__Impl ; + public final void rule__ServiceClient__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6751:1: ( rule__Node__Group__11__Impl ) - // InternalRos.g:6752:2: rule__Node__Group__11__Impl + // InternalRosParser.g:6843:1: ( rule__ServiceClient__Group__7__Impl ) + // InternalRosParser.g:6844:2: rule__ServiceClient__Group__7__Impl { pushFollow(FOLLOW_2); - rule__Node__Group__11__Impl(); + rule__ServiceClient__Group__7__Impl(); state._fsp--; @@ -20914,25 +20781,25 @@ public final void rule__Node__Group__11() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__11" + // $ANTLR end "rule__ServiceClient__Group__7" - // $ANTLR start "rule__Node__Group__11__Impl" - // InternalRos.g:6758:1: rule__Node__Group__11__Impl : ( '}' ) ; - public final void rule__Node__Group__11__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group__7__Impl" + // InternalRosParser.g:6850:1: rule__ServiceClient__Group__7__Impl : ( RULE_END ) ; + public final void rule__ServiceClient__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6762:1: ( ( '}' ) ) - // InternalRos.g:6763:1: ( '}' ) + // InternalRosParser.g:6854:1: ( ( RULE_END ) ) + // InternalRosParser.g:6855:1: ( RULE_END ) { - // InternalRos.g:6763:1: ( '}' ) - // InternalRos.g:6764:2: '}' + // InternalRosParser.g:6855:1: ( RULE_END ) + // InternalRosParser.g:6856:2: RULE_END { - before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_11()); - match(input,42,FOLLOW_2); - after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_11()); + before(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); } @@ -20951,26 +20818,26 @@ public final void rule__Node__Group__11__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group__11__Impl" + // $ANTLR end "rule__ServiceClient__Group__7__Impl" - // $ANTLR start "rule__Node__Group_4__0" - // InternalRos.g:6774: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 { + // $ANTLR start "rule__ServiceClient__Group_6__0" + // InternalRosParser.g:6866:1: rule__ServiceClient__Group_6__0 : rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 ; + public final void rule__ServiceClient__Group_6__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6778:1: ( rule__Node__Group_4__0__Impl rule__Node__Group_4__1 ) - // InternalRos.g:6779:2: rule__Node__Group_4__0__Impl rule__Node__Group_4__1 + // InternalRosParser.g:6870:1: ( rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 ) + // InternalRosParser.g:6871:2: rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 { - pushFollow(FOLLOW_4); - rule__Node__Group_4__0__Impl(); + pushFollow(FOLLOW_36); + rule__ServiceClient__Group_6__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_4__1(); + rule__ServiceClient__Group_6__1(); state._fsp--; @@ -20989,25 +20856,25 @@ public final void rule__Node__Group_4__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4__0" + // $ANTLR end "rule__ServiceClient__Group_6__0" - // $ANTLR start "rule__Node__Group_4__0__Impl" - // InternalRos.g:6786:1: rule__Node__Group_4__0__Impl : ( 'ServiceServers' ) ; - public final void rule__Node__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__Group_6__0__Impl" + // InternalRosParser.g:6878:1: rule__ServiceClient__Group_6__0__Impl : ( Ns ) ; + public final void rule__ServiceClient__Group_6__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6790:1: ( ( 'ServiceServers' ) ) - // InternalRos.g:6791:1: ( 'ServiceServers' ) + // InternalRosParser.g:6882:1: ( ( Ns ) ) + // InternalRosParser.g:6883:1: ( Ns ) { - // InternalRos.g:6791:1: ( 'ServiceServers' ) - // InternalRos.g:6792:2: 'ServiceServers' + // InternalRosParser.g:6883:1: ( Ns ) + // InternalRosParser.g:6884:2: Ns { - before(grammarAccess.getNodeAccess().getServiceServersKeyword_4_0()); - match(input,57,FOLLOW_2); - after(grammarAccess.getNodeAccess().getServiceServersKeyword_4_0()); + before(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); } @@ -21026,30 +20893,72 @@ public final void rule__Node__Group_4__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4__0__Impl" + // $ANTLR end "rule__ServiceClient__Group_6__0__Impl" - // $ANTLR start "rule__Node__Group_4__1" - // InternalRos.g:6801: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 { + // $ANTLR start "rule__ServiceClient__Group_6__1" + // InternalRosParser.g:6893:1: rule__ServiceClient__Group_6__1 : rule__ServiceClient__Group_6__1__Impl ; + public final void rule__ServiceClient__Group_6__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6805:1: ( rule__Node__Group_4__1__Impl rule__Node__Group_4__2 ) - // InternalRos.g:6806:2: rule__Node__Group_4__1__Impl rule__Node__Group_4__2 + // InternalRosParser.g:6897:1: ( rule__ServiceClient__Group_6__1__Impl ) + // InternalRosParser.g:6898:2: rule__ServiceClient__Group_6__1__Impl { - pushFollow(FOLLOW_31); - rule__Node__Group_4__1__Impl(); + pushFollow(FOLLOW_2); + rule__ServiceClient__Group_6__1__Impl(); state._fsp--; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_6__1" + + + // $ANTLR start "rule__ServiceClient__Group_6__1__Impl" + // InternalRosParser.g:6904:1: rule__ServiceClient__Group_6__1__Impl : ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) ; + public final void rule__ServiceClient__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:6908:1: ( ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) ) + // InternalRosParser.g:6909:1: ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) + { + // InternalRosParser.g:6909:1: ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) + // InternalRosParser.g:6910:2: ( rule__ServiceClient__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); + // InternalRosParser.g:6911:2: ( rule__ServiceClient__NamespaceAssignment_6_1 ) + // InternalRosParser.g:6911:3: rule__ServiceClient__NamespaceAssignment_6_1 + { pushFollow(FOLLOW_2); - rule__Node__Group_4__2(); + rule__ServiceClient__NamespaceAssignment_6_1(); state._fsp--; + } + + after(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); + + } + + } } @@ -21064,27 +20973,28 @@ public final void rule__Node__Group_4__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4__1" + // $ANTLR end "rule__ServiceClient__Group_6__1__Impl" - // $ANTLR start "rule__Node__Group_4__1__Impl" - // InternalRos.g:6813:1: rule__Node__Group_4__1__Impl : ( '{' ) ; - public final void rule__Node__Group_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group__0" + // InternalRosParser.g:6920:1: rule__ActionServer__Group__0 : rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 ; + public final void rule__ActionServer__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6817:1: ( ( '{' ) ) - // InternalRos.g:6818:1: ( '{' ) + // InternalRosParser.g:6924:1: ( rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 ) + // InternalRosParser.g:6925:2: rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 { - // InternalRos.g:6818:1: ( '{' ) - // InternalRos.g:6819:2: '{' - { - before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_4_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_4_1()); + pushFollow(FOLLOW_8); + rule__ActionServer__Group__0__Impl(); - } + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__1(); + + state._fsp--; } @@ -21101,26 +21011,63 @@ public final void rule__Node__Group_4__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4__1__Impl" + // $ANTLR end "rule__ActionServer__Group__0" + + + // $ANTLR start "rule__ActionServer__Group__0__Impl" + // InternalRosParser.g:6932:1: rule__ActionServer__Group__0__Impl : ( () ) ; + public final void rule__ActionServer__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:6936:1: ( ( () ) ) + // InternalRosParser.g:6937:1: ( () ) + { + // InternalRosParser.g:6937:1: ( () ) + // InternalRosParser.g:6938:2: () + { + before(grammarAccess.getActionServerAccess().getActionServerAction_0()); + // InternalRosParser.g:6939:2: () + // InternalRosParser.g:6939:3: + { + } + + after(grammarAccess.getActionServerAccess().getActionServerAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__0__Impl" - // $ANTLR start "rule__Node__Group_4__2" - // InternalRos.g:6828: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 { + // $ANTLR start "rule__ActionServer__Group__1" + // InternalRosParser.g:6947:1: rule__ActionServer__Group__1 : rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 ; + public final void rule__ActionServer__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6832:1: ( rule__Node__Group_4__2__Impl rule__Node__Group_4__3 ) - // InternalRos.g:6833:2: rule__Node__Group_4__2__Impl rule__Node__Group_4__3 + // InternalRosParser.g:6951:1: ( rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 ) + // InternalRosParser.g:6952:2: rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 { - pushFollow(FOLLOW_13); - rule__Node__Group_4__2__Impl(); + pushFollow(FOLLOW_5); + rule__ActionServer__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_4__3(); + rule__ActionServer__Group__2(); state._fsp--; @@ -21139,35 +21086,35 @@ public final void rule__Node__Group_4__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4__2" + // $ANTLR end "rule__ActionServer__Group__1" - // $ANTLR start "rule__Node__Group_4__2__Impl" - // InternalRos.g:6840:1: rule__Node__Group_4__2__Impl : ( ( rule__Node__ServiceserverAssignment_4_2 ) ) ; - public final void rule__Node__Group_4__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group__1__Impl" + // InternalRosParser.g:6959:1: rule__ActionServer__Group__1__Impl : ( ( rule__ActionServer__NameAssignment_1 ) ) ; + public final void rule__ActionServer__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6844:1: ( ( ( rule__Node__ServiceserverAssignment_4_2 ) ) ) - // InternalRos.g:6845:1: ( ( rule__Node__ServiceserverAssignment_4_2 ) ) + // InternalRosParser.g:6963:1: ( ( ( rule__ActionServer__NameAssignment_1 ) ) ) + // InternalRosParser.g:6964:1: ( ( rule__ActionServer__NameAssignment_1 ) ) { - // InternalRos.g:6845:1: ( ( rule__Node__ServiceserverAssignment_4_2 ) ) - // InternalRos.g:6846:2: ( rule__Node__ServiceserverAssignment_4_2 ) + // InternalRosParser.g:6964:1: ( ( rule__ActionServer__NameAssignment_1 ) ) + // InternalRosParser.g:6965:2: ( rule__ActionServer__NameAssignment_1 ) { - before(grammarAccess.getNodeAccess().getServiceserverAssignment_4_2()); - // InternalRos.g:6847:2: ( rule__Node__ServiceserverAssignment_4_2 ) - // InternalRos.g:6847:3: rule__Node__ServiceserverAssignment_4_2 + before(grammarAccess.getActionServerAccess().getNameAssignment_1()); + // InternalRosParser.g:6966:2: ( rule__ActionServer__NameAssignment_1 ) + // InternalRosParser.g:6966:3: rule__ActionServer__NameAssignment_1 { pushFollow(FOLLOW_2); - rule__Node__ServiceserverAssignment_4_2(); + rule__ActionServer__NameAssignment_1(); state._fsp--; } - after(grammarAccess.getNodeAccess().getServiceserverAssignment_4_2()); + after(grammarAccess.getActionServerAccess().getNameAssignment_1()); } @@ -21186,26 +21133,26 @@ public final void rule__Node__Group_4__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4__2__Impl" + // $ANTLR end "rule__ActionServer__Group__1__Impl" - // $ANTLR start "rule__Node__Group_4__3" - // InternalRos.g:6855:1: rule__Node__Group_4__3 : rule__Node__Group_4__3__Impl rule__Node__Group_4__4 ; - public final void rule__Node__Group_4__3() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group__2" + // InternalRosParser.g:6974:1: rule__ActionServer__Group__2 : rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 ; + public final void rule__ActionServer__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6859:1: ( rule__Node__Group_4__3__Impl rule__Node__Group_4__4 ) - // InternalRos.g:6860:2: rule__Node__Group_4__3__Impl rule__Node__Group_4__4 + // InternalRosParser.g:6978:1: ( rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 ) + // InternalRosParser.g:6979:2: rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 { - pushFollow(FOLLOW_13); - rule__Node__Group_4__3__Impl(); + pushFollow(FOLLOW_6); + rule__ActionServer__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_4__4(); + rule__ActionServer__Group__3(); state._fsp--; @@ -21224,53 +21171,100 @@ public final void rule__Node__Group_4__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4__3" + // $ANTLR end "rule__ActionServer__Group__2" - // $ANTLR start "rule__Node__Group_4__3__Impl" - // InternalRos.g:6867:1: rule__Node__Group_4__3__Impl : ( ( rule__Node__Group_4_3__0 )* ) ; - public final void rule__Node__Group_4__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group__2__Impl" + // InternalRosParser.g:6986:1: rule__ActionServer__Group__2__Impl : ( Colon ) ; + public final void rule__ActionServer__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6871:1: ( ( ( rule__Node__Group_4_3__0 )* ) ) - // InternalRos.g:6872:1: ( ( rule__Node__Group_4_3__0 )* ) + // InternalRosParser.g:6990:1: ( ( Colon ) ) + // InternalRosParser.g:6991:1: ( Colon ) { - // InternalRos.g:6872:1: ( ( rule__Node__Group_4_3__0 )* ) - // InternalRos.g:6873:2: ( rule__Node__Group_4_3__0 )* + // InternalRosParser.g:6991:1: ( Colon ) + // InternalRosParser.g:6992:2: Colon { - before(grammarAccess.getNodeAccess().getGroup_4_3()); - // InternalRos.g:6874:2: ( rule__Node__Group_4_3__0 )* - loop50: - do { - int alt50=2; - int LA50_0 = input.LA(1); + before(grammarAccess.getActionServerAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getColonKeyword_2()); - if ( (LA50_0==43) ) { - alt50=1; - } + } - switch (alt50) { - case 1 : - // InternalRos.g:6874:3: rule__Node__Group_4_3__0 - { - pushFollow(FOLLOW_7); - rule__Node__Group_4_3__0(); + } - state._fsp--; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + restoreStackSize(stackSize); - } - break; + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__2__Impl" - default : - break loop50; - } - } while (true); - after(grammarAccess.getNodeAccess().getGroup_4_3()); + // $ANTLR start "rule__ActionServer__Group__3" + // InternalRosParser.g:7001:1: rule__ActionServer__Group__3 : rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 ; + public final void rule__ActionServer__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:7005:1: ( rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 ) + // InternalRosParser.g:7006:2: rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 + { + pushFollow(FOLLOW_34); + rule__ActionServer__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__3" + + + // $ANTLR start "rule__ActionServer__Group__3__Impl" + // InternalRosParser.g:7013:1: rule__ActionServer__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionServer__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:7017:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:7018:1: ( RULE_BEGIN ) + { + // InternalRosParser.g:7018:1: ( RULE_BEGIN ) + // InternalRosParser.g:7019:2: RULE_BEGIN + { + before(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); } @@ -21289,21 +21283,26 @@ public final void rule__Node__Group_4__3__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4__3__Impl" + // $ANTLR end "rule__ActionServer__Group__3__Impl" - // $ANTLR start "rule__Node__Group_4__4" - // InternalRos.g:6882:1: rule__Node__Group_4__4 : rule__Node__Group_4__4__Impl ; - public final void rule__Node__Group_4__4() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group__4" + // InternalRosParser.g:7028:1: rule__ActionServer__Group__4 : rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 ; + public final void rule__ActionServer__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6886:1: ( rule__Node__Group_4__4__Impl ) - // InternalRos.g:6887:2: rule__Node__Group_4__4__Impl + // InternalRosParser.g:7032:1: ( rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 ) + // InternalRosParser.g:7033:2: rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 { + pushFollow(FOLLOW_8); + rule__ActionServer__Group__4__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Node__Group_4__4__Impl(); + rule__ActionServer__Group__5(); state._fsp--; @@ -21322,25 +21321,25 @@ public final void rule__Node__Group_4__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4__4" + // $ANTLR end "rule__ActionServer__Group__4" - // $ANTLR start "rule__Node__Group_4__4__Impl" - // InternalRos.g:6893:1: rule__Node__Group_4__4__Impl : ( '}' ) ; - public final void rule__Node__Group_4__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group__4__Impl" + // InternalRosParser.g:7040:1: rule__ActionServer__Group__4__Impl : ( Type_1 ) ; + public final void rule__ActionServer__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6897:1: ( ( '}' ) ) - // InternalRos.g:6898:1: ( '}' ) + // InternalRosParser.g:7044:1: ( ( Type_1 ) ) + // InternalRosParser.g:7045:1: ( Type_1 ) { - // InternalRos.g:6898:1: ( '}' ) - // InternalRos.g:6899:2: '}' + // InternalRosParser.g:7045:1: ( Type_1 ) + // InternalRosParser.g:7046:2: Type_1 { - before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_4_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_4_4()); + before(grammarAccess.getActionServerAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getTypeKeyword_4()); } @@ -21359,26 +21358,26 @@ public final void rule__Node__Group_4__4__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4__4__Impl" + // $ANTLR end "rule__ActionServer__Group__4__Impl" - // $ANTLR start "rule__Node__Group_4_3__0" - // InternalRos.g:6909:1: rule__Node__Group_4_3__0 : rule__Node__Group_4_3__0__Impl rule__Node__Group_4_3__1 ; - public final void rule__Node__Group_4_3__0() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group__5" + // InternalRosParser.g:7055:1: rule__ActionServer__Group__5 : rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 ; + public final void rule__ActionServer__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6913:1: ( rule__Node__Group_4_3__0__Impl rule__Node__Group_4_3__1 ) - // InternalRos.g:6914:2: rule__Node__Group_4_3__0__Impl rule__Node__Group_4_3__1 + // InternalRosParser.g:7059:1: ( rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 ) + // InternalRosParser.g:7060:2: rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 { - pushFollow(FOLLOW_31); - rule__Node__Group_4_3__0__Impl(); + pushFollow(FOLLOW_35); + rule__ActionServer__Group__5__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_4_3__1(); + rule__ActionServer__Group__6(); state._fsp--; @@ -21397,25 +21396,35 @@ public final void rule__Node__Group_4_3__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4_3__0" + // $ANTLR end "rule__ActionServer__Group__5" - // $ANTLR start "rule__Node__Group_4_3__0__Impl" - // InternalRos.g:6921:1: rule__Node__Group_4_3__0__Impl : ( ',' ) ; - public final void rule__Node__Group_4_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group__5__Impl" + // InternalRosParser.g:7067:1: rule__ActionServer__Group__5__Impl : ( ( rule__ActionServer__ActionAssignment_5 ) ) ; + public final void rule__ActionServer__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6925:1: ( ( ',' ) ) - // InternalRos.g:6926:1: ( ',' ) + // InternalRosParser.g:7071:1: ( ( ( rule__ActionServer__ActionAssignment_5 ) ) ) + // InternalRosParser.g:7072:1: ( ( rule__ActionServer__ActionAssignment_5 ) ) { - // InternalRos.g:6926:1: ( ',' ) - // InternalRos.g:6927:2: ',' + // InternalRosParser.g:7072:1: ( ( rule__ActionServer__ActionAssignment_5 ) ) + // InternalRosParser.g:7073:2: ( rule__ActionServer__ActionAssignment_5 ) + { + before(grammarAccess.getActionServerAccess().getActionAssignment_5()); + // InternalRosParser.g:7074:2: ( rule__ActionServer__ActionAssignment_5 ) + // InternalRosParser.g:7074:3: rule__ActionServer__ActionAssignment_5 { - before(grammarAccess.getNodeAccess().getCommaKeyword_4_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getNodeAccess().getCommaKeyword_4_3_0()); + pushFollow(FOLLOW_2); + rule__ActionServer__ActionAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getActionServerAccess().getActionAssignment_5()); } @@ -21434,21 +21443,26 @@ public final void rule__Node__Group_4_3__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4_3__0__Impl" + // $ANTLR end "rule__ActionServer__Group__5__Impl" - // $ANTLR start "rule__Node__Group_4_3__1" - // InternalRos.g:6936:1: rule__Node__Group_4_3__1 : rule__Node__Group_4_3__1__Impl ; - public final void rule__Node__Group_4_3__1() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group__6" + // InternalRosParser.g:7082:1: rule__ActionServer__Group__6 : rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 ; + public final void rule__ActionServer__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6940:1: ( rule__Node__Group_4_3__1__Impl ) - // InternalRos.g:6941:2: rule__Node__Group_4_3__1__Impl + // InternalRosParser.g:7086:1: ( rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 ) + // InternalRosParser.g:7087:2: rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 { + pushFollow(FOLLOW_35); + rule__ActionServer__Group__6__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Node__Group_4_3__1__Impl(); + rule__ActionServer__Group__7(); state._fsp--; @@ -21467,35 +21481,46 @@ public final void rule__Node__Group_4_3__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4_3__1" + // $ANTLR end "rule__ActionServer__Group__6" - // $ANTLR start "rule__Node__Group_4_3__1__Impl" - // InternalRos.g:6947:1: rule__Node__Group_4_3__1__Impl : ( ( rule__Node__ServiceserverAssignment_4_3_1 ) ) ; - public final void rule__Node__Group_4_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group__6__Impl" + // InternalRosParser.g:7094:1: rule__ActionServer__Group__6__Impl : ( ( rule__ActionServer__Group_6__0 )? ) ; + public final void rule__ActionServer__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6951:1: ( ( ( rule__Node__ServiceserverAssignment_4_3_1 ) ) ) - // InternalRos.g:6952:1: ( ( rule__Node__ServiceserverAssignment_4_3_1 ) ) - { - // InternalRos.g:6952:1: ( ( rule__Node__ServiceserverAssignment_4_3_1 ) ) - // InternalRos.g:6953:2: ( rule__Node__ServiceserverAssignment_4_3_1 ) + // InternalRosParser.g:7098:1: ( ( ( rule__ActionServer__Group_6__0 )? ) ) + // InternalRosParser.g:7099:1: ( ( rule__ActionServer__Group_6__0 )? ) { - before(grammarAccess.getNodeAccess().getServiceserverAssignment_4_3_1()); - // InternalRos.g:6954:2: ( rule__Node__ServiceserverAssignment_4_3_1 ) - // InternalRos.g:6954:3: rule__Node__ServiceserverAssignment_4_3_1 + // InternalRosParser.g:7099:1: ( ( rule__ActionServer__Group_6__0 )? ) + // InternalRosParser.g:7100:2: ( rule__ActionServer__Group_6__0 )? { - pushFollow(FOLLOW_2); - rule__Node__ServiceserverAssignment_4_3_1(); + before(grammarAccess.getActionServerAccess().getGroup_6()); + // InternalRosParser.g:7101:2: ( rule__ActionServer__Group_6__0 )? + int alt39=2; + int LA39_0 = input.LA(1); - state._fsp--; + if ( (LA39_0==Ns) ) { + alt39=1; + } + switch (alt39) { + case 1 : + // InternalRosParser.g:7101:3: rule__ActionServer__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__ActionServer__Group_6__0(); + + state._fsp--; + } + break; + } - after(grammarAccess.getNodeAccess().getServiceserverAssignment_4_3_1()); + after(grammarAccess.getActionServerAccess().getGroup_6()); } @@ -21514,26 +21539,21 @@ public final void rule__Node__Group_4_3__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_4_3__1__Impl" + // $ANTLR end "rule__ActionServer__Group__6__Impl" - // $ANTLR start "rule__Node__Group_5__0" - // InternalRos.g:6963: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 { + // $ANTLR start "rule__ActionServer__Group__7" + // InternalRosParser.g:7109:1: rule__ActionServer__Group__7 : rule__ActionServer__Group__7__Impl ; + public final void rule__ActionServer__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6967:1: ( rule__Node__Group_5__0__Impl rule__Node__Group_5__1 ) - // InternalRos.g:6968:2: rule__Node__Group_5__0__Impl rule__Node__Group_5__1 + // InternalRosParser.g:7113:1: ( rule__ActionServer__Group__7__Impl ) + // InternalRosParser.g:7114:2: rule__ActionServer__Group__7__Impl { - pushFollow(FOLLOW_4); - rule__Node__Group_5__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Node__Group_5__1(); + rule__ActionServer__Group__7__Impl(); state._fsp--; @@ -21552,25 +21572,25 @@ public final void rule__Node__Group_5__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_5__0" + // $ANTLR end "rule__ActionServer__Group__7" - // $ANTLR start "rule__Node__Group_5__0__Impl" - // InternalRos.g:6975:1: rule__Node__Group_5__0__Impl : ( 'Publishers' ) ; - public final void rule__Node__Group_5__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group__7__Impl" + // InternalRosParser.g:7120:1: rule__ActionServer__Group__7__Impl : ( RULE_END ) ; + public final void rule__ActionServer__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6979:1: ( ( 'Publishers' ) ) - // InternalRos.g:6980:1: ( 'Publishers' ) + // InternalRosParser.g:7124:1: ( ( RULE_END ) ) + // InternalRosParser.g:7125:1: ( RULE_END ) { - // InternalRos.g:6980:1: ( 'Publishers' ) - // InternalRos.g:6981:2: 'Publishers' + // InternalRosParser.g:7125:1: ( RULE_END ) + // InternalRosParser.g:7126:2: RULE_END { - before(grammarAccess.getNodeAccess().getPublishersKeyword_5_0()); - match(input,58,FOLLOW_2); - after(grammarAccess.getNodeAccess().getPublishersKeyword_5_0()); + before(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); } @@ -21589,26 +21609,26 @@ public final void rule__Node__Group_5__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_5__0__Impl" + // $ANTLR end "rule__ActionServer__Group__7__Impl" - // $ANTLR start "rule__Node__Group_5__1" - // InternalRos.g:6990: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 { + // $ANTLR start "rule__ActionServer__Group_6__0" + // InternalRosParser.g:7136:1: rule__ActionServer__Group_6__0 : rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 ; + public final void rule__ActionServer__Group_6__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:6994:1: ( rule__Node__Group_5__1__Impl rule__Node__Group_5__2 ) - // InternalRos.g:6995:2: rule__Node__Group_5__1__Impl rule__Node__Group_5__2 + // InternalRosParser.g:7140:1: ( rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 ) + // InternalRosParser.g:7141:2: rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 { - pushFollow(FOLLOW_32); - rule__Node__Group_5__1__Impl(); + pushFollow(FOLLOW_36); + rule__ActionServer__Group_6__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_5__2(); + rule__ActionServer__Group_6__1(); state._fsp--; @@ -21627,25 +21647,25 @@ public final void rule__Node__Group_5__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_5__1" + // $ANTLR end "rule__ActionServer__Group_6__0" - // $ANTLR start "rule__Node__Group_5__1__Impl" - // InternalRos.g:7002:1: rule__Node__Group_5__1__Impl : ( '{' ) ; - public final void rule__Node__Group_5__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group_6__0__Impl" + // InternalRosParser.g:7148:1: rule__ActionServer__Group_6__0__Impl : ( Ns ) ; + public final void rule__ActionServer__Group_6__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7006:1: ( ( '{' ) ) - // InternalRos.g:7007:1: ( '{' ) + // InternalRosParser.g:7152:1: ( ( Ns ) ) + // InternalRosParser.g:7153:1: ( Ns ) { - // InternalRos.g:7007:1: ( '{' ) - // InternalRos.g:7008:2: '{' + // InternalRosParser.g:7153:1: ( Ns ) + // InternalRosParser.g:7154:2: Ns { - before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_5_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_5_1()); + before(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); } @@ -21664,26 +21684,21 @@ public final void rule__Node__Group_5__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_5__1__Impl" + // $ANTLR end "rule__ActionServer__Group_6__0__Impl" - // $ANTLR start "rule__Node__Group_5__2" - // InternalRos.g:7017: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 { + // $ANTLR start "rule__ActionServer__Group_6__1" + // InternalRosParser.g:7163:1: rule__ActionServer__Group_6__1 : rule__ActionServer__Group_6__1__Impl ; + public final void rule__ActionServer__Group_6__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7021:1: ( rule__Node__Group_5__2__Impl rule__Node__Group_5__3 ) - // InternalRos.g:7022:2: rule__Node__Group_5__2__Impl rule__Node__Group_5__3 + // InternalRosParser.g:7167:1: ( rule__ActionServer__Group_6__1__Impl ) + // InternalRosParser.g:7168:2: rule__ActionServer__Group_6__1__Impl { - pushFollow(FOLLOW_13); - rule__Node__Group_5__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Node__Group_5__3(); + rule__ActionServer__Group_6__1__Impl(); state._fsp--; @@ -21702,35 +21717,35 @@ public final void rule__Node__Group_5__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_5__2" + // $ANTLR end "rule__ActionServer__Group_6__1" - // $ANTLR start "rule__Node__Group_5__2__Impl" - // InternalRos.g:7029:1: rule__Node__Group_5__2__Impl : ( ( rule__Node__PublisherAssignment_5_2 ) ) ; - public final void rule__Node__Group_5__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionServer__Group_6__1__Impl" + // InternalRosParser.g:7174:1: rule__ActionServer__Group_6__1__Impl : ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) ; + public final void rule__ActionServer__Group_6__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7033:1: ( ( ( rule__Node__PublisherAssignment_5_2 ) ) ) - // InternalRos.g:7034:1: ( ( rule__Node__PublisherAssignment_5_2 ) ) + // InternalRosParser.g:7178:1: ( ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) ) + // InternalRosParser.g:7179:1: ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) { - // InternalRos.g:7034:1: ( ( rule__Node__PublisherAssignment_5_2 ) ) - // InternalRos.g:7035:2: ( rule__Node__PublisherAssignment_5_2 ) + // InternalRosParser.g:7179:1: ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) + // InternalRosParser.g:7180:2: ( rule__ActionServer__NamespaceAssignment_6_1 ) { - before(grammarAccess.getNodeAccess().getPublisherAssignment_5_2()); - // InternalRos.g:7036:2: ( rule__Node__PublisherAssignment_5_2 ) - // InternalRos.g:7036:3: rule__Node__PublisherAssignment_5_2 + before(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); + // InternalRosParser.g:7181:2: ( rule__ActionServer__NamespaceAssignment_6_1 ) + // InternalRosParser.g:7181:3: rule__ActionServer__NamespaceAssignment_6_1 { pushFollow(FOLLOW_2); - rule__Node__PublisherAssignment_5_2(); + rule__ActionServer__NamespaceAssignment_6_1(); state._fsp--; } - after(grammarAccess.getNodeAccess().getPublisherAssignment_5_2()); + after(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); } @@ -21749,26 +21764,26 @@ public final void rule__Node__Group_5__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_5__2__Impl" + // $ANTLR end "rule__ActionServer__Group_6__1__Impl" - // $ANTLR start "rule__Node__Group_5__3" - // InternalRos.g:7044:1: rule__Node__Group_5__3 : rule__Node__Group_5__3__Impl rule__Node__Group_5__4 ; - public final void rule__Node__Group_5__3() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__0" + // InternalRosParser.g:7190:1: rule__ActionClient__Group__0 : rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 ; + public final void rule__ActionClient__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7048:1: ( rule__Node__Group_5__3__Impl rule__Node__Group_5__4 ) - // InternalRos.g:7049:2: rule__Node__Group_5__3__Impl rule__Node__Group_5__4 + // InternalRosParser.g:7194:1: ( rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 ) + // InternalRosParser.g:7195:2: rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 { - pushFollow(FOLLOW_13); - rule__Node__Group_5__3__Impl(); + pushFollow(FOLLOW_8); + rule__ActionClient__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_5__4(); + rule__ActionClient__Group__1(); state._fsp--; @@ -21787,123 +21802,29 @@ public final void rule__Node__Group_5__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_5__3" + // $ANTLR end "rule__ActionClient__Group__0" - // $ANTLR start "rule__Node__Group_5__3__Impl" - // InternalRos.g:7056:1: rule__Node__Group_5__3__Impl : ( ( rule__Node__Group_5_3__0 )* ) ; - public final void rule__Node__Group_5__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__0__Impl" + // InternalRosParser.g:7202:1: rule__ActionClient__Group__0__Impl : ( () ) ; + public final void rule__ActionClient__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7060:1: ( ( ( rule__Node__Group_5_3__0 )* ) ) - // InternalRos.g:7061:1: ( ( rule__Node__Group_5_3__0 )* ) + // InternalRosParser.g:7206:1: ( ( () ) ) + // InternalRosParser.g:7207:1: ( () ) { - // InternalRos.g:7061:1: ( ( rule__Node__Group_5_3__0 )* ) - // InternalRos.g:7062:2: ( rule__Node__Group_5_3__0 )* + // InternalRosParser.g:7207:1: ( () ) + // InternalRosParser.g:7208:2: () { - before(grammarAccess.getNodeAccess().getGroup_5_3()); - // InternalRos.g:7063:2: ( rule__Node__Group_5_3__0 )* - loop51: - do { - int alt51=2; - int LA51_0 = input.LA(1); - - if ( (LA51_0==43) ) { - alt51=1; - } - - - switch (alt51) { - case 1 : - // InternalRos.g:7063:3: rule__Node__Group_5_3__0 - { - pushFollow(FOLLOW_7); - rule__Node__Group_5_3__0(); - - state._fsp--; - - - } - break; - - default : - break loop51; - } - } while (true); - - after(grammarAccess.getNodeAccess().getGroup_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__Node__Group_5__4" - // InternalRos.g:7071:1: rule__Node__Group_5__4 : rule__Node__Group_5__4__Impl ; - public final void rule__Node__Group_5__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7075:1: ( rule__Node__Group_5__4__Impl ) - // InternalRos.g:7076:2: rule__Node__Group_5__4__Impl + before(grammarAccess.getActionClientAccess().getActionClientAction_0()); + // InternalRosParser.g:7209:2: () + // InternalRosParser.g:7209:3: { - pushFollow(FOLLOW_2); - rule__Node__Group_5__4__Impl(); - - state._fsp--; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_5__4" - - - // $ANTLR start "rule__Node__Group_5__4__Impl" - // InternalRos.g:7082:1: rule__Node__Group_5__4__Impl : ( '}' ) ; - public final void rule__Node__Group_5__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7086:1: ( ( '}' ) ) - // InternalRos.g:7087:1: ( '}' ) - { - // InternalRos.g:7087:1: ( '}' ) - // InternalRos.g:7088:2: '}' - { - before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_5_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_5_4()); + after(grammarAccess.getActionClientAccess().getActionClientAction_0()); } @@ -21911,10 +21832,6 @@ public final void rule__Node__Group_5__4__Impl() throws RecognitionException { } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -21922,96 +21839,26 @@ public final void rule__Node__Group_5__4__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_5__4__Impl" + // $ANTLR end "rule__ActionClient__Group__0__Impl" - // $ANTLR start "rule__Node__Group_5_3__0" - // InternalRos.g:7098:1: rule__Node__Group_5_3__0 : rule__Node__Group_5_3__0__Impl rule__Node__Group_5_3__1 ; - public final void rule__Node__Group_5_3__0() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__1" + // InternalRosParser.g:7217:1: rule__ActionClient__Group__1 : rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 ; + public final void rule__ActionClient__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7102:1: ( rule__Node__Group_5_3__0__Impl rule__Node__Group_5_3__1 ) - // InternalRos.g:7103:2: rule__Node__Group_5_3__0__Impl rule__Node__Group_5_3__1 + // InternalRosParser.g:7221:1: ( rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 ) + // InternalRosParser.g:7222:2: rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 { - pushFollow(FOLLOW_32); - rule__Node__Group_5_3__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__Node__Group_5_3__1(); + pushFollow(FOLLOW_5); + rule__ActionClient__Group__1__Impl(); state._fsp--; - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_5_3__0" - - - // $ANTLR start "rule__Node__Group_5_3__0__Impl" - // InternalRos.g:7110:1: rule__Node__Group_5_3__0__Impl : ( ',' ) ; - public final void rule__Node__Group_5_3__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7114:1: ( ( ',' ) ) - // InternalRos.g:7115:1: ( ',' ) - { - // InternalRos.g:7115:1: ( ',' ) - // InternalRos.g:7116:2: ',' - { - before(grammarAccess.getNodeAccess().getCommaKeyword_5_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getNodeAccess().getCommaKeyword_5_3_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_5_3__0__Impl" - - - // $ANTLR start "rule__Node__Group_5_3__1" - // InternalRos.g:7125:1: rule__Node__Group_5_3__1 : rule__Node__Group_5_3__1__Impl ; - public final void rule__Node__Group_5_3__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7129:1: ( rule__Node__Group_5_3__1__Impl ) - // InternalRos.g:7130:2: rule__Node__Group_5_3__1__Impl - { pushFollow(FOLLOW_2); - rule__Node__Group_5_3__1__Impl(); + rule__ActionClient__Group__2(); state._fsp--; @@ -22030,35 +21877,35 @@ public final void rule__Node__Group_5_3__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_5_3__1" + // $ANTLR end "rule__ActionClient__Group__1" - // $ANTLR start "rule__Node__Group_5_3__1__Impl" - // InternalRos.g:7136:1: rule__Node__Group_5_3__1__Impl : ( ( rule__Node__PublisherAssignment_5_3_1 ) ) ; - public final void rule__Node__Group_5_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__1__Impl" + // InternalRosParser.g:7229:1: rule__ActionClient__Group__1__Impl : ( ( rule__ActionClient__NameAssignment_1 ) ) ; + public final void rule__ActionClient__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7140:1: ( ( ( rule__Node__PublisherAssignment_5_3_1 ) ) ) - // InternalRos.g:7141:1: ( ( rule__Node__PublisherAssignment_5_3_1 ) ) + // InternalRosParser.g:7233:1: ( ( ( rule__ActionClient__NameAssignment_1 ) ) ) + // InternalRosParser.g:7234:1: ( ( rule__ActionClient__NameAssignment_1 ) ) { - // InternalRos.g:7141:1: ( ( rule__Node__PublisherAssignment_5_3_1 ) ) - // InternalRos.g:7142:2: ( rule__Node__PublisherAssignment_5_3_1 ) + // InternalRosParser.g:7234:1: ( ( rule__ActionClient__NameAssignment_1 ) ) + // InternalRosParser.g:7235:2: ( rule__ActionClient__NameAssignment_1 ) { - before(grammarAccess.getNodeAccess().getPublisherAssignment_5_3_1()); - // InternalRos.g:7143:2: ( rule__Node__PublisherAssignment_5_3_1 ) - // InternalRos.g:7143:3: rule__Node__PublisherAssignment_5_3_1 + before(grammarAccess.getActionClientAccess().getNameAssignment_1()); + // InternalRosParser.g:7236:2: ( rule__ActionClient__NameAssignment_1 ) + // InternalRosParser.g:7236:3: rule__ActionClient__NameAssignment_1 { pushFollow(FOLLOW_2); - rule__Node__PublisherAssignment_5_3_1(); + rule__ActionClient__NameAssignment_1(); state._fsp--; } - after(grammarAccess.getNodeAccess().getPublisherAssignment_5_3_1()); + after(grammarAccess.getActionClientAccess().getNameAssignment_1()); } @@ -22077,26 +21924,26 @@ public final void rule__Node__Group_5_3__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_5_3__1__Impl" + // $ANTLR end "rule__ActionClient__Group__1__Impl" - // $ANTLR start "rule__Node__Group_6__0" - // InternalRos.g:7152:1: rule__Node__Group_6__0 : rule__Node__Group_6__0__Impl rule__Node__Group_6__1 ; - public final void rule__Node__Group_6__0() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__2" + // InternalRosParser.g:7244:1: rule__ActionClient__Group__2 : rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 ; + public final void rule__ActionClient__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7156:1: ( rule__Node__Group_6__0__Impl rule__Node__Group_6__1 ) - // InternalRos.g:7157:2: rule__Node__Group_6__0__Impl rule__Node__Group_6__1 + // InternalRosParser.g:7248:1: ( rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 ) + // InternalRosParser.g:7249:2: rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 { - pushFollow(FOLLOW_4); - rule__Node__Group_6__0__Impl(); + pushFollow(FOLLOW_6); + rule__ActionClient__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_6__1(); + rule__ActionClient__Group__3(); state._fsp--; @@ -22115,25 +21962,25 @@ public final void rule__Node__Group_6__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6__0" + // $ANTLR end "rule__ActionClient__Group__2" - // $ANTLR start "rule__Node__Group_6__0__Impl" - // InternalRos.g:7164:1: rule__Node__Group_6__0__Impl : ( 'Subscribers' ) ; - public final void rule__Node__Group_6__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__2__Impl" + // InternalRosParser.g:7256:1: rule__ActionClient__Group__2__Impl : ( Colon ) ; + public final void rule__ActionClient__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7168:1: ( ( 'Subscribers' ) ) - // InternalRos.g:7169:1: ( 'Subscribers' ) + // InternalRosParser.g:7260:1: ( ( Colon ) ) + // InternalRosParser.g:7261:1: ( Colon ) { - // InternalRos.g:7169:1: ( 'Subscribers' ) - // InternalRos.g:7170:2: 'Subscribers' + // InternalRosParser.g:7261:1: ( Colon ) + // InternalRosParser.g:7262:2: Colon { - before(grammarAccess.getNodeAccess().getSubscribersKeyword_6_0()); - match(input,59,FOLLOW_2); - after(grammarAccess.getNodeAccess().getSubscribersKeyword_6_0()); + before(grammarAccess.getActionClientAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getColonKeyword_2()); } @@ -22152,26 +21999,26 @@ public final void rule__Node__Group_6__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6__0__Impl" + // $ANTLR end "rule__ActionClient__Group__2__Impl" - // $ANTLR start "rule__Node__Group_6__1" - // InternalRos.g:7179:1: rule__Node__Group_6__1 : rule__Node__Group_6__1__Impl rule__Node__Group_6__2 ; - public final void rule__Node__Group_6__1() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__3" + // InternalRosParser.g:7271:1: rule__ActionClient__Group__3 : rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 ; + public final void rule__ActionClient__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7183:1: ( rule__Node__Group_6__1__Impl rule__Node__Group_6__2 ) - // InternalRos.g:7184:2: rule__Node__Group_6__1__Impl rule__Node__Group_6__2 + // InternalRosParser.g:7275:1: ( rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 ) + // InternalRosParser.g:7276:2: rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 { - pushFollow(FOLLOW_33); - rule__Node__Group_6__1__Impl(); + pushFollow(FOLLOW_34); + rule__ActionClient__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_6__2(); + rule__ActionClient__Group__4(); state._fsp--; @@ -22190,25 +22037,25 @@ public final void rule__Node__Group_6__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6__1" + // $ANTLR end "rule__ActionClient__Group__3" - // $ANTLR start "rule__Node__Group_6__1__Impl" - // InternalRos.g:7191:1: rule__Node__Group_6__1__Impl : ( '{' ) ; - public final void rule__Node__Group_6__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__3__Impl" + // InternalRosParser.g:7283:1: rule__ActionClient__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionClient__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7195:1: ( ( '{' ) ) - // InternalRos.g:7196:1: ( '{' ) + // InternalRosParser.g:7287:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:7288:1: ( RULE_BEGIN ) { - // InternalRos.g:7196:1: ( '{' ) - // InternalRos.g:7197:2: '{' + // InternalRosParser.g:7288:1: ( RULE_BEGIN ) + // InternalRosParser.g:7289:2: RULE_BEGIN { - before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_6_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_6_1()); + before(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); } @@ -22227,26 +22074,26 @@ public final void rule__Node__Group_6__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6__1__Impl" + // $ANTLR end "rule__ActionClient__Group__3__Impl" - // $ANTLR start "rule__Node__Group_6__2" - // InternalRos.g:7206:1: rule__Node__Group_6__2 : rule__Node__Group_6__2__Impl rule__Node__Group_6__3 ; - public final void rule__Node__Group_6__2() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__4" + // InternalRosParser.g:7298:1: rule__ActionClient__Group__4 : rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 ; + public final void rule__ActionClient__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7210:1: ( rule__Node__Group_6__2__Impl rule__Node__Group_6__3 ) - // InternalRos.g:7211:2: rule__Node__Group_6__2__Impl rule__Node__Group_6__3 + // InternalRosParser.g:7302:1: ( rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 ) + // InternalRosParser.g:7303:2: rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 { - pushFollow(FOLLOW_13); - rule__Node__Group_6__2__Impl(); + pushFollow(FOLLOW_8); + rule__ActionClient__Group__4__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_6__3(); + rule__ActionClient__Group__5(); state._fsp--; @@ -22265,35 +22112,25 @@ public final void rule__Node__Group_6__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6__2" + // $ANTLR end "rule__ActionClient__Group__4" - // $ANTLR start "rule__Node__Group_6__2__Impl" - // InternalRos.g:7218:1: rule__Node__Group_6__2__Impl : ( ( rule__Node__SubscriberAssignment_6_2 ) ) ; - public final void rule__Node__Group_6__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__4__Impl" + // InternalRosParser.g:7310:1: rule__ActionClient__Group__4__Impl : ( Type_1 ) ; + public final void rule__ActionClient__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7222:1: ( ( ( rule__Node__SubscriberAssignment_6_2 ) ) ) - // InternalRos.g:7223:1: ( ( rule__Node__SubscriberAssignment_6_2 ) ) - { - // InternalRos.g:7223:1: ( ( rule__Node__SubscriberAssignment_6_2 ) ) - // InternalRos.g:7224:2: ( rule__Node__SubscriberAssignment_6_2 ) + // InternalRosParser.g:7314:1: ( ( Type_1 ) ) + // InternalRosParser.g:7315:1: ( Type_1 ) { - before(grammarAccess.getNodeAccess().getSubscriberAssignment_6_2()); - // InternalRos.g:7225:2: ( rule__Node__SubscriberAssignment_6_2 ) - // InternalRos.g:7225:3: rule__Node__SubscriberAssignment_6_2 + // InternalRosParser.g:7315:1: ( Type_1 ) + // InternalRosParser.g:7316:2: Type_1 { - pushFollow(FOLLOW_2); - rule__Node__SubscriberAssignment_6_2(); - - state._fsp--; - - - } - - after(grammarAccess.getNodeAccess().getSubscriberAssignment_6_2()); + before(grammarAccess.getActionClientAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getTypeKeyword_4()); } @@ -22312,26 +22149,26 @@ public final void rule__Node__Group_6__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6__2__Impl" + // $ANTLR end "rule__ActionClient__Group__4__Impl" - // $ANTLR start "rule__Node__Group_6__3" - // InternalRos.g:7233:1: rule__Node__Group_6__3 : rule__Node__Group_6__3__Impl rule__Node__Group_6__4 ; - public final void rule__Node__Group_6__3() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__5" + // InternalRosParser.g:7325:1: rule__ActionClient__Group__5 : rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 ; + public final void rule__ActionClient__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7237:1: ( rule__Node__Group_6__3__Impl rule__Node__Group_6__4 ) - // InternalRos.g:7238:2: rule__Node__Group_6__3__Impl rule__Node__Group_6__4 + // InternalRosParser.g:7329:1: ( rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 ) + // InternalRosParser.g:7330:2: rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 { - pushFollow(FOLLOW_13); - rule__Node__Group_6__3__Impl(); + pushFollow(FOLLOW_35); + rule__ActionClient__Group__5__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_6__4(); + rule__ActionClient__Group__6(); state._fsp--; @@ -22350,53 +22187,35 @@ public final void rule__Node__Group_6__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6__3" + // $ANTLR end "rule__ActionClient__Group__5" - // $ANTLR start "rule__Node__Group_6__3__Impl" - // InternalRos.g:7245:1: rule__Node__Group_6__3__Impl : ( ( rule__Node__Group_6_3__0 )* ) ; - public final void rule__Node__Group_6__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__5__Impl" + // InternalRosParser.g:7337:1: rule__ActionClient__Group__5__Impl : ( ( rule__ActionClient__ActionAssignment_5 ) ) ; + public final void rule__ActionClient__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7249:1: ( ( ( rule__Node__Group_6_3__0 )* ) ) - // InternalRos.g:7250:1: ( ( rule__Node__Group_6_3__0 )* ) + // InternalRosParser.g:7341:1: ( ( ( rule__ActionClient__ActionAssignment_5 ) ) ) + // InternalRosParser.g:7342:1: ( ( rule__ActionClient__ActionAssignment_5 ) ) { - // InternalRos.g:7250:1: ( ( rule__Node__Group_6_3__0 )* ) - // InternalRos.g:7251:2: ( rule__Node__Group_6_3__0 )* + // InternalRosParser.g:7342:1: ( ( rule__ActionClient__ActionAssignment_5 ) ) + // InternalRosParser.g:7343:2: ( rule__ActionClient__ActionAssignment_5 ) { - before(grammarAccess.getNodeAccess().getGroup_6_3()); - // InternalRos.g:7252:2: ( rule__Node__Group_6_3__0 )* - loop52: - do { - int alt52=2; - int LA52_0 = input.LA(1); - - if ( (LA52_0==43) ) { - alt52=1; - } - - - switch (alt52) { - case 1 : - // InternalRos.g:7252:3: rule__Node__Group_6_3__0 - { - pushFollow(FOLLOW_7); - rule__Node__Group_6_3__0(); - - state._fsp--; + before(grammarAccess.getActionClientAccess().getActionAssignment_5()); + // InternalRosParser.g:7344:2: ( rule__ActionClient__ActionAssignment_5 ) + // InternalRosParser.g:7344:3: rule__ActionClient__ActionAssignment_5 + { + pushFollow(FOLLOW_2); + rule__ActionClient__ActionAssignment_5(); + state._fsp--; - } - break; - default : - break loop52; - } - } while (true); + } - after(grammarAccess.getNodeAccess().getGroup_6_3()); + after(grammarAccess.getActionClientAccess().getActionAssignment_5()); } @@ -22415,21 +22234,26 @@ public final void rule__Node__Group_6__3__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6__3__Impl" + // $ANTLR end "rule__ActionClient__Group__5__Impl" - // $ANTLR start "rule__Node__Group_6__4" - // InternalRos.g:7260:1: rule__Node__Group_6__4 : rule__Node__Group_6__4__Impl ; - public final void rule__Node__Group_6__4() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__6" + // InternalRosParser.g:7352:1: rule__ActionClient__Group__6 : rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 ; + public final void rule__ActionClient__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7264:1: ( rule__Node__Group_6__4__Impl ) - // InternalRos.g:7265:2: rule__Node__Group_6__4__Impl + // InternalRosParser.g:7356:1: ( rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 ) + // InternalRosParser.g:7357:2: rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 { + pushFollow(FOLLOW_35); + rule__ActionClient__Group__6__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Node__Group_6__4__Impl(); + rule__ActionClient__Group__7(); state._fsp--; @@ -22448,100 +22272,46 @@ public final void rule__Node__Group_6__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6__4" + // $ANTLR end "rule__ActionClient__Group__6" - // $ANTLR start "rule__Node__Group_6__4__Impl" - // InternalRos.g:7271:1: rule__Node__Group_6__4__Impl : ( '}' ) ; - public final void rule__Node__Group_6__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__6__Impl" + // InternalRosParser.g:7364:1: rule__ActionClient__Group__6__Impl : ( ( rule__ActionClient__Group_6__0 )? ) ; + public final void rule__ActionClient__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7275:1: ( ( '}' ) ) - // InternalRos.g:7276:1: ( '}' ) + // InternalRosParser.g:7368:1: ( ( ( rule__ActionClient__Group_6__0 )? ) ) + // InternalRosParser.g:7369:1: ( ( rule__ActionClient__Group_6__0 )? ) { - // InternalRos.g:7276:1: ( '}' ) - // InternalRos.g:7277:2: '}' + // InternalRosParser.g:7369:1: ( ( rule__ActionClient__Group_6__0 )? ) + // InternalRosParser.g:7370:2: ( rule__ActionClient__Group_6__0 )? { - before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_6_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_6_4()); - - } - + before(grammarAccess.getActionClientAccess().getGroup_6()); + // InternalRosParser.g:7371:2: ( rule__ActionClient__Group_6__0 )? + int alt40=2; + int LA40_0 = input.LA(1); + if ( (LA40_0==Ns) ) { + alt40=1; } + switch (alt40) { + case 1 : + // InternalRosParser.g:7371:3: rule__ActionClient__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__ActionClient__Group_6__0(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_6__4__Impl" - - - // $ANTLR start "rule__Node__Group_6_3__0" - // InternalRos.g:7287:1: rule__Node__Group_6_3__0 : rule__Node__Group_6_3__0__Impl rule__Node__Group_6_3__1 ; - public final void rule__Node__Group_6_3__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7291:1: ( rule__Node__Group_6_3__0__Impl rule__Node__Group_6_3__1 ) - // InternalRos.g:7292:2: rule__Node__Group_6_3__0__Impl rule__Node__Group_6_3__1 - { - pushFollow(FOLLOW_33); - rule__Node__Group_6_3__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__Node__Group_6_3__1(); + state._fsp--; - state._fsp--; + } + break; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_6_3__0" - - - // $ANTLR start "rule__Node__Group_6_3__0__Impl" - // InternalRos.g:7299:1: rule__Node__Group_6_3__0__Impl : ( ',' ) ; - public final void rule__Node__Group_6_3__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7303:1: ( ( ',' ) ) - // InternalRos.g:7304:1: ( ',' ) - { - // InternalRos.g:7304:1: ( ',' ) - // InternalRos.g:7305:2: ',' - { - before(grammarAccess.getNodeAccess().getCommaKeyword_6_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getNodeAccess().getCommaKeyword_6_3_0()); + after(grammarAccess.getActionClientAccess().getGroup_6()); } @@ -22560,21 +22330,21 @@ public final void rule__Node__Group_6_3__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6_3__0__Impl" + // $ANTLR end "rule__ActionClient__Group__6__Impl" - // $ANTLR start "rule__Node__Group_6_3__1" - // InternalRos.g:7314:1: rule__Node__Group_6_3__1 : rule__Node__Group_6_3__1__Impl ; - public final void rule__Node__Group_6_3__1() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__7" + // InternalRosParser.g:7379:1: rule__ActionClient__Group__7 : rule__ActionClient__Group__7__Impl ; + public final void rule__ActionClient__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7318:1: ( rule__Node__Group_6_3__1__Impl ) - // InternalRos.g:7319:2: rule__Node__Group_6_3__1__Impl + // InternalRosParser.g:7383:1: ( rule__ActionClient__Group__7__Impl ) + // InternalRosParser.g:7384:2: rule__ActionClient__Group__7__Impl { pushFollow(FOLLOW_2); - rule__Node__Group_6_3__1__Impl(); + rule__ActionClient__Group__7__Impl(); state._fsp--; @@ -22593,35 +22363,25 @@ public final void rule__Node__Group_6_3__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6_3__1" + // $ANTLR end "rule__ActionClient__Group__7" - // $ANTLR start "rule__Node__Group_6_3__1__Impl" - // InternalRos.g:7325:1: rule__Node__Group_6_3__1__Impl : ( ( rule__Node__SubscriberAssignment_6_3_1 ) ) ; - public final void rule__Node__Group_6_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group__7__Impl" + // InternalRosParser.g:7390:1: rule__ActionClient__Group__7__Impl : ( RULE_END ) ; + public final void rule__ActionClient__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7329:1: ( ( ( rule__Node__SubscriberAssignment_6_3_1 ) ) ) - // InternalRos.g:7330:1: ( ( rule__Node__SubscriberAssignment_6_3_1 ) ) + // InternalRosParser.g:7394:1: ( ( RULE_END ) ) + // InternalRosParser.g:7395:1: ( RULE_END ) { - // InternalRos.g:7330:1: ( ( rule__Node__SubscriberAssignment_6_3_1 ) ) - // InternalRos.g:7331:2: ( rule__Node__SubscriberAssignment_6_3_1 ) + // InternalRosParser.g:7395:1: ( RULE_END ) + // InternalRosParser.g:7396:2: RULE_END { - before(grammarAccess.getNodeAccess().getSubscriberAssignment_6_3_1()); - // InternalRos.g:7332:2: ( rule__Node__SubscriberAssignment_6_3_1 ) - // InternalRos.g:7332:3: rule__Node__SubscriberAssignment_6_3_1 - { - pushFollow(FOLLOW_2); - rule__Node__SubscriberAssignment_6_3_1(); - - state._fsp--; - - - } - - after(grammarAccess.getNodeAccess().getSubscriberAssignment_6_3_1()); + before(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); } @@ -22640,26 +22400,26 @@ public final void rule__Node__Group_6_3__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_6_3__1__Impl" + // $ANTLR end "rule__ActionClient__Group__7__Impl" - // $ANTLR start "rule__Node__Group_7__0" - // InternalRos.g:7341:1: rule__Node__Group_7__0 : rule__Node__Group_7__0__Impl rule__Node__Group_7__1 ; - public final void rule__Node__Group_7__0() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group_6__0" + // InternalRosParser.g:7406:1: rule__ActionClient__Group_6__0 : rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 ; + public final void rule__ActionClient__Group_6__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7345:1: ( rule__Node__Group_7__0__Impl rule__Node__Group_7__1 ) - // InternalRos.g:7346:2: rule__Node__Group_7__0__Impl rule__Node__Group_7__1 + // InternalRosParser.g:7410:1: ( rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 ) + // InternalRosParser.g:7411:2: rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 { - pushFollow(FOLLOW_4); - rule__Node__Group_7__0__Impl(); + pushFollow(FOLLOW_36); + rule__ActionClient__Group_6__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_7__1(); + rule__ActionClient__Group_6__1(); state._fsp--; @@ -22678,25 +22438,25 @@ public final void rule__Node__Group_7__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_7__0" + // $ANTLR end "rule__ActionClient__Group_6__0" - // $ANTLR start "rule__Node__Group_7__0__Impl" - // InternalRos.g:7353:1: rule__Node__Group_7__0__Impl : ( 'ServiceClients' ) ; - public final void rule__Node__Group_7__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group_6__0__Impl" + // InternalRosParser.g:7418:1: rule__ActionClient__Group_6__0__Impl : ( Ns ) ; + public final void rule__ActionClient__Group_6__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7357:1: ( ( 'ServiceClients' ) ) - // InternalRos.g:7358:1: ( 'ServiceClients' ) + // InternalRosParser.g:7422:1: ( ( Ns ) ) + // InternalRosParser.g:7423:1: ( Ns ) { - // InternalRos.g:7358:1: ( 'ServiceClients' ) - // InternalRos.g:7359:2: 'ServiceClients' + // InternalRosParser.g:7423:1: ( Ns ) + // InternalRosParser.g:7424:2: Ns { - before(grammarAccess.getNodeAccess().getServiceClientsKeyword_7_0()); - match(input,60,FOLLOW_2); - after(grammarAccess.getNodeAccess().getServiceClientsKeyword_7_0()); + before(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); } @@ -22715,101 +22475,21 @@ public final void rule__Node__Group_7__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_7__0__Impl" - - - // $ANTLR start "rule__Node__Group_7__1" - // InternalRos.g:7368:1: rule__Node__Group_7__1 : rule__Node__Group_7__1__Impl rule__Node__Group_7__2 ; - public final void rule__Node__Group_7__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7372:1: ( rule__Node__Group_7__1__Impl rule__Node__Group_7__2 ) - // InternalRos.g:7373:2: rule__Node__Group_7__1__Impl rule__Node__Group_7__2 - { - pushFollow(FOLLOW_34); - rule__Node__Group_7__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__Node__Group_7__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_7__1" - - - // $ANTLR start "rule__Node__Group_7__1__Impl" - // InternalRos.g:7380:1: rule__Node__Group_7__1__Impl : ( '{' ) ; - public final void rule__Node__Group_7__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7384:1: ( ( '{' ) ) - // InternalRos.g:7385:1: ( '{' ) - { - // InternalRos.g:7385:1: ( '{' ) - // InternalRos.g:7386:2: '{' - { - before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_7_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_7_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_7__1__Impl" + // $ANTLR end "rule__ActionClient__Group_6__0__Impl" - // $ANTLR start "rule__Node__Group_7__2" - // InternalRos.g:7395:1: rule__Node__Group_7__2 : rule__Node__Group_7__2__Impl rule__Node__Group_7__3 ; - public final void rule__Node__Group_7__2() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group_6__1" + // InternalRosParser.g:7433:1: rule__ActionClient__Group_6__1 : rule__ActionClient__Group_6__1__Impl ; + public final void rule__ActionClient__Group_6__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7399:1: ( rule__Node__Group_7__2__Impl rule__Node__Group_7__3 ) - // InternalRos.g:7400:2: rule__Node__Group_7__2__Impl rule__Node__Group_7__3 + // InternalRosParser.g:7437:1: ( rule__ActionClient__Group_6__1__Impl ) + // InternalRosParser.g:7438:2: rule__ActionClient__Group_6__1__Impl { - pushFollow(FOLLOW_13); - rule__Node__Group_7__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Node__Group_7__3(); + rule__ActionClient__Group_6__1__Impl(); state._fsp--; @@ -22828,35 +22508,35 @@ public final void rule__Node__Group_7__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_7__2" + // $ANTLR end "rule__ActionClient__Group_6__1" - // $ANTLR start "rule__Node__Group_7__2__Impl" - // InternalRos.g:7407:1: rule__Node__Group_7__2__Impl : ( ( rule__Node__ServiceclientAssignment_7_2 ) ) ; - public final void rule__Node__Group_7__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ActionClient__Group_6__1__Impl" + // InternalRosParser.g:7444:1: rule__ActionClient__Group_6__1__Impl : ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) ; + public final void rule__ActionClient__Group_6__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7411:1: ( ( ( rule__Node__ServiceclientAssignment_7_2 ) ) ) - // InternalRos.g:7412:1: ( ( rule__Node__ServiceclientAssignment_7_2 ) ) + // InternalRosParser.g:7448:1: ( ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) ) + // InternalRosParser.g:7449:1: ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) { - // InternalRos.g:7412:1: ( ( rule__Node__ServiceclientAssignment_7_2 ) ) - // InternalRos.g:7413:2: ( rule__Node__ServiceclientAssignment_7_2 ) + // InternalRosParser.g:7449:1: ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) + // InternalRosParser.g:7450:2: ( rule__ActionClient__NamespaceAssignment_6_1 ) { - before(grammarAccess.getNodeAccess().getServiceclientAssignment_7_2()); - // InternalRos.g:7414:2: ( rule__Node__ServiceclientAssignment_7_2 ) - // InternalRos.g:7414:3: rule__Node__ServiceclientAssignment_7_2 + before(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); + // InternalRosParser.g:7451:2: ( rule__ActionClient__NamespaceAssignment_6_1 ) + // InternalRosParser.g:7451:3: rule__ActionClient__NamespaceAssignment_6_1 { pushFollow(FOLLOW_2); - rule__Node__ServiceclientAssignment_7_2(); + rule__ActionClient__NamespaceAssignment_6_1(); state._fsp--; } - after(grammarAccess.getNodeAccess().getServiceclientAssignment_7_2()); + after(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); } @@ -22875,26 +22555,26 @@ public final void rule__Node__Group_7__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_7__2__Impl" + // $ANTLR end "rule__ActionClient__Group_6__1__Impl" - // $ANTLR start "rule__Node__Group_7__3" - // InternalRos.g:7422:1: rule__Node__Group_7__3 : rule__Node__Group_7__3__Impl rule__Node__Group_7__4 ; - public final void rule__Node__Group_7__3() throws RecognitionException { + // $ANTLR start "rule__ExternalDependency__Group__0" + // InternalRosParser.g:7460: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 { - // InternalRos.g:7426:1: ( rule__Node__Group_7__3__Impl rule__Node__Group_7__4 ) - // InternalRos.g:7427:2: rule__Node__Group_7__3__Impl rule__Node__Group_7__4 + // InternalRosParser.g:7464:1: ( rule__ExternalDependency__Group__0__Impl rule__ExternalDependency__Group__1 ) + // InternalRosParser.g:7465:2: rule__ExternalDependency__Group__0__Impl rule__ExternalDependency__Group__1 { - pushFollow(FOLLOW_13); - rule__Node__Group_7__3__Impl(); + pushFollow(FOLLOW_12); + rule__ExternalDependency__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_7__4(); + rule__ExternalDependency__Group__1(); state._fsp--; @@ -22913,123 +22593,29 @@ public final void rule__Node__Group_7__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_7__3" + // $ANTLR end "rule__ExternalDependency__Group__0" - // $ANTLR start "rule__Node__Group_7__3__Impl" - // InternalRos.g:7434:1: rule__Node__Group_7__3__Impl : ( ( rule__Node__Group_7_3__0 )* ) ; - public final void rule__Node__Group_7__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ExternalDependency__Group__0__Impl" + // InternalRosParser.g:7472:1: rule__ExternalDependency__Group__0__Impl : ( () ) ; + public final void rule__ExternalDependency__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7438:1: ( ( ( rule__Node__Group_7_3__0 )* ) ) - // InternalRos.g:7439:1: ( ( rule__Node__Group_7_3__0 )* ) + // InternalRosParser.g:7476:1: ( ( () ) ) + // InternalRosParser.g:7477:1: ( () ) { - // InternalRos.g:7439:1: ( ( rule__Node__Group_7_3__0 )* ) - // InternalRos.g:7440:2: ( rule__Node__Group_7_3__0 )* + // InternalRosParser.g:7477:1: ( () ) + // InternalRosParser.g:7478:2: () { - before(grammarAccess.getNodeAccess().getGroup_7_3()); - // InternalRos.g:7441:2: ( rule__Node__Group_7_3__0 )* - loop53: - do { - int alt53=2; - int LA53_0 = input.LA(1); - - if ( (LA53_0==43) ) { - alt53=1; - } - - - switch (alt53) { - case 1 : - // InternalRos.g:7441:3: rule__Node__Group_7_3__0 - { - pushFollow(FOLLOW_7); - rule__Node__Group_7_3__0(); - - state._fsp--; - - - } - break; - - default : - break loop53; - } - } while (true); - - after(grammarAccess.getNodeAccess().getGroup_7_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_7__3__Impl" - - - // $ANTLR start "rule__Node__Group_7__4" - // InternalRos.g:7449:1: rule__Node__Group_7__4 : rule__Node__Group_7__4__Impl ; - public final void rule__Node__Group_7__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7453:1: ( rule__Node__Group_7__4__Impl ) - // InternalRos.g:7454:2: rule__Node__Group_7__4__Impl + before(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); + // InternalRosParser.g:7479:2: () + // InternalRosParser.g:7479:3: { - pushFollow(FOLLOW_2); - rule__Node__Group_7__4__Impl(); - - state._fsp--; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_7__4" - - - // $ANTLR start "rule__Node__Group_7__4__Impl" - // InternalRos.g:7460:1: rule__Node__Group_7__4__Impl : ( '}' ) ; - public final void rule__Node__Group_7__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7464:1: ( ( '}' ) ) - // InternalRos.g:7465:1: ( '}' ) - { - // InternalRos.g:7465:1: ( '}' ) - // InternalRos.g:7466:2: '}' - { - before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_7_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_7_4()); + after(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); } @@ -23037,10 +22623,6 @@ public final void rule__Node__Group_7__4__Impl() throws RecognitionException { } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -23048,26 +22630,26 @@ public final void rule__Node__Group_7__4__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_7__4__Impl" + // $ANTLR end "rule__ExternalDependency__Group__0__Impl" - // $ANTLR start "rule__Node__Group_7_3__0" - // InternalRos.g:7476:1: rule__Node__Group_7_3__0 : rule__Node__Group_7_3__0__Impl rule__Node__Group_7_3__1 ; - public final void rule__Node__Group_7_3__0() throws RecognitionException { + // $ANTLR start "rule__ExternalDependency__Group__1" + // InternalRosParser.g:7487: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 { - // InternalRos.g:7480:1: ( rule__Node__Group_7_3__0__Impl rule__Node__Group_7_3__1 ) - // InternalRos.g:7481:2: rule__Node__Group_7_3__0__Impl rule__Node__Group_7_3__1 + // InternalRosParser.g:7491:1: ( rule__ExternalDependency__Group__1__Impl rule__ExternalDependency__Group__2 ) + // InternalRosParser.g:7492:2: rule__ExternalDependency__Group__1__Impl rule__ExternalDependency__Group__2 { - pushFollow(FOLLOW_34); - rule__Node__Group_7_3__0__Impl(); + pushFollow(FOLLOW_8); + rule__ExternalDependency__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_7_3__1(); + rule__ExternalDependency__Group__2(); state._fsp--; @@ -23086,25 +22668,25 @@ public final void rule__Node__Group_7_3__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_7_3__0" + // $ANTLR end "rule__ExternalDependency__Group__1" - // $ANTLR start "rule__Node__Group_7_3__0__Impl" - // InternalRos.g:7488:1: rule__Node__Group_7_3__0__Impl : ( ',' ) ; - public final void rule__Node__Group_7_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ExternalDependency__Group__1__Impl" + // InternalRosParser.g:7499:1: rule__ExternalDependency__Group__1__Impl : ( ExternalDependency ) ; + public final void rule__ExternalDependency__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7492:1: ( ( ',' ) ) - // InternalRos.g:7493:1: ( ',' ) + // InternalRosParser.g:7503:1: ( ( ExternalDependency ) ) + // InternalRosParser.g:7504:1: ( ExternalDependency ) { - // InternalRos.g:7493:1: ( ',' ) - // InternalRos.g:7494:2: ',' + // InternalRosParser.g:7504:1: ( ExternalDependency ) + // InternalRosParser.g:7505:2: ExternalDependency { - before(grammarAccess.getNodeAccess().getCommaKeyword_7_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getNodeAccess().getCommaKeyword_7_3_0()); + before(grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); + match(input,ExternalDependency,FOLLOW_2); + after(grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); } @@ -23123,21 +22705,21 @@ public final void rule__Node__Group_7_3__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_7_3__0__Impl" + // $ANTLR end "rule__ExternalDependency__Group__1__Impl" - // $ANTLR start "rule__Node__Group_7_3__1" - // InternalRos.g:7503:1: rule__Node__Group_7_3__1 : rule__Node__Group_7_3__1__Impl ; - public final void rule__Node__Group_7_3__1() throws RecognitionException { + // $ANTLR start "rule__ExternalDependency__Group__2" + // InternalRosParser.g:7514:1: rule__ExternalDependency__Group__2 : rule__ExternalDependency__Group__2__Impl ; + public final void rule__ExternalDependency__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7507:1: ( rule__Node__Group_7_3__1__Impl ) - // InternalRos.g:7508:2: rule__Node__Group_7_3__1__Impl + // InternalRosParser.g:7518:1: ( rule__ExternalDependency__Group__2__Impl ) + // InternalRosParser.g:7519:2: rule__ExternalDependency__Group__2__Impl { pushFollow(FOLLOW_2); - rule__Node__Group_7_3__1__Impl(); + rule__ExternalDependency__Group__2__Impl(); state._fsp--; @@ -23156,35 +22738,35 @@ public final void rule__Node__Group_7_3__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_7_3__1" + // $ANTLR end "rule__ExternalDependency__Group__2" - // $ANTLR start "rule__Node__Group_7_3__1__Impl" - // InternalRos.g:7514:1: rule__Node__Group_7_3__1__Impl : ( ( rule__Node__ServiceclientAssignment_7_3_1 ) ) ; - public final void rule__Node__Group_7_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ExternalDependency__Group__2__Impl" + // InternalRosParser.g:7525:1: rule__ExternalDependency__Group__2__Impl : ( ( rule__ExternalDependency__NameAssignment_2 ) ) ; + public final void rule__ExternalDependency__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7518:1: ( ( ( rule__Node__ServiceclientAssignment_7_3_1 ) ) ) - // InternalRos.g:7519:1: ( ( rule__Node__ServiceclientAssignment_7_3_1 ) ) + // InternalRosParser.g:7529:1: ( ( ( rule__ExternalDependency__NameAssignment_2 ) ) ) + // InternalRosParser.g:7530:1: ( ( rule__ExternalDependency__NameAssignment_2 ) ) { - // InternalRos.g:7519:1: ( ( rule__Node__ServiceclientAssignment_7_3_1 ) ) - // InternalRos.g:7520:2: ( rule__Node__ServiceclientAssignment_7_3_1 ) + // InternalRosParser.g:7530:1: ( ( rule__ExternalDependency__NameAssignment_2 ) ) + // InternalRosParser.g:7531:2: ( rule__ExternalDependency__NameAssignment_2 ) { - before(grammarAccess.getNodeAccess().getServiceclientAssignment_7_3_1()); - // InternalRos.g:7521:2: ( rule__Node__ServiceclientAssignment_7_3_1 ) - // InternalRos.g:7521:3: rule__Node__ServiceclientAssignment_7_3_1 + before(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); + // InternalRosParser.g:7532:2: ( rule__ExternalDependency__NameAssignment_2 ) + // InternalRosParser.g:7532:3: rule__ExternalDependency__NameAssignment_2 { pushFollow(FOLLOW_2); - rule__Node__ServiceclientAssignment_7_3_1(); + rule__ExternalDependency__NameAssignment_2(); state._fsp--; } - after(grammarAccess.getNodeAccess().getServiceclientAssignment_7_3_1()); + after(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); } @@ -23203,26 +22785,26 @@ public final void rule__Node__Group_7_3__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_7_3__1__Impl" + // $ANTLR end "rule__ExternalDependency__Group__2__Impl" - // $ANTLR start "rule__Node__Group_8__0" - // InternalRos.g:7530:1: rule__Node__Group_8__0 : rule__Node__Group_8__0__Impl rule__Node__Group_8__1 ; - public final void rule__Node__Group_8__0() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group__0" + // InternalRosParser.g:7541:1: rule__GlobalNamespace__Group__0 : rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 ; + public final void rule__GlobalNamespace__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7534:1: ( rule__Node__Group_8__0__Impl rule__Node__Group_8__1 ) - // InternalRos.g:7535:2: rule__Node__Group_8__0__Impl rule__Node__Group_8__1 + // InternalRosParser.g:7545:1: ( rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 ) + // InternalRosParser.g:7546:2: rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 { - pushFollow(FOLLOW_4); - rule__Node__Group_8__0__Impl(); + pushFollow(FOLLOW_37); + rule__GlobalNamespace__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_8__1(); + rule__GlobalNamespace__Group__1(); state._fsp--; @@ -23241,25 +22823,29 @@ public final void rule__Node__Group_8__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8__0" + // $ANTLR end "rule__GlobalNamespace__Group__0" - // $ANTLR start "rule__Node__Group_8__0__Impl" - // InternalRos.g:7542:1: rule__Node__Group_8__0__Impl : ( 'ActionServers' ) ; - public final void rule__Node__Group_8__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group__0__Impl" + // InternalRosParser.g:7553:1: rule__GlobalNamespace__Group__0__Impl : ( () ) ; + public final void rule__GlobalNamespace__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7546:1: ( ( 'ActionServers' ) ) - // InternalRos.g:7547:1: ( 'ActionServers' ) + // InternalRosParser.g:7557:1: ( ( () ) ) + // InternalRosParser.g:7558:1: ( () ) { - // InternalRos.g:7547:1: ( 'ActionServers' ) - // InternalRos.g:7548:2: 'ActionServers' + // InternalRosParser.g:7558:1: ( () ) + // InternalRosParser.g:7559:2: () + { + before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); + // InternalRosParser.g:7560:2: () + // InternalRosParser.g:7560:3: { - before(grammarAccess.getNodeAccess().getActionServersKeyword_8_0()); - match(input,61,FOLLOW_2); - after(grammarAccess.getNodeAccess().getActionServersKeyword_8_0()); + } + + after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); } @@ -23267,10 +22853,6 @@ public final void rule__Node__Group_8__0__Impl() throws RecognitionException { } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -23278,26 +22860,26 @@ public final void rule__Node__Group_8__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8__0__Impl" + // $ANTLR end "rule__GlobalNamespace__Group__0__Impl" - // $ANTLR start "rule__Node__Group_8__1" - // InternalRos.g:7557:1: rule__Node__Group_8__1 : rule__Node__Group_8__1__Impl rule__Node__Group_8__2 ; - public final void rule__Node__Group_8__1() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group__1" + // InternalRosParser.g:7568:1: rule__GlobalNamespace__Group__1 : rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 ; + public final void rule__GlobalNamespace__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7561:1: ( rule__Node__Group_8__1__Impl rule__Node__Group_8__2 ) - // InternalRos.g:7562:2: rule__Node__Group_8__1__Impl rule__Node__Group_8__2 + // InternalRosParser.g:7572:1: ( rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 ) + // InternalRosParser.g:7573:2: rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 { - pushFollow(FOLLOW_35); - rule__Node__Group_8__1__Impl(); + pushFollow(FOLLOW_11); + rule__GlobalNamespace__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_8__2(); + rule__GlobalNamespace__Group__2(); state._fsp--; @@ -23316,25 +22898,25 @@ public final void rule__Node__Group_8__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8__1" + // $ANTLR end "rule__GlobalNamespace__Group__1" - // $ANTLR start "rule__Node__Group_8__1__Impl" - // InternalRos.g:7569:1: rule__Node__Group_8__1__Impl : ( '{' ) ; - public final void rule__Node__Group_8__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group__1__Impl" + // InternalRosParser.g:7580:1: rule__GlobalNamespace__Group__1__Impl : ( GlobalNamespace ) ; + public final void rule__GlobalNamespace__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7573:1: ( ( '{' ) ) - // InternalRos.g:7574:1: ( '{' ) + // InternalRosParser.g:7584:1: ( ( GlobalNamespace ) ) + // InternalRosParser.g:7585:1: ( GlobalNamespace ) { - // InternalRos.g:7574:1: ( '{' ) - // InternalRos.g:7575:2: '{' + // InternalRosParser.g:7585:1: ( GlobalNamespace ) + // InternalRosParser.g:7586:2: GlobalNamespace { - before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_8_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_8_1()); + before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); + match(input,GlobalNamespace,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); } @@ -23353,26 +22935,21 @@ public final void rule__Node__Group_8__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8__1__Impl" + // $ANTLR end "rule__GlobalNamespace__Group__1__Impl" - // $ANTLR start "rule__Node__Group_8__2" - // InternalRos.g:7584:1: rule__Node__Group_8__2 : rule__Node__Group_8__2__Impl rule__Node__Group_8__3 ; - public final void rule__Node__Group_8__2() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group__2" + // InternalRosParser.g:7595:1: rule__GlobalNamespace__Group__2 : rule__GlobalNamespace__Group__2__Impl ; + public final void rule__GlobalNamespace__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7588:1: ( rule__Node__Group_8__2__Impl rule__Node__Group_8__3 ) - // InternalRos.g:7589:2: rule__Node__Group_8__2__Impl rule__Node__Group_8__3 + // InternalRosParser.g:7599:1: ( rule__GlobalNamespace__Group__2__Impl ) + // InternalRosParser.g:7600:2: rule__GlobalNamespace__Group__2__Impl { - pushFollow(FOLLOW_13); - rule__Node__Group_8__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Node__Group_8__3(); + rule__GlobalNamespace__Group__2__Impl(); state._fsp--; @@ -23391,35 +22968,46 @@ public final void rule__Node__Group_8__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8__2" + // $ANTLR end "rule__GlobalNamespace__Group__2" - // $ANTLR start "rule__Node__Group_8__2__Impl" - // InternalRos.g:7596:1: rule__Node__Group_8__2__Impl : ( ( rule__Node__ActionserverAssignment_8_2 ) ) ; - public final void rule__Node__Group_8__2__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group__2__Impl" + // InternalRosParser.g:7606:1: rule__GlobalNamespace__Group__2__Impl : ( ( rule__GlobalNamespace__Group_2__0 )? ) ; + public final void rule__GlobalNamespace__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7600:1: ( ( ( rule__Node__ActionserverAssignment_8_2 ) ) ) - // InternalRos.g:7601:1: ( ( rule__Node__ActionserverAssignment_8_2 ) ) + // InternalRosParser.g:7610:1: ( ( ( rule__GlobalNamespace__Group_2__0 )? ) ) + // InternalRosParser.g:7611:1: ( ( rule__GlobalNamespace__Group_2__0 )? ) { - // InternalRos.g:7601:1: ( ( rule__Node__ActionserverAssignment_8_2 ) ) - // InternalRos.g:7602:2: ( rule__Node__ActionserverAssignment_8_2 ) + // InternalRosParser.g:7611:1: ( ( rule__GlobalNamespace__Group_2__0 )? ) + // InternalRosParser.g:7612:2: ( rule__GlobalNamespace__Group_2__0 )? { - before(grammarAccess.getNodeAccess().getActionserverAssignment_8_2()); - // InternalRos.g:7603:2: ( rule__Node__ActionserverAssignment_8_2 ) - // InternalRos.g:7603:3: rule__Node__ActionserverAssignment_8_2 - { - pushFollow(FOLLOW_2); - rule__Node__ActionserverAssignment_8_2(); + before(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); + // InternalRosParser.g:7613:2: ( rule__GlobalNamespace__Group_2__0 )? + int alt41=2; + int LA41_0 = input.LA(1); + + if ( (LA41_0==LeftSquareBracket) ) { + alt41=1; + } + switch (alt41) { + case 1 : + // InternalRosParser.g:7613:3: rule__GlobalNamespace__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2__0(); + + state._fsp--; - state._fsp--; + } + break; } - after(grammarAccess.getNodeAccess().getActionserverAssignment_8_2()); + after(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); } @@ -23438,26 +23026,26 @@ public final void rule__Node__Group_8__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8__2__Impl" + // $ANTLR end "rule__GlobalNamespace__Group__2__Impl" - // $ANTLR start "rule__Node__Group_8__3" - // InternalRos.g:7611:1: rule__Node__Group_8__3 : rule__Node__Group_8__3__Impl rule__Node__Group_8__4 ; - public final void rule__Node__Group_8__3() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2__0" + // InternalRosParser.g:7622:1: rule__GlobalNamespace__Group_2__0 : rule__GlobalNamespace__Group_2__0__Impl rule__GlobalNamespace__Group_2__1 ; + public final void rule__GlobalNamespace__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7615:1: ( rule__Node__Group_8__3__Impl rule__Node__Group_8__4 ) - // InternalRos.g:7616:2: rule__Node__Group_8__3__Impl rule__Node__Group_8__4 + // InternalRosParser.g:7626:1: ( rule__GlobalNamespace__Group_2__0__Impl rule__GlobalNamespace__Group_2__1 ) + // InternalRosParser.g:7627:2: rule__GlobalNamespace__Group_2__0__Impl rule__GlobalNamespace__Group_2__1 { - pushFollow(FOLLOW_13); - rule__Node__Group_8__3__Impl(); + pushFollow(FOLLOW_38); + rule__GlobalNamespace__Group_2__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_8__4(); + rule__GlobalNamespace__Group_2__1(); state._fsp--; @@ -23476,53 +23064,25 @@ public final void rule__Node__Group_8__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8__3" + // $ANTLR end "rule__GlobalNamespace__Group_2__0" - // $ANTLR start "rule__Node__Group_8__3__Impl" - // InternalRos.g:7623:1: rule__Node__Group_8__3__Impl : ( ( rule__Node__Group_8_3__0 )* ) ; - public final void rule__Node__Group_8__3__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2__0__Impl" + // InternalRosParser.g:7634:1: rule__GlobalNamespace__Group_2__0__Impl : ( LeftSquareBracket ) ; + public final void rule__GlobalNamespace__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7627:1: ( ( ( rule__Node__Group_8_3__0 )* ) ) - // InternalRos.g:7628:1: ( ( rule__Node__Group_8_3__0 )* ) + // InternalRosParser.g:7638:1: ( ( LeftSquareBracket ) ) + // InternalRosParser.g:7639:1: ( LeftSquareBracket ) { - // InternalRos.g:7628:1: ( ( rule__Node__Group_8_3__0 )* ) - // InternalRos.g:7629:2: ( rule__Node__Group_8_3__0 )* + // InternalRosParser.g:7639:1: ( LeftSquareBracket ) + // InternalRosParser.g:7640:2: LeftSquareBracket { - before(grammarAccess.getNodeAccess().getGroup_8_3()); - // InternalRos.g:7630:2: ( rule__Node__Group_8_3__0 )* - loop54: - do { - int alt54=2; - int LA54_0 = input.LA(1); - - if ( (LA54_0==43) ) { - alt54=1; - } - - - switch (alt54) { - case 1 : - // InternalRos.g:7630:3: rule__Node__Group_8_3__0 - { - pushFollow(FOLLOW_7); - rule__Node__Group_8_3__0(); - - state._fsp--; - - - } - break; - - default : - break loop54; - } - } while (true); - - after(grammarAccess.getNodeAccess().getGroup_8_3()); + before(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } @@ -23541,21 +23101,26 @@ public final void rule__Node__Group_8__3__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8__3__Impl" + // $ANTLR end "rule__GlobalNamespace__Group_2__0__Impl" - // $ANTLR start "rule__Node__Group_8__4" - // InternalRos.g:7638:1: rule__Node__Group_8__4 : rule__Node__Group_8__4__Impl ; - public final void rule__Node__Group_8__4() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2__1" + // InternalRosParser.g:7649:1: rule__GlobalNamespace__Group_2__1 : rule__GlobalNamespace__Group_2__1__Impl rule__GlobalNamespace__Group_2__2 ; + public final void rule__GlobalNamespace__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7642:1: ( rule__Node__Group_8__4__Impl ) - // InternalRos.g:7643:2: rule__Node__Group_8__4__Impl + // InternalRosParser.g:7653:1: ( rule__GlobalNamespace__Group_2__1__Impl rule__GlobalNamespace__Group_2__2 ) + // InternalRosParser.g:7654:2: rule__GlobalNamespace__Group_2__1__Impl rule__GlobalNamespace__Group_2__2 { + pushFollow(FOLLOW_13); + rule__GlobalNamespace__Group_2__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Node__Group_8__4__Impl(); + rule__GlobalNamespace__Group_2__2(); state._fsp--; @@ -23574,100 +23139,35 @@ public final void rule__Node__Group_8__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8__4" + // $ANTLR end "rule__GlobalNamespace__Group_2__1" - // $ANTLR start "rule__Node__Group_8__4__Impl" - // InternalRos.g:7649:1: rule__Node__Group_8__4__Impl : ( '}' ) ; - public final void rule__Node__Group_8__4__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2__1__Impl" + // InternalRosParser.g:7661:1: rule__GlobalNamespace__Group_2__1__Impl : ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) ; + public final void rule__GlobalNamespace__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7653:1: ( ( '}' ) ) - // InternalRos.g:7654:1: ( '}' ) + // InternalRosParser.g:7665:1: ( ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) ) + // InternalRosParser.g:7666:1: ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) { - // InternalRos.g:7654:1: ( '}' ) - // InternalRos.g:7655:2: '}' + // InternalRosParser.g:7666:1: ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) + // InternalRosParser.g:7667:2: ( rule__GlobalNamespace__PartsAssignment_2_1 ) { - before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_8_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_8_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_8__4__Impl" - - - // $ANTLR start "rule__Node__Group_8_3__0" - // InternalRos.g:7665:1: rule__Node__Group_8_3__0 : rule__Node__Group_8_3__0__Impl rule__Node__Group_8_3__1 ; - public final void rule__Node__Group_8_3__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7669:1: ( rule__Node__Group_8_3__0__Impl rule__Node__Group_8_3__1 ) - // InternalRos.g:7670:2: rule__Node__Group_8_3__0__Impl rule__Node__Group_8_3__1 + before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); + // InternalRosParser.g:7668:2: ( rule__GlobalNamespace__PartsAssignment_2_1 ) + // InternalRosParser.g:7668:3: rule__GlobalNamespace__PartsAssignment_2_1 { - pushFollow(FOLLOW_35); - rule__Node__Group_8_3__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Node__Group_8_3__1(); + rule__GlobalNamespace__PartsAssignment_2_1(); state._fsp--; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_8_3__0" - - - // $ANTLR start "rule__Node__Group_8_3__0__Impl" - // InternalRos.g:7677:1: rule__Node__Group_8_3__0__Impl : ( ',' ) ; - public final void rule__Node__Group_8_3__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7681:1: ( ( ',' ) ) - // InternalRos.g:7682:1: ( ',' ) - { - // InternalRos.g:7682:1: ( ',' ) - // InternalRos.g:7683:2: ',' - { - before(grammarAccess.getNodeAccess().getCommaKeyword_8_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getNodeAccess().getCommaKeyword_8_3_0()); + after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); } @@ -23686,21 +23186,26 @@ public final void rule__Node__Group_8_3__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8_3__0__Impl" + // $ANTLR end "rule__GlobalNamespace__Group_2__1__Impl" - // $ANTLR start "rule__Node__Group_8_3__1" - // InternalRos.g:7692:1: rule__Node__Group_8_3__1 : rule__Node__Group_8_3__1__Impl ; - public final void rule__Node__Group_8_3__1() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2__2" + // InternalRosParser.g:7676:1: rule__GlobalNamespace__Group_2__2 : rule__GlobalNamespace__Group_2__2__Impl rule__GlobalNamespace__Group_2__3 ; + public final void rule__GlobalNamespace__Group_2__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7696:1: ( rule__Node__Group_8_3__1__Impl ) - // InternalRos.g:7697:2: rule__Node__Group_8_3__1__Impl + // InternalRosParser.g:7680:1: ( rule__GlobalNamespace__Group_2__2__Impl rule__GlobalNamespace__Group_2__3 ) + // InternalRosParser.g:7681:2: rule__GlobalNamespace__Group_2__2__Impl rule__GlobalNamespace__Group_2__3 { + pushFollow(FOLLOW_13); + rule__GlobalNamespace__Group_2__2__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Node__Group_8_3__1__Impl(); + rule__GlobalNamespace__Group_2__3(); state._fsp--; @@ -23719,35 +23224,53 @@ public final void rule__Node__Group_8_3__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8_3__1" + // $ANTLR end "rule__GlobalNamespace__Group_2__2" - // $ANTLR start "rule__Node__Group_8_3__1__Impl" - // InternalRos.g:7703:1: rule__Node__Group_8_3__1__Impl : ( ( rule__Node__ActionserverAssignment_8_3_1 ) ) ; - public final void rule__Node__Group_8_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2__2__Impl" + // InternalRosParser.g:7688:1: rule__GlobalNamespace__Group_2__2__Impl : ( ( rule__GlobalNamespace__Group_2_2__0 )* ) ; + public final void rule__GlobalNamespace__Group_2__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7707:1: ( ( ( rule__Node__ActionserverAssignment_8_3_1 ) ) ) - // InternalRos.g:7708:1: ( ( rule__Node__ActionserverAssignment_8_3_1 ) ) - { - // InternalRos.g:7708:1: ( ( rule__Node__ActionserverAssignment_8_3_1 ) ) - // InternalRos.g:7709:2: ( rule__Node__ActionserverAssignment_8_3_1 ) + // InternalRosParser.g:7692:1: ( ( ( rule__GlobalNamespace__Group_2_2__0 )* ) ) + // InternalRosParser.g:7693:1: ( ( rule__GlobalNamespace__Group_2_2__0 )* ) { - before(grammarAccess.getNodeAccess().getActionserverAssignment_8_3_1()); - // InternalRos.g:7710:2: ( rule__Node__ActionserverAssignment_8_3_1 ) - // InternalRos.g:7710:3: rule__Node__ActionserverAssignment_8_3_1 + // InternalRosParser.g:7693:1: ( ( rule__GlobalNamespace__Group_2_2__0 )* ) + // InternalRosParser.g:7694:2: ( rule__GlobalNamespace__Group_2_2__0 )* { - pushFollow(FOLLOW_2); - rule__Node__ActionserverAssignment_8_3_1(); + before(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); + // InternalRosParser.g:7695:2: ( rule__GlobalNamespace__Group_2_2__0 )* + loop42: + do { + int alt42=2; + int LA42_0 = input.LA(1); - state._fsp--; + if ( (LA42_0==Comma) ) { + alt42=1; + } - } + switch (alt42) { + case 1 : + // InternalRosParser.g:7695:3: rule__GlobalNamespace__Group_2_2__0 + { + pushFollow(FOLLOW_14); + rule__GlobalNamespace__Group_2_2__0(); - after(grammarAccess.getNodeAccess().getActionserverAssignment_8_3_1()); + state._fsp--; + + + } + break; + + default : + break loop42; + } + } while (true); + + after(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); } @@ -23766,26 +23289,21 @@ public final void rule__Node__Group_8_3__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_8_3__1__Impl" + // $ANTLR end "rule__GlobalNamespace__Group_2__2__Impl" - // $ANTLR start "rule__Node__Group_9__0" - // InternalRos.g:7719:1: rule__Node__Group_9__0 : rule__Node__Group_9__0__Impl rule__Node__Group_9__1 ; - public final void rule__Node__Group_9__0() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2__3" + // InternalRosParser.g:7703:1: rule__GlobalNamespace__Group_2__3 : rule__GlobalNamespace__Group_2__3__Impl ; + public final void rule__GlobalNamespace__Group_2__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7723:1: ( rule__Node__Group_9__0__Impl rule__Node__Group_9__1 ) - // InternalRos.g:7724:2: rule__Node__Group_9__0__Impl rule__Node__Group_9__1 + // InternalRosParser.g:7707:1: ( rule__GlobalNamespace__Group_2__3__Impl ) + // InternalRosParser.g:7708:2: rule__GlobalNamespace__Group_2__3__Impl { - pushFollow(FOLLOW_4); - rule__Node__Group_9__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Node__Group_9__1(); + rule__GlobalNamespace__Group_2__3__Impl(); state._fsp--; @@ -23804,25 +23322,25 @@ public final void rule__Node__Group_9__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_9__0" + // $ANTLR end "rule__GlobalNamespace__Group_2__3" - // $ANTLR start "rule__Node__Group_9__0__Impl" - // InternalRos.g:7731:1: rule__Node__Group_9__0__Impl : ( 'ActionClients' ) ; - public final void rule__Node__Group_9__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2__3__Impl" + // InternalRosParser.g:7714:1: rule__GlobalNamespace__Group_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__GlobalNamespace__Group_2__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7735:1: ( ( 'ActionClients' ) ) - // InternalRos.g:7736:1: ( 'ActionClients' ) + // InternalRosParser.g:7718:1: ( ( RightSquareBracket ) ) + // InternalRosParser.g:7719:1: ( RightSquareBracket ) { - // InternalRos.g:7736:1: ( 'ActionClients' ) - // InternalRos.g:7737:2: 'ActionClients' + // InternalRosParser.g:7719:1: ( RightSquareBracket ) + // InternalRosParser.g:7720:2: RightSquareBracket { - before(grammarAccess.getNodeAccess().getActionClientsKeyword_9_0()); - match(input,62,FOLLOW_2); - after(grammarAccess.getNodeAccess().getActionClientsKeyword_9_0()); + before(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); } @@ -23841,26 +23359,26 @@ public final void rule__Node__Group_9__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_9__0__Impl" + // $ANTLR end "rule__GlobalNamespace__Group_2__3__Impl" - // $ANTLR start "rule__Node__Group_9__1" - // InternalRos.g:7746:1: rule__Node__Group_9__1 : rule__Node__Group_9__1__Impl rule__Node__Group_9__2 ; - public final void rule__Node__Group_9__1() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2_2__0" + // InternalRosParser.g:7730:1: rule__GlobalNamespace__Group_2_2__0 : rule__GlobalNamespace__Group_2_2__0__Impl rule__GlobalNamespace__Group_2_2__1 ; + public final void rule__GlobalNamespace__Group_2_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7750:1: ( rule__Node__Group_9__1__Impl rule__Node__Group_9__2 ) - // InternalRos.g:7751:2: rule__Node__Group_9__1__Impl rule__Node__Group_9__2 + // InternalRosParser.g:7734:1: ( rule__GlobalNamespace__Group_2_2__0__Impl rule__GlobalNamespace__Group_2_2__1 ) + // InternalRosParser.g:7735:2: rule__GlobalNamespace__Group_2_2__0__Impl rule__GlobalNamespace__Group_2_2__1 { - pushFollow(FOLLOW_36); - rule__Node__Group_9__1__Impl(); + pushFollow(FOLLOW_38); + rule__GlobalNamespace__Group_2_2__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_9__2(); + rule__GlobalNamespace__Group_2_2__1(); state._fsp--; @@ -23879,25 +23397,25 @@ public final void rule__Node__Group_9__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_9__1" + // $ANTLR end "rule__GlobalNamespace__Group_2_2__0" - // $ANTLR start "rule__Node__Group_9__1__Impl" - // InternalRos.g:7758:1: rule__Node__Group_9__1__Impl : ( '{' ) ; - public final void rule__Node__Group_9__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2_2__0__Impl" + // InternalRosParser.g:7742:1: rule__GlobalNamespace__Group_2_2__0__Impl : ( Comma ) ; + public final void rule__GlobalNamespace__Group_2_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7762:1: ( ( '{' ) ) - // InternalRos.g:7763:1: ( '{' ) + // InternalRosParser.g:7746:1: ( ( Comma ) ) + // InternalRosParser.g:7747:1: ( Comma ) { - // InternalRos.g:7763:1: ( '{' ) - // InternalRos.g:7764:2: '{' + // InternalRosParser.g:7747:1: ( Comma ) + // InternalRosParser.g:7748:2: Comma { - before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_9_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_9_1()); + before(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); } @@ -23916,26 +23434,21 @@ public final void rule__Node__Group_9__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_9__1__Impl" + // $ANTLR end "rule__GlobalNamespace__Group_2_2__0__Impl" - // $ANTLR start "rule__Node__Group_9__2" - // InternalRos.g:7773:1: rule__Node__Group_9__2 : rule__Node__Group_9__2__Impl rule__Node__Group_9__3 ; - public final void rule__Node__Group_9__2() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2_2__1" + // InternalRosParser.g:7757:1: rule__GlobalNamespace__Group_2_2__1 : rule__GlobalNamespace__Group_2_2__1__Impl ; + public final void rule__GlobalNamespace__Group_2_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7777:1: ( rule__Node__Group_9__2__Impl rule__Node__Group_9__3 ) - // InternalRos.g:7778:2: rule__Node__Group_9__2__Impl rule__Node__Group_9__3 + // InternalRosParser.g:7761:1: ( rule__GlobalNamespace__Group_2_2__1__Impl ) + // InternalRosParser.g:7762:2: rule__GlobalNamespace__Group_2_2__1__Impl { - pushFollow(FOLLOW_13); - rule__Node__Group_9__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Node__Group_9__3(); + rule__GlobalNamespace__Group_2_2__1__Impl(); state._fsp--; @@ -23954,35 +23467,35 @@ public final void rule__Node__Group_9__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_9__2" + // $ANTLR end "rule__GlobalNamespace__Group_2_2__1" - // $ANTLR start "rule__Node__Group_9__2__Impl" - // InternalRos.g:7785:1: rule__Node__Group_9__2__Impl : ( ( rule__Node__ActionclientAssignment_9_2 ) ) ; - public final void rule__Node__Group_9__2__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__Group_2_2__1__Impl" + // InternalRosParser.g:7768:1: rule__GlobalNamespace__Group_2_2__1__Impl : ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) ; + public final void rule__GlobalNamespace__Group_2_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7789:1: ( ( ( rule__Node__ActionclientAssignment_9_2 ) ) ) - // InternalRos.g:7790:1: ( ( rule__Node__ActionclientAssignment_9_2 ) ) + // InternalRosParser.g:7772:1: ( ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) ) + // InternalRosParser.g:7773:1: ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) { - // InternalRos.g:7790:1: ( ( rule__Node__ActionclientAssignment_9_2 ) ) - // InternalRos.g:7791:2: ( rule__Node__ActionclientAssignment_9_2 ) + // InternalRosParser.g:7773:1: ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) + // InternalRosParser.g:7774:2: ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) { - before(grammarAccess.getNodeAccess().getActionclientAssignment_9_2()); - // InternalRos.g:7792:2: ( rule__Node__ActionclientAssignment_9_2 ) - // InternalRos.g:7792:3: rule__Node__ActionclientAssignment_9_2 + before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); + // InternalRosParser.g:7775:2: ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) + // InternalRosParser.g:7775:3: rule__GlobalNamespace__PartsAssignment_2_2_1 { pushFollow(FOLLOW_2); - rule__Node__ActionclientAssignment_9_2(); + rule__GlobalNamespace__PartsAssignment_2_2_1(); state._fsp--; } - after(grammarAccess.getNodeAccess().getActionclientAssignment_9_2()); + after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); } @@ -24001,26 +23514,26 @@ public final void rule__Node__Group_9__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_9__2__Impl" + // $ANTLR end "rule__GlobalNamespace__Group_2_2__1__Impl" - // $ANTLR start "rule__Node__Group_9__3" - // InternalRos.g:7800:1: rule__Node__Group_9__3 : rule__Node__Group_9__3__Impl rule__Node__Group_9__4 ; - public final void rule__Node__Group_9__3() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group__0" + // InternalRosParser.g:7784:1: rule__RelativeNamespace_Impl__Group__0 : rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 ; + public final void rule__RelativeNamespace_Impl__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7804:1: ( rule__Node__Group_9__3__Impl rule__Node__Group_9__4 ) - // InternalRos.g:7805:2: rule__Node__Group_9__3__Impl rule__Node__Group_9__4 + // InternalRosParser.g:7788:1: ( rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 ) + // InternalRosParser.g:7789:2: rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 { - pushFollow(FOLLOW_13); - rule__Node__Group_9__3__Impl(); + pushFollow(FOLLOW_39); + rule__RelativeNamespace_Impl__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_9__4(); + rule__RelativeNamespace_Impl__Group__1(); state._fsp--; @@ -24039,123 +23552,29 @@ public final void rule__Node__Group_9__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_9__3" + // $ANTLR end "rule__RelativeNamespace_Impl__Group__0" - // $ANTLR start "rule__Node__Group_9__3__Impl" - // InternalRos.g:7812:1: rule__Node__Group_9__3__Impl : ( ( rule__Node__Group_9_3__0 )* ) ; - public final void rule__Node__Group_9__3__Impl() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group__0__Impl" + // InternalRosParser.g:7796:1: rule__RelativeNamespace_Impl__Group__0__Impl : ( () ) ; + public final void rule__RelativeNamespace_Impl__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7816:1: ( ( ( rule__Node__Group_9_3__0 )* ) ) - // InternalRos.g:7817:1: ( ( rule__Node__Group_9_3__0 )* ) + // InternalRosParser.g:7800:1: ( ( () ) ) + // InternalRosParser.g:7801:1: ( () ) { - // InternalRos.g:7817:1: ( ( rule__Node__Group_9_3__0 )* ) - // InternalRos.g:7818:2: ( rule__Node__Group_9_3__0 )* + // InternalRosParser.g:7801:1: ( () ) + // InternalRosParser.g:7802:2: () { - before(grammarAccess.getNodeAccess().getGroup_9_3()); - // InternalRos.g:7819:2: ( rule__Node__Group_9_3__0 )* - loop55: - do { - int alt55=2; - int LA55_0 = input.LA(1); - - if ( (LA55_0==43) ) { - alt55=1; - } - - - switch (alt55) { - case 1 : - // InternalRos.g:7819:3: rule__Node__Group_9_3__0 - { - pushFollow(FOLLOW_7); - rule__Node__Group_9_3__0(); - - state._fsp--; - - - } - break; - - default : - break loop55; - } - } while (true); - - after(grammarAccess.getNodeAccess().getGroup_9_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_9__3__Impl" - - - // $ANTLR start "rule__Node__Group_9__4" - // InternalRos.g:7827:1: rule__Node__Group_9__4 : rule__Node__Group_9__4__Impl ; - public final void rule__Node__Group_9__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7831:1: ( rule__Node__Group_9__4__Impl ) - // InternalRos.g:7832:2: rule__Node__Group_9__4__Impl + before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); + // InternalRosParser.g:7803:2: () + // InternalRosParser.g:7803:3: { - pushFollow(FOLLOW_2); - rule__Node__Group_9__4__Impl(); - - state._fsp--; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_9__4" - - - // $ANTLR start "rule__Node__Group_9__4__Impl" - // InternalRos.g:7838:1: rule__Node__Group_9__4__Impl : ( '}' ) ; - public final void rule__Node__Group_9__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7842:1: ( ( '}' ) ) - // InternalRos.g:7843:1: ( '}' ) - { - // InternalRos.g:7843:1: ( '}' ) - // InternalRos.g:7844:2: '}' - { - before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_9_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_9_4()); + after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); } @@ -24163,10 +23582,6 @@ public final void rule__Node__Group_9__4__Impl() throws RecognitionException { } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -24174,26 +23589,26 @@ public final void rule__Node__Group_9__4__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_9__4__Impl" + // $ANTLR end "rule__RelativeNamespace_Impl__Group__0__Impl" - // $ANTLR start "rule__Node__Group_9_3__0" - // InternalRos.g:7854:1: rule__Node__Group_9_3__0 : rule__Node__Group_9_3__0__Impl rule__Node__Group_9_3__1 ; - public final void rule__Node__Group_9_3__0() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group__1" + // InternalRosParser.g:7811:1: rule__RelativeNamespace_Impl__Group__1 : rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 ; + public final void rule__RelativeNamespace_Impl__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7858:1: ( rule__Node__Group_9_3__0__Impl rule__Node__Group_9_3__1 ) - // InternalRos.g:7859:2: rule__Node__Group_9_3__0__Impl rule__Node__Group_9_3__1 + // InternalRosParser.g:7815:1: ( rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 ) + // InternalRosParser.g:7816:2: rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 { - pushFollow(FOLLOW_36); - rule__Node__Group_9_3__0__Impl(); + pushFollow(FOLLOW_11); + rule__RelativeNamespace_Impl__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_9_3__1(); + rule__RelativeNamespace_Impl__Group__2(); state._fsp--; @@ -24212,25 +23627,25 @@ public final void rule__Node__Group_9_3__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_9_3__0" + // $ANTLR end "rule__RelativeNamespace_Impl__Group__1" - // $ANTLR start "rule__Node__Group_9_3__0__Impl" - // InternalRos.g:7866:1: rule__Node__Group_9_3__0__Impl : ( ',' ) ; - public final void rule__Node__Group_9_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group__1__Impl" + // InternalRosParser.g:7823:1: rule__RelativeNamespace_Impl__Group__1__Impl : ( RelativeNamespace ) ; + public final void rule__RelativeNamespace_Impl__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7870:1: ( ( ',' ) ) - // InternalRos.g:7871:1: ( ',' ) + // InternalRosParser.g:7827:1: ( ( RelativeNamespace ) ) + // InternalRosParser.g:7828:1: ( RelativeNamespace ) { - // InternalRos.g:7871:1: ( ',' ) - // InternalRos.g:7872:2: ',' + // InternalRosParser.g:7828:1: ( RelativeNamespace ) + // InternalRosParser.g:7829:2: RelativeNamespace { - before(grammarAccess.getNodeAccess().getCommaKeyword_9_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getNodeAccess().getCommaKeyword_9_3_0()); + before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); + match(input,RelativeNamespace,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); } @@ -24249,21 +23664,21 @@ public final void rule__Node__Group_9_3__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_9_3__0__Impl" + // $ANTLR end "rule__RelativeNamespace_Impl__Group__1__Impl" - // $ANTLR start "rule__Node__Group_9_3__1" - // InternalRos.g:7881:1: rule__Node__Group_9_3__1 : rule__Node__Group_9_3__1__Impl ; - public final void rule__Node__Group_9_3__1() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group__2" + // InternalRosParser.g:7838:1: rule__RelativeNamespace_Impl__Group__2 : rule__RelativeNamespace_Impl__Group__2__Impl ; + public final void rule__RelativeNamespace_Impl__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7885:1: ( rule__Node__Group_9_3__1__Impl ) - // InternalRos.g:7886:2: rule__Node__Group_9_3__1__Impl + // InternalRosParser.g:7842:1: ( rule__RelativeNamespace_Impl__Group__2__Impl ) + // InternalRosParser.g:7843:2: rule__RelativeNamespace_Impl__Group__2__Impl { pushFollow(FOLLOW_2); - rule__Node__Group_9_3__1__Impl(); + rule__RelativeNamespace_Impl__Group__2__Impl(); state._fsp--; @@ -24282,110 +23697,46 @@ public final void rule__Node__Group_9_3__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_9_3__1" + // $ANTLR end "rule__RelativeNamespace_Impl__Group__2" - // $ANTLR start "rule__Node__Group_9_3__1__Impl" - // InternalRos.g:7892:1: rule__Node__Group_9_3__1__Impl : ( ( rule__Node__ActionclientAssignment_9_3_1 ) ) ; - public final void rule__Node__Group_9_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group__2__Impl" + // InternalRosParser.g:7849:1: rule__RelativeNamespace_Impl__Group__2__Impl : ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) ; + public final void rule__RelativeNamespace_Impl__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7896:1: ( ( ( rule__Node__ActionclientAssignment_9_3_1 ) ) ) - // InternalRos.g:7897:1: ( ( rule__Node__ActionclientAssignment_9_3_1 ) ) - { - // InternalRos.g:7897:1: ( ( rule__Node__ActionclientAssignment_9_3_1 ) ) - // InternalRos.g:7898:2: ( rule__Node__ActionclientAssignment_9_3_1 ) + // InternalRosParser.g:7853:1: ( ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) ) + // InternalRosParser.g:7854:1: ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) { - before(grammarAccess.getNodeAccess().getActionclientAssignment_9_3_1()); - // InternalRos.g:7899:2: ( rule__Node__ActionclientAssignment_9_3_1 ) - // InternalRos.g:7899:3: rule__Node__ActionclientAssignment_9_3_1 + // InternalRosParser.g:7854:1: ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) + // InternalRosParser.g:7855:2: ( rule__RelativeNamespace_Impl__Group_2__0 )? { - pushFollow(FOLLOW_2); - rule__Node__ActionclientAssignment_9_3_1(); - - state._fsp--; - - - } - - after(grammarAccess.getNodeAccess().getActionclientAssignment_9_3_1()); - - } - + before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); + // InternalRosParser.g:7856:2: ( rule__RelativeNamespace_Impl__Group_2__0 )? + int alt43=2; + int LA43_0 = input.LA(1); + if ( (LA43_0==LeftSquareBracket) ) { + alt43=1; } + switch (alt43) { + case 1 : + // InternalRosParser.g:7856:3: rule__RelativeNamespace_Impl__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2__0(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_9_3__1__Impl" - - - // $ANTLR start "rule__Node__Group_10__0" - // InternalRos.g:7908:1: rule__Node__Group_10__0 : rule__Node__Group_10__0__Impl rule__Node__Group_10__1 ; - public final void rule__Node__Group_10__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7912:1: ( rule__Node__Group_10__0__Impl rule__Node__Group_10__1 ) - // InternalRos.g:7913:2: rule__Node__Group_10__0__Impl rule__Node__Group_10__1 - { - pushFollow(FOLLOW_4); - rule__Node__Group_10__0__Impl(); - - state._fsp--; + state._fsp--; - pushFollow(FOLLOW_2); - rule__Node__Group_10__1(); - - state._fsp--; + } + break; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__Group_10__0" - - - // $ANTLR start "rule__Node__Group_10__0__Impl" - // InternalRos.g:7920:1: rule__Node__Group_10__0__Impl : ( 'Parameters' ) ; - public final void rule__Node__Group_10__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:7924:1: ( ( 'Parameters' ) ) - // InternalRos.g:7925:1: ( 'Parameters' ) - { - // InternalRos.g:7925:1: ( 'Parameters' ) - // InternalRos.g:7926:2: 'Parameters' - { - before(grammarAccess.getNodeAccess().getParametersKeyword_10_0()); - match(input,63,FOLLOW_2); - after(grammarAccess.getNodeAccess().getParametersKeyword_10_0()); + after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); } @@ -24404,26 +23755,26 @@ public final void rule__Node__Group_10__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_10__0__Impl" + // $ANTLR end "rule__RelativeNamespace_Impl__Group__2__Impl" - // $ANTLR start "rule__Node__Group_10__1" - // InternalRos.g:7935:1: rule__Node__Group_10__1 : rule__Node__Group_10__1__Impl rule__Node__Group_10__2 ; - public final void rule__Node__Group_10__1() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__0" + // InternalRosParser.g:7865:1: rule__RelativeNamespace_Impl__Group_2__0 : rule__RelativeNamespace_Impl__Group_2__0__Impl rule__RelativeNamespace_Impl__Group_2__1 ; + public final void rule__RelativeNamespace_Impl__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7939:1: ( rule__Node__Group_10__1__Impl rule__Node__Group_10__2 ) - // InternalRos.g:7940:2: rule__Node__Group_10__1__Impl rule__Node__Group_10__2 + // InternalRosParser.g:7869:1: ( rule__RelativeNamespace_Impl__Group_2__0__Impl rule__RelativeNamespace_Impl__Group_2__1 ) + // InternalRosParser.g:7870:2: rule__RelativeNamespace_Impl__Group_2__0__Impl rule__RelativeNamespace_Impl__Group_2__1 { - pushFollow(FOLLOW_37); - rule__Node__Group_10__1__Impl(); + pushFollow(FOLLOW_38); + rule__RelativeNamespace_Impl__Group_2__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_10__2(); + rule__RelativeNamespace_Impl__Group_2__1(); state._fsp--; @@ -24442,25 +23793,25 @@ public final void rule__Node__Group_10__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_10__1" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__0" - // $ANTLR start "rule__Node__Group_10__1__Impl" - // InternalRos.g:7947:1: rule__Node__Group_10__1__Impl : ( '{' ) ; - public final void rule__Node__Group_10__1__Impl() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__0__Impl" + // InternalRosParser.g:7877:1: rule__RelativeNamespace_Impl__Group_2__0__Impl : ( LeftSquareBracket ) ; + public final void rule__RelativeNamespace_Impl__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7951:1: ( ( '{' ) ) - // InternalRos.g:7952:1: ( '{' ) + // InternalRosParser.g:7881:1: ( ( LeftSquareBracket ) ) + // InternalRosParser.g:7882:1: ( LeftSquareBracket ) { - // InternalRos.g:7952:1: ( '{' ) - // InternalRos.g:7953:2: '{' + // InternalRosParser.g:7882:1: ( LeftSquareBracket ) + // InternalRosParser.g:7883:2: LeftSquareBracket { - before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_10_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_10_1()); + before(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); } @@ -24479,26 +23830,26 @@ public final void rule__Node__Group_10__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_10__1__Impl" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__0__Impl" - // $ANTLR start "rule__Node__Group_10__2" - // InternalRos.g:7962:1: rule__Node__Group_10__2 : rule__Node__Group_10__2__Impl rule__Node__Group_10__3 ; - public final void rule__Node__Group_10__2() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__1" + // InternalRosParser.g:7892:1: rule__RelativeNamespace_Impl__Group_2__1 : rule__RelativeNamespace_Impl__Group_2__1__Impl rule__RelativeNamespace_Impl__Group_2__2 ; + public final void rule__RelativeNamespace_Impl__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7966:1: ( rule__Node__Group_10__2__Impl rule__Node__Group_10__3 ) - // InternalRos.g:7967:2: rule__Node__Group_10__2__Impl rule__Node__Group_10__3 + // InternalRosParser.g:7896:1: ( rule__RelativeNamespace_Impl__Group_2__1__Impl rule__RelativeNamespace_Impl__Group_2__2 ) + // InternalRosParser.g:7897:2: rule__RelativeNamespace_Impl__Group_2__1__Impl rule__RelativeNamespace_Impl__Group_2__2 { pushFollow(FOLLOW_13); - rule__Node__Group_10__2__Impl(); + rule__RelativeNamespace_Impl__Group_2__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_10__3(); + rule__RelativeNamespace_Impl__Group_2__2(); state._fsp--; @@ -24517,35 +23868,35 @@ public final void rule__Node__Group_10__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_10__2" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__1" - // $ANTLR start "rule__Node__Group_10__2__Impl" - // InternalRos.g:7974:1: rule__Node__Group_10__2__Impl : ( ( rule__Node__ParameterAssignment_10_2 ) ) ; - public final void rule__Node__Group_10__2__Impl() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__1__Impl" + // InternalRosParser.g:7904:1: rule__RelativeNamespace_Impl__Group_2__1__Impl : ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) ; + public final void rule__RelativeNamespace_Impl__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7978:1: ( ( ( rule__Node__ParameterAssignment_10_2 ) ) ) - // InternalRos.g:7979:1: ( ( rule__Node__ParameterAssignment_10_2 ) ) + // InternalRosParser.g:7908:1: ( ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) ) + // InternalRosParser.g:7909:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) { - // InternalRos.g:7979:1: ( ( rule__Node__ParameterAssignment_10_2 ) ) - // InternalRos.g:7980:2: ( rule__Node__ParameterAssignment_10_2 ) + // InternalRosParser.g:7909:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) + // InternalRosParser.g:7910:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) { - before(grammarAccess.getNodeAccess().getParameterAssignment_10_2()); - // InternalRos.g:7981:2: ( rule__Node__ParameterAssignment_10_2 ) - // InternalRos.g:7981:3: rule__Node__ParameterAssignment_10_2 + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); + // InternalRosParser.g:7911:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) + // InternalRosParser.g:7911:3: rule__RelativeNamespace_Impl__PartsAssignment_2_1 { pushFollow(FOLLOW_2); - rule__Node__ParameterAssignment_10_2(); + rule__RelativeNamespace_Impl__PartsAssignment_2_1(); state._fsp--; } - after(grammarAccess.getNodeAccess().getParameterAssignment_10_2()); + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); } @@ -24564,26 +23915,26 @@ public final void rule__Node__Group_10__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_10__2__Impl" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__1__Impl" - // $ANTLR start "rule__Node__Group_10__3" - // InternalRos.g:7989:1: rule__Node__Group_10__3 : rule__Node__Group_10__3__Impl rule__Node__Group_10__4 ; - public final void rule__Node__Group_10__3() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__2" + // InternalRosParser.g:7919:1: rule__RelativeNamespace_Impl__Group_2__2 : rule__RelativeNamespace_Impl__Group_2__2__Impl rule__RelativeNamespace_Impl__Group_2__3 ; + public final void rule__RelativeNamespace_Impl__Group_2__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:7993:1: ( rule__Node__Group_10__3__Impl rule__Node__Group_10__4 ) - // InternalRos.g:7994:2: rule__Node__Group_10__3__Impl rule__Node__Group_10__4 + // InternalRosParser.g:7923:1: ( rule__RelativeNamespace_Impl__Group_2__2__Impl rule__RelativeNamespace_Impl__Group_2__3 ) + // InternalRosParser.g:7924:2: rule__RelativeNamespace_Impl__Group_2__2__Impl rule__RelativeNamespace_Impl__Group_2__3 { pushFollow(FOLLOW_13); - rule__Node__Group_10__3__Impl(); + rule__RelativeNamespace_Impl__Group_2__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_10__4(); + rule__RelativeNamespace_Impl__Group_2__3(); state._fsp--; @@ -24602,40 +23953,40 @@ public final void rule__Node__Group_10__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_10__3" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__2" - // $ANTLR start "rule__Node__Group_10__3__Impl" - // InternalRos.g:8001:1: rule__Node__Group_10__3__Impl : ( ( rule__Node__Group_10_3__0 )* ) ; - public final void rule__Node__Group_10__3__Impl() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__2__Impl" + // InternalRosParser.g:7931:1: rule__RelativeNamespace_Impl__Group_2__2__Impl : ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) ; + public final void rule__RelativeNamespace_Impl__Group_2__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8005:1: ( ( ( rule__Node__Group_10_3__0 )* ) ) - // InternalRos.g:8006:1: ( ( rule__Node__Group_10_3__0 )* ) + // InternalRosParser.g:7935:1: ( ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) ) + // InternalRosParser.g:7936:1: ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) { - // InternalRos.g:8006:1: ( ( rule__Node__Group_10_3__0 )* ) - // InternalRos.g:8007:2: ( rule__Node__Group_10_3__0 )* + // InternalRosParser.g:7936:1: ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) + // InternalRosParser.g:7937:2: ( rule__RelativeNamespace_Impl__Group_2_2__0 )* { - before(grammarAccess.getNodeAccess().getGroup_10_3()); - // InternalRos.g:8008:2: ( rule__Node__Group_10_3__0 )* - loop56: + before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); + // InternalRosParser.g:7938:2: ( rule__RelativeNamespace_Impl__Group_2_2__0 )* + loop44: do { - int alt56=2; - int LA56_0 = input.LA(1); + int alt44=2; + int LA44_0 = input.LA(1); - if ( (LA56_0==43) ) { - alt56=1; + if ( (LA44_0==Comma) ) { + alt44=1; } - switch (alt56) { + switch (alt44) { case 1 : - // InternalRos.g:8008:3: rule__Node__Group_10_3__0 + // InternalRosParser.g:7938:3: rule__RelativeNamespace_Impl__Group_2_2__0 { - pushFollow(FOLLOW_7); - rule__Node__Group_10_3__0(); + pushFollow(FOLLOW_14); + rule__RelativeNamespace_Impl__Group_2_2__0(); state._fsp--; @@ -24644,11 +23995,11 @@ public final void rule__Node__Group_10__3__Impl() throws RecognitionException { break; default : - break loop56; + break loop44; } } while (true); - after(grammarAccess.getNodeAccess().getGroup_10_3()); + after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); } @@ -24667,21 +24018,21 @@ public final void rule__Node__Group_10__3__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_10__3__Impl" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__2__Impl" - // $ANTLR start "rule__Node__Group_10__4" - // InternalRos.g:8016:1: rule__Node__Group_10__4 : rule__Node__Group_10__4__Impl ; - public final void rule__Node__Group_10__4() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__3" + // InternalRosParser.g:7946:1: rule__RelativeNamespace_Impl__Group_2__3 : rule__RelativeNamespace_Impl__Group_2__3__Impl ; + public final void rule__RelativeNamespace_Impl__Group_2__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8020:1: ( rule__Node__Group_10__4__Impl ) - // InternalRos.g:8021:2: rule__Node__Group_10__4__Impl + // InternalRosParser.g:7950:1: ( rule__RelativeNamespace_Impl__Group_2__3__Impl ) + // InternalRosParser.g:7951:2: rule__RelativeNamespace_Impl__Group_2__3__Impl { pushFollow(FOLLOW_2); - rule__Node__Group_10__4__Impl(); + rule__RelativeNamespace_Impl__Group_2__3__Impl(); state._fsp--; @@ -24700,25 +24051,25 @@ public final void rule__Node__Group_10__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_10__4" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__3" - // $ANTLR start "rule__Node__Group_10__4__Impl" - // InternalRos.g:8027:1: rule__Node__Group_10__4__Impl : ( '}' ) ; - public final void rule__Node__Group_10__4__Impl() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__3__Impl" + // InternalRosParser.g:7957:1: rule__RelativeNamespace_Impl__Group_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__RelativeNamespace_Impl__Group_2__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8031:1: ( ( '}' ) ) - // InternalRos.g:8032:1: ( '}' ) + // InternalRosParser.g:7961:1: ( ( RightSquareBracket ) ) + // InternalRosParser.g:7962:1: ( RightSquareBracket ) { - // InternalRos.g:8032:1: ( '}' ) - // InternalRos.g:8033:2: '}' + // InternalRosParser.g:7962:1: ( RightSquareBracket ) + // InternalRosParser.g:7963:2: RightSquareBracket { - before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_10_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_10_4()); + before(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); } @@ -24737,26 +24088,26 @@ public final void rule__Node__Group_10__4__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_10__4__Impl" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__3__Impl" - // $ANTLR start "rule__Node__Group_10_3__0" - // InternalRos.g:8043:1: rule__Node__Group_10_3__0 : rule__Node__Group_10_3__0__Impl rule__Node__Group_10_3__1 ; - public final void rule__Node__Group_10_3__0() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__0" + // InternalRosParser.g:7973:1: rule__RelativeNamespace_Impl__Group_2_2__0 : rule__RelativeNamespace_Impl__Group_2_2__0__Impl rule__RelativeNamespace_Impl__Group_2_2__1 ; + public final void rule__RelativeNamespace_Impl__Group_2_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8047:1: ( rule__Node__Group_10_3__0__Impl rule__Node__Group_10_3__1 ) - // InternalRos.g:8048:2: rule__Node__Group_10_3__0__Impl rule__Node__Group_10_3__1 + // InternalRosParser.g:7977:1: ( rule__RelativeNamespace_Impl__Group_2_2__0__Impl rule__RelativeNamespace_Impl__Group_2_2__1 ) + // InternalRosParser.g:7978:2: rule__RelativeNamespace_Impl__Group_2_2__0__Impl rule__RelativeNamespace_Impl__Group_2_2__1 { - pushFollow(FOLLOW_37); - rule__Node__Group_10_3__0__Impl(); + pushFollow(FOLLOW_38); + rule__RelativeNamespace_Impl__Group_2_2__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Node__Group_10_3__1(); + rule__RelativeNamespace_Impl__Group_2_2__1(); state._fsp--; @@ -24775,25 +24126,25 @@ public final void rule__Node__Group_10_3__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_10_3__0" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__0" - // $ANTLR start "rule__Node__Group_10_3__0__Impl" - // InternalRos.g:8055:1: rule__Node__Group_10_3__0__Impl : ( ',' ) ; - public final void rule__Node__Group_10_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__0__Impl" + // InternalRosParser.g:7985:1: rule__RelativeNamespace_Impl__Group_2_2__0__Impl : ( Comma ) ; + public final void rule__RelativeNamespace_Impl__Group_2_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8059:1: ( ( ',' ) ) - // InternalRos.g:8060:1: ( ',' ) + // InternalRosParser.g:7989:1: ( ( Comma ) ) + // InternalRosParser.g:7990:1: ( Comma ) { - // InternalRos.g:8060:1: ( ',' ) - // InternalRos.g:8061:2: ',' + // InternalRosParser.g:7990:1: ( Comma ) + // InternalRosParser.g:7991:2: Comma { - before(grammarAccess.getNodeAccess().getCommaKeyword_10_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getNodeAccess().getCommaKeyword_10_3_0()); + before(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); } @@ -24812,21 +24163,21 @@ public final void rule__Node__Group_10_3__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Node__Group_10_3__0__Impl" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__0__Impl" - // $ANTLR start "rule__Node__Group_10_3__1" - // InternalRos.g:8070:1: rule__Node__Group_10_3__1 : rule__Node__Group_10_3__1__Impl ; - public final void rule__Node__Group_10_3__1() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__1" + // InternalRosParser.g:8000:1: rule__RelativeNamespace_Impl__Group_2_2__1 : rule__RelativeNamespace_Impl__Group_2_2__1__Impl ; + public final void rule__RelativeNamespace_Impl__Group_2_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8074:1: ( rule__Node__Group_10_3__1__Impl ) - // InternalRos.g:8075:2: rule__Node__Group_10_3__1__Impl + // InternalRosParser.g:8004:1: ( rule__RelativeNamespace_Impl__Group_2_2__1__Impl ) + // InternalRosParser.g:8005:2: rule__RelativeNamespace_Impl__Group_2_2__1__Impl { pushFollow(FOLLOW_2); - rule__Node__Group_10_3__1__Impl(); + rule__RelativeNamespace_Impl__Group_2_2__1__Impl(); state._fsp--; @@ -24845,35 +24196,35 @@ public final void rule__Node__Group_10_3__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__Group_10_3__1" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__1" - // $ANTLR start "rule__Node__Group_10_3__1__Impl" - // InternalRos.g:8081:1: rule__Node__Group_10_3__1__Impl : ( ( rule__Node__ParameterAssignment_10_3_1 ) ) ; - public final void rule__Node__Group_10_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__1__Impl" + // InternalRosParser.g:8011:1: rule__RelativeNamespace_Impl__Group_2_2__1__Impl : ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) ; + public final void rule__RelativeNamespace_Impl__Group_2_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8085:1: ( ( ( rule__Node__ParameterAssignment_10_3_1 ) ) ) - // InternalRos.g:8086:1: ( ( rule__Node__ParameterAssignment_10_3_1 ) ) + // InternalRosParser.g:8015:1: ( ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) ) + // InternalRosParser.g:8016:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) { - // InternalRos.g:8086:1: ( ( rule__Node__ParameterAssignment_10_3_1 ) ) - // InternalRos.g:8087:2: ( rule__Node__ParameterAssignment_10_3_1 ) + // InternalRosParser.g:8016:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) + // InternalRosParser.g:8017:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) { - before(grammarAccess.getNodeAccess().getParameterAssignment_10_3_1()); - // InternalRos.g:8088:2: ( rule__Node__ParameterAssignment_10_3_1 ) - // InternalRos.g:8088:3: rule__Node__ParameterAssignment_10_3_1 + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); + // InternalRosParser.g:8018:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) + // InternalRosParser.g:8018:3: rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 { pushFollow(FOLLOW_2); - rule__Node__ParameterAssignment_10_3_1(); + rule__RelativeNamespace_Impl__PartsAssignment_2_2_1(); state._fsp--; } - after(grammarAccess.getNodeAccess().getParameterAssignment_10_3_1()); + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); } @@ -24892,26 +24243,26 @@ public final void rule__Node__Group_10_3__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Node__Group_10_3__1__Impl" + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__1__Impl" - // $ANTLR start "rule__ServiceServer__Group__0" - // InternalRos.g:8097:1: rule__ServiceServer__Group__0 : rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 ; - public final void rule__ServiceServer__Group__0() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group__0" + // InternalRosParser.g:8027:1: rule__PrivateNamespace__Group__0 : rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 ; + public final void rule__PrivateNamespace__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8101:1: ( rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 ) - // InternalRos.g:8102:2: rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 + // InternalRosParser.g:8031:1: ( rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 ) + // InternalRosParser.g:8032:2: rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 { - pushFollow(FOLLOW_4); - rule__ServiceServer__Group__0__Impl(); + pushFollow(FOLLOW_36); + rule__PrivateNamespace__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceServer__Group__1(); + rule__PrivateNamespace__Group__1(); state._fsp--; @@ -24930,100 +24281,29 @@ public final void rule__ServiceServer__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceServer__Group__0" + // $ANTLR end "rule__PrivateNamespace__Group__0" - // $ANTLR start "rule__ServiceServer__Group__0__Impl" - // InternalRos.g:8109:1: rule__ServiceServer__Group__0__Impl : ( 'ServiceServer' ) ; - public final void rule__ServiceServer__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group__0__Impl" + // InternalRosParser.g:8039:1: rule__PrivateNamespace__Group__0__Impl : ( () ) ; + public final void rule__PrivateNamespace__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8113:1: ( ( 'ServiceServer' ) ) - // InternalRos.g:8114:1: ( 'ServiceServer' ) + // InternalRosParser.g:8043:1: ( ( () ) ) + // InternalRosParser.g:8044:1: ( () ) { - // InternalRos.g:8114:1: ( 'ServiceServer' ) - // InternalRos.g:8115:2: 'ServiceServer' + // InternalRosParser.g:8044:1: ( () ) + // InternalRosParser.g:8045:2: () { - before(grammarAccess.getServiceServerAccess().getServiceServerKeyword_0()); - match(input,64,FOLLOW_2); - after(grammarAccess.getServiceServerAccess().getServiceServerKeyword_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceServer__Group__0__Impl" - - - // $ANTLR start "rule__ServiceServer__Group__1" - // InternalRos.g:8124:1: rule__ServiceServer__Group__1 : rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 ; - public final void rule__ServiceServer__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:8128:1: ( rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 ) - // InternalRos.g:8129:2: rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 + before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); + // InternalRosParser.g:8046:2: () + // InternalRosParser.g:8046:3: { - pushFollow(FOLLOW_29); - rule__ServiceServer__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ServiceServer__Group__2(); - - state._fsp--; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceServer__Group__1" - - - // $ANTLR start "rule__ServiceServer__Group__1__Impl" - // InternalRos.g:8136:1: rule__ServiceServer__Group__1__Impl : ( '{' ) ; - public final void rule__ServiceServer__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:8140:1: ( ( '{' ) ) - // InternalRos.g:8141:1: ( '{' ) - { - // InternalRos.g:8141:1: ( '{' ) - // InternalRos.g:8142:2: '{' - { - before(grammarAccess.getServiceServerAccess().getLeftCurlyBracketKeyword_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getServiceServerAccess().getLeftCurlyBracketKeyword_1()); + after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); } @@ -25031,10 +24311,6 @@ public final void rule__ServiceServer__Group__1__Impl() throws RecognitionExcept } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -25042,26 +24318,26 @@ public final void rule__ServiceServer__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceServer__Group__1__Impl" + // $ANTLR end "rule__PrivateNamespace__Group__0__Impl" - // $ANTLR start "rule__ServiceServer__Group__2" - // InternalRos.g:8151:1: rule__ServiceServer__Group__2 : rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 ; - public final void rule__ServiceServer__Group__2() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group__1" + // InternalRosParser.g:8054:1: rule__PrivateNamespace__Group__1 : rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 ; + public final void rule__PrivateNamespace__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8155:1: ( rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 ) - // InternalRos.g:8156:2: rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 + // InternalRosParser.g:8058:1: ( rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 ) + // InternalRosParser.g:8059:2: rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 { - pushFollow(FOLLOW_10); - rule__ServiceServer__Group__2__Impl(); + pushFollow(FOLLOW_11); + rule__PrivateNamespace__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceServer__Group__3(); + rule__PrivateNamespace__Group__2(); state._fsp--; @@ -25080,25 +24356,25 @@ public final void rule__ServiceServer__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceServer__Group__2" + // $ANTLR end "rule__PrivateNamespace__Group__1" - // $ANTLR start "rule__ServiceServer__Group__2__Impl" - // InternalRos.g:8163:1: rule__ServiceServer__Group__2__Impl : ( 'name' ) ; - public final void rule__ServiceServer__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group__1__Impl" + // InternalRosParser.g:8066:1: rule__PrivateNamespace__Group__1__Impl : ( PrivateNamespace ) ; + public final void rule__PrivateNamespace__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8167:1: ( ( 'name' ) ) - // InternalRos.g:8168:1: ( 'name' ) + // InternalRosParser.g:8070:1: ( ( PrivateNamespace ) ) + // InternalRosParser.g:8071:1: ( PrivateNamespace ) { - // InternalRos.g:8168:1: ( 'name' ) - // InternalRos.g:8169:2: 'name' + // InternalRosParser.g:8071:1: ( PrivateNamespace ) + // InternalRosParser.g:8072:2: PrivateNamespace { - before(grammarAccess.getServiceServerAccess().getNameKeyword_2()); - match(input,33,FOLLOW_2); - after(grammarAccess.getServiceServerAccess().getNameKeyword_2()); + before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); + match(input,PrivateNamespace,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); } @@ -25117,26 +24393,21 @@ public final void rule__ServiceServer__Group__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceServer__Group__2__Impl" + // $ANTLR end "rule__PrivateNamespace__Group__1__Impl" - // $ANTLR start "rule__ServiceServer__Group__3" - // InternalRos.g:8178:1: rule__ServiceServer__Group__3 : rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 ; - public final void rule__ServiceServer__Group__3() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group__2" + // InternalRosParser.g:8081:1: rule__PrivateNamespace__Group__2 : rule__PrivateNamespace__Group__2__Impl ; + public final void rule__PrivateNamespace__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8182:1: ( rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 ) - // InternalRos.g:8183:2: rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 + // InternalRosParser.g:8085:1: ( rule__PrivateNamespace__Group__2__Impl ) + // InternalRosParser.g:8086:2: rule__PrivateNamespace__Group__2__Impl { - pushFollow(FOLLOW_38); - rule__ServiceServer__Group__3__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ServiceServer__Group__4(); + rule__PrivateNamespace__Group__2__Impl(); state._fsp--; @@ -25155,35 +24426,46 @@ public final void rule__ServiceServer__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceServer__Group__3" + // $ANTLR end "rule__PrivateNamespace__Group__2" - // $ANTLR start "rule__ServiceServer__Group__3__Impl" - // InternalRos.g:8190:1: rule__ServiceServer__Group__3__Impl : ( ( rule__ServiceServer__NameAssignment_3 ) ) ; - public final void rule__ServiceServer__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group__2__Impl" + // InternalRosParser.g:8092:1: rule__PrivateNamespace__Group__2__Impl : ( ( rule__PrivateNamespace__Group_2__0 )? ) ; + public final void rule__PrivateNamespace__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8194:1: ( ( ( rule__ServiceServer__NameAssignment_3 ) ) ) - // InternalRos.g:8195:1: ( ( rule__ServiceServer__NameAssignment_3 ) ) - { - // InternalRos.g:8195:1: ( ( rule__ServiceServer__NameAssignment_3 ) ) - // InternalRos.g:8196:2: ( rule__ServiceServer__NameAssignment_3 ) + // InternalRosParser.g:8096:1: ( ( ( rule__PrivateNamespace__Group_2__0 )? ) ) + // InternalRosParser.g:8097:1: ( ( rule__PrivateNamespace__Group_2__0 )? ) { - before(grammarAccess.getServiceServerAccess().getNameAssignment_3()); - // InternalRos.g:8197:2: ( rule__ServiceServer__NameAssignment_3 ) - // InternalRos.g:8197:3: rule__ServiceServer__NameAssignment_3 + // InternalRosParser.g:8097:1: ( ( rule__PrivateNamespace__Group_2__0 )? ) + // InternalRosParser.g:8098:2: ( rule__PrivateNamespace__Group_2__0 )? { - pushFollow(FOLLOW_2); - rule__ServiceServer__NameAssignment_3(); + before(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); + // InternalRosParser.g:8099:2: ( rule__PrivateNamespace__Group_2__0 )? + int alt45=2; + int LA45_0 = input.LA(1); - state._fsp--; + if ( (LA45_0==LeftSquareBracket) ) { + alt45=1; + } + switch (alt45) { + case 1 : + // InternalRosParser.g:8099:3: rule__PrivateNamespace__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2__0(); + state._fsp--; + + + } + break; } - after(grammarAccess.getServiceServerAccess().getNameAssignment_3()); + after(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); } @@ -25202,26 +24484,26 @@ public final void rule__ServiceServer__Group__3__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceServer__Group__3__Impl" + // $ANTLR end "rule__PrivateNamespace__Group__2__Impl" - // $ANTLR start "rule__ServiceServer__Group__4" - // InternalRos.g:8205:1: rule__ServiceServer__Group__4 : rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 ; - public final void rule__ServiceServer__Group__4() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2__0" + // InternalRosParser.g:8108:1: rule__PrivateNamespace__Group_2__0 : rule__PrivateNamespace__Group_2__0__Impl rule__PrivateNamespace__Group_2__1 ; + public final void rule__PrivateNamespace__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8209:1: ( rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 ) - // InternalRos.g:8210:2: rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 + // InternalRosParser.g:8112:1: ( rule__PrivateNamespace__Group_2__0__Impl rule__PrivateNamespace__Group_2__1 ) + // InternalRosParser.g:8113:2: rule__PrivateNamespace__Group_2__0__Impl rule__PrivateNamespace__Group_2__1 { - pushFollow(FOLLOW_10); - rule__ServiceServer__Group__4__Impl(); + pushFollow(FOLLOW_38); + rule__PrivateNamespace__Group_2__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceServer__Group__5(); + rule__PrivateNamespace__Group_2__1(); state._fsp--; @@ -25240,25 +24522,25 @@ public final void rule__ServiceServer__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceServer__Group__4" + // $ANTLR end "rule__PrivateNamespace__Group_2__0" - // $ANTLR start "rule__ServiceServer__Group__4__Impl" - // InternalRos.g:8217:1: rule__ServiceServer__Group__4__Impl : ( 'service' ) ; - public final void rule__ServiceServer__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2__0__Impl" + // InternalRosParser.g:8120:1: rule__PrivateNamespace__Group_2__0__Impl : ( LeftSquareBracket ) ; + public final void rule__PrivateNamespace__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8221:1: ( ( 'service' ) ) - // InternalRos.g:8222:1: ( 'service' ) + // InternalRosParser.g:8124:1: ( ( LeftSquareBracket ) ) + // InternalRosParser.g:8125:1: ( LeftSquareBracket ) { - // InternalRos.g:8222:1: ( 'service' ) - // InternalRos.g:8223:2: 'service' + // InternalRosParser.g:8125:1: ( LeftSquareBracket ) + // InternalRosParser.g:8126:2: LeftSquareBracket { - before(grammarAccess.getServiceServerAccess().getServiceKeyword_4()); - match(input,35,FOLLOW_2); - after(grammarAccess.getServiceServerAccess().getServiceKeyword_4()); + before(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } @@ -25277,26 +24559,26 @@ public final void rule__ServiceServer__Group__4__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceServer__Group__4__Impl" + // $ANTLR end "rule__PrivateNamespace__Group_2__0__Impl" - // $ANTLR start "rule__ServiceServer__Group__5" - // InternalRos.g:8232:1: rule__ServiceServer__Group__5 : rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 ; - public final void rule__ServiceServer__Group__5() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2__1" + // InternalRosParser.g:8135:1: rule__PrivateNamespace__Group_2__1 : rule__PrivateNamespace__Group_2__1__Impl rule__PrivateNamespace__Group_2__2 ; + public final void rule__PrivateNamespace__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8236:1: ( rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 ) - // InternalRos.g:8237:2: rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 + // InternalRosParser.g:8139:1: ( rule__PrivateNamespace__Group_2__1__Impl rule__PrivateNamespace__Group_2__2 ) + // InternalRosParser.g:8140:2: rule__PrivateNamespace__Group_2__1__Impl rule__PrivateNamespace__Group_2__2 { - pushFollow(FOLLOW_39); - rule__ServiceServer__Group__5__Impl(); + pushFollow(FOLLOW_13); + rule__PrivateNamespace__Group_2__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceServer__Group__6(); + rule__PrivateNamespace__Group_2__2(); state._fsp--; @@ -25315,35 +24597,35 @@ public final void rule__ServiceServer__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceServer__Group__5" + // $ANTLR end "rule__PrivateNamespace__Group_2__1" - // $ANTLR start "rule__ServiceServer__Group__5__Impl" - // InternalRos.g:8244:1: rule__ServiceServer__Group__5__Impl : ( ( rule__ServiceServer__ServiceAssignment_5 ) ) ; - public final void rule__ServiceServer__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2__1__Impl" + // InternalRosParser.g:8147:1: rule__PrivateNamespace__Group_2__1__Impl : ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) ; + public final void rule__PrivateNamespace__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8248:1: ( ( ( rule__ServiceServer__ServiceAssignment_5 ) ) ) - // InternalRos.g:8249:1: ( ( rule__ServiceServer__ServiceAssignment_5 ) ) + // InternalRosParser.g:8151:1: ( ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) ) + // InternalRosParser.g:8152:1: ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) { - // InternalRos.g:8249:1: ( ( rule__ServiceServer__ServiceAssignment_5 ) ) - // InternalRos.g:8250:2: ( rule__ServiceServer__ServiceAssignment_5 ) + // InternalRosParser.g:8152:1: ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) + // InternalRosParser.g:8153:2: ( rule__PrivateNamespace__PartsAssignment_2_1 ) { - before(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); - // InternalRos.g:8251:2: ( rule__ServiceServer__ServiceAssignment_5 ) - // InternalRos.g:8251:3: rule__ServiceServer__ServiceAssignment_5 + before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); + // InternalRosParser.g:8154:2: ( rule__PrivateNamespace__PartsAssignment_2_1 ) + // InternalRosParser.g:8154:3: rule__PrivateNamespace__PartsAssignment_2_1 { pushFollow(FOLLOW_2); - rule__ServiceServer__ServiceAssignment_5(); + rule__PrivateNamespace__PartsAssignment_2_1(); state._fsp--; } - after(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); + after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); } @@ -25362,26 +24644,26 @@ public final void rule__ServiceServer__Group__5__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceServer__Group__5__Impl" + // $ANTLR end "rule__PrivateNamespace__Group_2__1__Impl" - // $ANTLR start "rule__ServiceServer__Group__6" - // InternalRos.g:8259:1: rule__ServiceServer__Group__6 : rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 ; - public final void rule__ServiceServer__Group__6() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2__2" + // InternalRosParser.g:8162:1: rule__PrivateNamespace__Group_2__2 : rule__PrivateNamespace__Group_2__2__Impl rule__PrivateNamespace__Group_2__3 ; + public final void rule__PrivateNamespace__Group_2__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8263:1: ( rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 ) - // InternalRos.g:8264:2: rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 + // InternalRosParser.g:8166:1: ( rule__PrivateNamespace__Group_2__2__Impl rule__PrivateNamespace__Group_2__3 ) + // InternalRosParser.g:8167:2: rule__PrivateNamespace__Group_2__2__Impl rule__PrivateNamespace__Group_2__3 { - pushFollow(FOLLOW_39); - rule__ServiceServer__Group__6__Impl(); + pushFollow(FOLLOW_13); + rule__PrivateNamespace__Group_2__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceServer__Group__7(); + rule__PrivateNamespace__Group_2__3(); state._fsp--; @@ -25400,116 +24682,53 @@ public final void rule__ServiceServer__Group__6() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceServer__Group__6" + // $ANTLR end "rule__PrivateNamespace__Group_2__2" - // $ANTLR start "rule__ServiceServer__Group__6__Impl" - // InternalRos.g:8271:1: rule__ServiceServer__Group__6__Impl : ( ( rule__ServiceServer__Group_6__0 )? ) ; - public final void rule__ServiceServer__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2__2__Impl" + // InternalRosParser.g:8174:1: rule__PrivateNamespace__Group_2__2__Impl : ( ( rule__PrivateNamespace__Group_2_2__0 )* ) ; + public final void rule__PrivateNamespace__Group_2__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8275:1: ( ( ( rule__ServiceServer__Group_6__0 )? ) ) - // InternalRos.g:8276:1: ( ( rule__ServiceServer__Group_6__0 )? ) + // InternalRosParser.g:8178:1: ( ( ( rule__PrivateNamespace__Group_2_2__0 )* ) ) + // InternalRosParser.g:8179:1: ( ( rule__PrivateNamespace__Group_2_2__0 )* ) { - // InternalRos.g:8276:1: ( ( rule__ServiceServer__Group_6__0 )? ) - // InternalRos.g:8277:2: ( rule__ServiceServer__Group_6__0 )? - { - before(grammarAccess.getServiceServerAccess().getGroup_6()); - // InternalRos.g:8278:2: ( rule__ServiceServer__Group_6__0 )? - int alt57=2; - int LA57_0 = input.LA(1); - - if ( (LA57_0==65) ) { - alt57=1; - } - switch (alt57) { - case 1 : - // InternalRos.g:8278:3: rule__ServiceServer__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__ServiceServer__Group_6__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getServiceServerAccess().getGroup_6()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceServer__Group__6__Impl" - - - // $ANTLR start "rule__ServiceServer__Group__7" - // InternalRos.g:8286:1: rule__ServiceServer__Group__7 : rule__ServiceServer__Group__7__Impl ; - public final void rule__ServiceServer__Group__7() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:8290:1: ( rule__ServiceServer__Group__7__Impl ) - // InternalRos.g:8291:2: rule__ServiceServer__Group__7__Impl + // InternalRosParser.g:8179:1: ( ( rule__PrivateNamespace__Group_2_2__0 )* ) + // InternalRosParser.g:8180:2: ( rule__PrivateNamespace__Group_2_2__0 )* { - pushFollow(FOLLOW_2); - rule__ServiceServer__Group__7__Impl(); - - state._fsp--; + before(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); + // InternalRosParser.g:8181:2: ( rule__PrivateNamespace__Group_2_2__0 )* + loop46: + do { + int alt46=2; + int LA46_0 = input.LA(1); + if ( (LA46_0==Comma) ) { + alt46=1; + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt46) { + case 1 : + // InternalRosParser.g:8181:3: rule__PrivateNamespace__Group_2_2__0 + { + pushFollow(FOLLOW_14); + rule__PrivateNamespace__Group_2_2__0(); - restoreStackSize(stackSize); + state._fsp--; - } - return ; - } - // $ANTLR end "rule__ServiceServer__Group__7" + } + break; - // $ANTLR start "rule__ServiceServer__Group__7__Impl" - // InternalRos.g:8297:1: rule__ServiceServer__Group__7__Impl : ( '}' ) ; - public final void rule__ServiceServer__Group__7__Impl() throws RecognitionException { + default : + break loop46; + } + } while (true); - int stackSize = keepStackSize(); - - try { - // InternalRos.g:8301:1: ( ( '}' ) ) - // InternalRos.g:8302:1: ( '}' ) - { - // InternalRos.g:8302:1: ( '}' ) - // InternalRos.g:8303:2: '}' - { - before(grammarAccess.getServiceServerAccess().getRightCurlyBracketKeyword_7()); - match(input,42,FOLLOW_2); - after(grammarAccess.getServiceServerAccess().getRightCurlyBracketKeyword_7()); + after(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); } @@ -25528,26 +24747,21 @@ public final void rule__ServiceServer__Group__7__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceServer__Group__7__Impl" + // $ANTLR end "rule__PrivateNamespace__Group_2__2__Impl" - // $ANTLR start "rule__ServiceServer__Group_6__0" - // InternalRos.g:8313:1: rule__ServiceServer__Group_6__0 : rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 ; - public final void rule__ServiceServer__Group_6__0() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2__3" + // InternalRosParser.g:8189:1: rule__PrivateNamespace__Group_2__3 : rule__PrivateNamespace__Group_2__3__Impl ; + public final void rule__PrivateNamespace__Group_2__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8317:1: ( rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 ) - // InternalRos.g:8318:2: rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 + // InternalRosParser.g:8193:1: ( rule__PrivateNamespace__Group_2__3__Impl ) + // InternalRosParser.g:8194:2: rule__PrivateNamespace__Group_2__3__Impl { - pushFollow(FOLLOW_40); - rule__ServiceServer__Group_6__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ServiceServer__Group_6__1(); + rule__PrivateNamespace__Group_2__3__Impl(); state._fsp--; @@ -25566,25 +24780,25 @@ public final void rule__ServiceServer__Group_6__0() throws RecognitionException } return ; } - // $ANTLR end "rule__ServiceServer__Group_6__0" + // $ANTLR end "rule__PrivateNamespace__Group_2__3" - // $ANTLR start "rule__ServiceServer__Group_6__0__Impl" - // InternalRos.g:8325:1: rule__ServiceServer__Group_6__0__Impl : ( 'namespace' ) ; - public final void rule__ServiceServer__Group_6__0__Impl() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2__3__Impl" + // InternalRosParser.g:8200:1: rule__PrivateNamespace__Group_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__PrivateNamespace__Group_2__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8329:1: ( ( 'namespace' ) ) - // InternalRos.g:8330:1: ( 'namespace' ) + // InternalRosParser.g:8204:1: ( ( RightSquareBracket ) ) + // InternalRosParser.g:8205:1: ( RightSquareBracket ) { - // InternalRos.g:8330:1: ( 'namespace' ) - // InternalRos.g:8331:2: 'namespace' + // InternalRosParser.g:8205:1: ( RightSquareBracket ) + // InternalRosParser.g:8206:2: RightSquareBracket { - before(grammarAccess.getServiceServerAccess().getNamespaceKeyword_6_0()); - match(input,65,FOLLOW_2); - after(grammarAccess.getServiceServerAccess().getNamespaceKeyword_6_0()); + before(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); } @@ -25603,21 +24817,26 @@ public final void rule__ServiceServer__Group_6__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ServiceServer__Group_6__0__Impl" + // $ANTLR end "rule__PrivateNamespace__Group_2__3__Impl" - // $ANTLR start "rule__ServiceServer__Group_6__1" - // InternalRos.g:8340:1: rule__ServiceServer__Group_6__1 : rule__ServiceServer__Group_6__1__Impl ; - public final void rule__ServiceServer__Group_6__1() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2_2__0" + // InternalRosParser.g:8216:1: rule__PrivateNamespace__Group_2_2__0 : rule__PrivateNamespace__Group_2_2__0__Impl rule__PrivateNamespace__Group_2_2__1 ; + public final void rule__PrivateNamespace__Group_2_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8344:1: ( rule__ServiceServer__Group_6__1__Impl ) - // InternalRos.g:8345:2: rule__ServiceServer__Group_6__1__Impl + // InternalRosParser.g:8220:1: ( rule__PrivateNamespace__Group_2_2__0__Impl rule__PrivateNamespace__Group_2_2__1 ) + // InternalRosParser.g:8221:2: rule__PrivateNamespace__Group_2_2__0__Impl rule__PrivateNamespace__Group_2_2__1 { + pushFollow(FOLLOW_38); + rule__PrivateNamespace__Group_2_2__0__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__ServiceServer__Group_6__1__Impl(); + rule__PrivateNamespace__Group_2_2__1(); state._fsp--; @@ -25636,35 +24855,25 @@ public final void rule__ServiceServer__Group_6__1() throws RecognitionException } return ; } - // $ANTLR end "rule__ServiceServer__Group_6__1" + // $ANTLR end "rule__PrivateNamespace__Group_2_2__0" - // $ANTLR start "rule__ServiceServer__Group_6__1__Impl" - // InternalRos.g:8351:1: rule__ServiceServer__Group_6__1__Impl : ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) ; - public final void rule__ServiceServer__Group_6__1__Impl() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2_2__0__Impl" + // InternalRosParser.g:8228:1: rule__PrivateNamespace__Group_2_2__0__Impl : ( Comma ) ; + public final void rule__PrivateNamespace__Group_2_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8355:1: ( ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) ) - // InternalRos.g:8356:1: ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) + // InternalRosParser.g:8232:1: ( ( Comma ) ) + // InternalRosParser.g:8233:1: ( Comma ) { - // InternalRos.g:8356:1: ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) - // InternalRos.g:8357:2: ( rule__ServiceServer__NamespaceAssignment_6_1 ) + // InternalRosParser.g:8233:1: ( Comma ) + // InternalRosParser.g:8234:2: Comma { - before(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); - // InternalRos.g:8358:2: ( rule__ServiceServer__NamespaceAssignment_6_1 ) - // InternalRos.g:8358:3: rule__ServiceServer__NamespaceAssignment_6_1 - { - pushFollow(FOLLOW_2); - rule__ServiceServer__NamespaceAssignment_6_1(); - - state._fsp--; - - - } - - after(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); + before(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); } @@ -25683,26 +24892,21 @@ public final void rule__ServiceServer__Group_6__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ServiceServer__Group_6__1__Impl" + // $ANTLR end "rule__PrivateNamespace__Group_2_2__0__Impl" - // $ANTLR start "rule__Publisher__Group__0" - // InternalRos.g:8367:1: rule__Publisher__Group__0 : rule__Publisher__Group__0__Impl rule__Publisher__Group__1 ; - public final void rule__Publisher__Group__0() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2_2__1" + // InternalRosParser.g:8243:1: rule__PrivateNamespace__Group_2_2__1 : rule__PrivateNamespace__Group_2_2__1__Impl ; + public final void rule__PrivateNamespace__Group_2_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8371:1: ( rule__Publisher__Group__0__Impl rule__Publisher__Group__1 ) - // InternalRos.g:8372:2: rule__Publisher__Group__0__Impl rule__Publisher__Group__1 + // InternalRosParser.g:8247:1: ( rule__PrivateNamespace__Group_2_2__1__Impl ) + // InternalRosParser.g:8248:2: rule__PrivateNamespace__Group_2_2__1__Impl { - pushFollow(FOLLOW_4); - rule__Publisher__Group__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Publisher__Group__1(); + rule__PrivateNamespace__Group_2_2__1__Impl(); state._fsp--; @@ -25721,25 +24925,35 @@ public final void rule__Publisher__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Publisher__Group__0" + // $ANTLR end "rule__PrivateNamespace__Group_2_2__1" - // $ANTLR start "rule__Publisher__Group__0__Impl" - // InternalRos.g:8379:1: rule__Publisher__Group__0__Impl : ( 'Publisher' ) ; - public final void rule__Publisher__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__Group_2_2__1__Impl" + // InternalRosParser.g:8254:1: rule__PrivateNamespace__Group_2_2__1__Impl : ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) ; + public final void rule__PrivateNamespace__Group_2_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8383:1: ( ( 'Publisher' ) ) - // InternalRos.g:8384:1: ( 'Publisher' ) + // InternalRosParser.g:8258:1: ( ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) ) + // InternalRosParser.g:8259:1: ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) + { + // InternalRosParser.g:8259:1: ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) + // InternalRosParser.g:8260:2: ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) { - // InternalRos.g:8384:1: ( 'Publisher' ) - // InternalRos.g:8385:2: 'Publisher' + before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); + // InternalRosParser.g:8261:2: ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) + // InternalRosParser.g:8261:3: rule__PrivateNamespace__PartsAssignment_2_2_1 { - before(grammarAccess.getPublisherAccess().getPublisherKeyword_0()); - match(input,66,FOLLOW_2); - after(grammarAccess.getPublisherAccess().getPublisherKeyword_0()); + pushFollow(FOLLOW_2); + rule__PrivateNamespace__PartsAssignment_2_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); } @@ -25758,26 +24972,26 @@ public final void rule__Publisher__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Publisher__Group__0__Impl" + // $ANTLR end "rule__PrivateNamespace__Group_2_2__1__Impl" - // $ANTLR start "rule__Publisher__Group__1" - // InternalRos.g:8394:1: rule__Publisher__Group__1 : rule__Publisher__Group__1__Impl rule__Publisher__Group__2 ; - public final void rule__Publisher__Group__1() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__0" + // InternalRosParser.g:8270: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 { - // InternalRos.g:8398:1: ( rule__Publisher__Group__1__Impl rule__Publisher__Group__2 ) - // InternalRos.g:8399:2: rule__Publisher__Group__1__Impl rule__Publisher__Group__2 + // InternalRosParser.g:8274:1: ( rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ) + // InternalRosParser.g:8275:2: rule__Parameter__Group__0__Impl rule__Parameter__Group__1 { - pushFollow(FOLLOW_29); - rule__Publisher__Group__1__Impl(); + pushFollow(FOLLOW_8); + rule__Parameter__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Publisher__Group__2(); + rule__Parameter__Group__1(); state._fsp--; @@ -25796,25 +25010,29 @@ public final void rule__Publisher__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Publisher__Group__1" + // $ANTLR end "rule__Parameter__Group__0" - // $ANTLR start "rule__Publisher__Group__1__Impl" - // InternalRos.g:8406:1: rule__Publisher__Group__1__Impl : ( '{' ) ; - public final void rule__Publisher__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__0__Impl" + // InternalRosParser.g:8282:1: rule__Parameter__Group__0__Impl : ( () ) ; + public final void rule__Parameter__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8410:1: ( ( '{' ) ) - // InternalRos.g:8411:1: ( '{' ) + // InternalRosParser.g:8286:1: ( ( () ) ) + // InternalRosParser.g:8287:1: ( () ) + { + // InternalRosParser.g:8287:1: ( () ) + // InternalRosParser.g:8288:2: () { - // InternalRos.g:8411:1: ( '{' ) - // InternalRos.g:8412:2: '{' + before(grammarAccess.getParameterAccess().getParameterAction_0()); + // InternalRosParser.g:8289:2: () + // InternalRosParser.g:8289:3: { - before(grammarAccess.getPublisherAccess().getLeftCurlyBracketKeyword_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getPublisherAccess().getLeftCurlyBracketKeyword_1()); + } + + after(grammarAccess.getParameterAccess().getParameterAction_0()); } @@ -25822,10 +25040,6 @@ public final void rule__Publisher__Group__1__Impl() throws RecognitionException } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -25833,26 +25047,26 @@ public final void rule__Publisher__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Publisher__Group__1__Impl" + // $ANTLR end "rule__Parameter__Group__0__Impl" - // $ANTLR start "rule__Publisher__Group__2" - // InternalRos.g:8421:1: rule__Publisher__Group__2 : rule__Publisher__Group__2__Impl rule__Publisher__Group__3 ; - public final void rule__Publisher__Group__2() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__1" + // InternalRosParser.g:8297: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 { - // InternalRos.g:8425:1: ( rule__Publisher__Group__2__Impl rule__Publisher__Group__3 ) - // InternalRos.g:8426:2: rule__Publisher__Group__2__Impl rule__Publisher__Group__3 + // InternalRosParser.g:8301:1: ( rule__Parameter__Group__1__Impl rule__Parameter__Group__2 ) + // InternalRosParser.g:8302:2: rule__Parameter__Group__1__Impl rule__Parameter__Group__2 { - pushFollow(FOLLOW_10); - rule__Publisher__Group__2__Impl(); + pushFollow(FOLLOW_5); + rule__Parameter__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Publisher__Group__3(); + rule__Parameter__Group__2(); state._fsp--; @@ -25871,25 +25085,35 @@ public final void rule__Publisher__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Publisher__Group__2" + // $ANTLR end "rule__Parameter__Group__1" - // $ANTLR start "rule__Publisher__Group__2__Impl" - // InternalRos.g:8433:1: rule__Publisher__Group__2__Impl : ( 'name' ) ; - public final void rule__Publisher__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__1__Impl" + // InternalRosParser.g:8309:1: rule__Parameter__Group__1__Impl : ( ( rule__Parameter__NameAssignment_1 ) ) ; + public final void rule__Parameter__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8437:1: ( ( 'name' ) ) - // InternalRos.g:8438:1: ( 'name' ) + // InternalRosParser.g:8313:1: ( ( ( rule__Parameter__NameAssignment_1 ) ) ) + // InternalRosParser.g:8314:1: ( ( rule__Parameter__NameAssignment_1 ) ) + { + // InternalRosParser.g:8314:1: ( ( rule__Parameter__NameAssignment_1 ) ) + // InternalRosParser.g:8315:2: ( rule__Parameter__NameAssignment_1 ) { - // InternalRos.g:8438:1: ( 'name' ) - // InternalRos.g:8439:2: 'name' + before(grammarAccess.getParameterAccess().getNameAssignment_1()); + // InternalRosParser.g:8316:2: ( rule__Parameter__NameAssignment_1 ) + // InternalRosParser.g:8316:3: rule__Parameter__NameAssignment_1 { - before(grammarAccess.getPublisherAccess().getNameKeyword_2()); - match(input,33,FOLLOW_2); - after(grammarAccess.getPublisherAccess().getNameKeyword_2()); + pushFollow(FOLLOW_2); + rule__Parameter__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAccess().getNameAssignment_1()); } @@ -25908,26 +25132,26 @@ public final void rule__Publisher__Group__2__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Publisher__Group__2__Impl" + // $ANTLR end "rule__Parameter__Group__1__Impl" - // $ANTLR start "rule__Publisher__Group__3" - // InternalRos.g:8448:1: rule__Publisher__Group__3 : rule__Publisher__Group__3__Impl rule__Publisher__Group__4 ; - public final void rule__Publisher__Group__3() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__2" + // InternalRosParser.g:8324: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 { - // InternalRos.g:8452:1: ( rule__Publisher__Group__3__Impl rule__Publisher__Group__4 ) - // InternalRos.g:8453:2: rule__Publisher__Group__3__Impl rule__Publisher__Group__4 + // InternalRosParser.g:8328:1: ( rule__Parameter__Group__2__Impl rule__Parameter__Group__3 ) + // InternalRosParser.g:8329:2: rule__Parameter__Group__2__Impl rule__Parameter__Group__3 { - pushFollow(FOLLOW_41); - rule__Publisher__Group__3__Impl(); + pushFollow(FOLLOW_6); + rule__Parameter__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Publisher__Group__4(); + rule__Parameter__Group__3(); state._fsp--; @@ -25946,35 +25170,25 @@ public final void rule__Publisher__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Publisher__Group__3" + // $ANTLR end "rule__Parameter__Group__2" - // $ANTLR start "rule__Publisher__Group__3__Impl" - // InternalRos.g:8460:1: rule__Publisher__Group__3__Impl : ( ( rule__Publisher__NameAssignment_3 ) ) ; - public final void rule__Publisher__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__2__Impl" + // InternalRosParser.g:8336:1: rule__Parameter__Group__2__Impl : ( Colon ) ; + public final void rule__Parameter__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8464:1: ( ( ( rule__Publisher__NameAssignment_3 ) ) ) - // InternalRos.g:8465:1: ( ( rule__Publisher__NameAssignment_3 ) ) - { - // InternalRos.g:8465:1: ( ( rule__Publisher__NameAssignment_3 ) ) - // InternalRos.g:8466:2: ( rule__Publisher__NameAssignment_3 ) + // InternalRosParser.g:8340:1: ( ( Colon ) ) + // InternalRosParser.g:8341:1: ( Colon ) { - before(grammarAccess.getPublisherAccess().getNameAssignment_3()); - // InternalRos.g:8467:2: ( rule__Publisher__NameAssignment_3 ) - // InternalRos.g:8467:3: rule__Publisher__NameAssignment_3 + // InternalRosParser.g:8341:1: ( Colon ) + // InternalRosParser.g:8342:2: Colon { - pushFollow(FOLLOW_2); - rule__Publisher__NameAssignment_3(); - - state._fsp--; - - - } - - after(grammarAccess.getPublisherAccess().getNameAssignment_3()); + before(grammarAccess.getParameterAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getParameterAccess().getColonKeyword_2()); } @@ -25993,26 +25207,26 @@ public final void rule__Publisher__Group__3__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Publisher__Group__3__Impl" + // $ANTLR end "rule__Parameter__Group__2__Impl" - // $ANTLR start "rule__Publisher__Group__4" - // InternalRos.g:8475:1: rule__Publisher__Group__4 : rule__Publisher__Group__4__Impl rule__Publisher__Group__5 ; - public final void rule__Publisher__Group__4() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__3" + // InternalRosParser.g:8351: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 { - // InternalRos.g:8479:1: ( rule__Publisher__Group__4__Impl rule__Publisher__Group__5 ) - // InternalRos.g:8480:2: rule__Publisher__Group__4__Impl rule__Publisher__Group__5 + // InternalRosParser.g:8355:1: ( rule__Parameter__Group__3__Impl rule__Parameter__Group__4 ) + // InternalRosParser.g:8356:2: rule__Parameter__Group__3__Impl rule__Parameter__Group__4 { - pushFollow(FOLLOW_10); - rule__Publisher__Group__4__Impl(); + pushFollow(FOLLOW_40); + rule__Parameter__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Publisher__Group__5(); + rule__Parameter__Group__4(); state._fsp--; @@ -26031,25 +25245,25 @@ public final void rule__Publisher__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__Publisher__Group__4" + // $ANTLR end "rule__Parameter__Group__3" - // $ANTLR start "rule__Publisher__Group__4__Impl" - // InternalRos.g:8487:1: rule__Publisher__Group__4__Impl : ( 'message' ) ; - public final void rule__Publisher__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__3__Impl" + // InternalRosParser.g:8363:1: rule__Parameter__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Parameter__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8491:1: ( ( 'message' ) ) - // InternalRos.g:8492:1: ( 'message' ) + // InternalRosParser.g:8367:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:8368:1: ( RULE_BEGIN ) { - // InternalRos.g:8492:1: ( 'message' ) - // InternalRos.g:8493:2: 'message' + // InternalRosParser.g:8368:1: ( RULE_BEGIN ) + // InternalRosParser.g:8369:2: RULE_BEGIN { - before(grammarAccess.getPublisherAccess().getMessageKeyword_4()); - match(input,30,FOLLOW_2); - after(grammarAccess.getPublisherAccess().getMessageKeyword_4()); + before(grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); } @@ -26068,26 +25282,26 @@ public final void rule__Publisher__Group__4__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Publisher__Group__4__Impl" + // $ANTLR end "rule__Parameter__Group__3__Impl" - // $ANTLR start "rule__Publisher__Group__5" - // InternalRos.g:8502:1: rule__Publisher__Group__5 : rule__Publisher__Group__5__Impl rule__Publisher__Group__6 ; - public final void rule__Publisher__Group__5() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__4" + // InternalRosParser.g:8378: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 { - // InternalRos.g:8506:1: ( rule__Publisher__Group__5__Impl rule__Publisher__Group__6 ) - // InternalRos.g:8507:2: rule__Publisher__Group__5__Impl rule__Publisher__Group__6 + // InternalRosParser.g:8382:1: ( rule__Parameter__Group__4__Impl rule__Parameter__Group__5 ) + // InternalRosParser.g:8383:2: rule__Parameter__Group__4__Impl rule__Parameter__Group__5 { - pushFollow(FOLLOW_39); - rule__Publisher__Group__5__Impl(); + pushFollow(FOLLOW_41); + rule__Parameter__Group__4__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Publisher__Group__6(); + rule__Parameter__Group__5(); state._fsp--; @@ -26106,35 +25320,25 @@ public final void rule__Publisher__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__Publisher__Group__5" + // $ANTLR end "rule__Parameter__Group__4" - // $ANTLR start "rule__Publisher__Group__5__Impl" - // InternalRos.g:8514:1: rule__Publisher__Group__5__Impl : ( ( rule__Publisher__MessageAssignment_5 ) ) ; - public final void rule__Publisher__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__4__Impl" + // InternalRosParser.g:8390:1: rule__Parameter__Group__4__Impl : ( Type ) ; + public final void rule__Parameter__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8518:1: ( ( ( rule__Publisher__MessageAssignment_5 ) ) ) - // InternalRos.g:8519:1: ( ( rule__Publisher__MessageAssignment_5 ) ) - { - // InternalRos.g:8519:1: ( ( rule__Publisher__MessageAssignment_5 ) ) - // InternalRos.g:8520:2: ( rule__Publisher__MessageAssignment_5 ) + // InternalRosParser.g:8394:1: ( ( Type ) ) + // InternalRosParser.g:8395:1: ( Type ) { - before(grammarAccess.getPublisherAccess().getMessageAssignment_5()); - // InternalRos.g:8521:2: ( rule__Publisher__MessageAssignment_5 ) - // InternalRos.g:8521:3: rule__Publisher__MessageAssignment_5 + // InternalRosParser.g:8395:1: ( Type ) + // InternalRosParser.g:8396:2: Type { - pushFollow(FOLLOW_2); - rule__Publisher__MessageAssignment_5(); - - state._fsp--; - - - } - - after(grammarAccess.getPublisherAccess().getMessageAssignment_5()); + before(grammarAccess.getParameterAccess().getTypeKeyword_4()); + match(input,Type,FOLLOW_2); + after(grammarAccess.getParameterAccess().getTypeKeyword_4()); } @@ -26153,26 +25357,26 @@ public final void rule__Publisher__Group__5__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Publisher__Group__5__Impl" + // $ANTLR end "rule__Parameter__Group__4__Impl" - // $ANTLR start "rule__Publisher__Group__6" - // InternalRos.g:8529:1: rule__Publisher__Group__6 : rule__Publisher__Group__6__Impl rule__Publisher__Group__7 ; - public final void rule__Publisher__Group__6() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__5" + // InternalRosParser.g:8405:1: rule__Parameter__Group__5 : rule__Parameter__Group__5__Impl rule__Parameter__Group__6 ; + public final void rule__Parameter__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8533:1: ( rule__Publisher__Group__6__Impl rule__Publisher__Group__7 ) - // InternalRos.g:8534:2: rule__Publisher__Group__6__Impl rule__Publisher__Group__7 + // InternalRosParser.g:8409:1: ( rule__Parameter__Group__5__Impl rule__Parameter__Group__6 ) + // InternalRosParser.g:8410:2: rule__Parameter__Group__5__Impl rule__Parameter__Group__6 { - pushFollow(FOLLOW_39); - rule__Publisher__Group__6__Impl(); + pushFollow(FOLLOW_35); + rule__Parameter__Group__5__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Publisher__Group__7(); + rule__Parameter__Group__6(); state._fsp--; @@ -26191,46 +25395,35 @@ public final void rule__Publisher__Group__6() throws RecognitionException { } return ; } - // $ANTLR end "rule__Publisher__Group__6" + // $ANTLR end "rule__Parameter__Group__5" - // $ANTLR start "rule__Publisher__Group__6__Impl" - // InternalRos.g:8541:1: rule__Publisher__Group__6__Impl : ( ( rule__Publisher__Group_6__0 )? ) ; - public final void rule__Publisher__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__5__Impl" + // InternalRosParser.g:8417:1: rule__Parameter__Group__5__Impl : ( ( rule__Parameter__TypeAssignment_5 ) ) ; + public final void rule__Parameter__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8545:1: ( ( ( rule__Publisher__Group_6__0 )? ) ) - // InternalRos.g:8546:1: ( ( rule__Publisher__Group_6__0 )? ) + // InternalRosParser.g:8421:1: ( ( ( rule__Parameter__TypeAssignment_5 ) ) ) + // InternalRosParser.g:8422:1: ( ( rule__Parameter__TypeAssignment_5 ) ) { - // InternalRos.g:8546:1: ( ( rule__Publisher__Group_6__0 )? ) - // InternalRos.g:8547:2: ( rule__Publisher__Group_6__0 )? + // InternalRosParser.g:8422:1: ( ( rule__Parameter__TypeAssignment_5 ) ) + // InternalRosParser.g:8423:2: ( rule__Parameter__TypeAssignment_5 ) { - before(grammarAccess.getPublisherAccess().getGroup_6()); - // InternalRos.g:8548:2: ( rule__Publisher__Group_6__0 )? - int alt58=2; - int LA58_0 = input.LA(1); - - if ( (LA58_0==65) ) { - alt58=1; - } - switch (alt58) { - case 1 : - // InternalRos.g:8548:3: rule__Publisher__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__Publisher__Group_6__0(); - - state._fsp--; + before(grammarAccess.getParameterAccess().getTypeAssignment_5()); + // InternalRosParser.g:8424:2: ( rule__Parameter__TypeAssignment_5 ) + // InternalRosParser.g:8424:3: rule__Parameter__TypeAssignment_5 + { + pushFollow(FOLLOW_2); + rule__Parameter__TypeAssignment_5(); + state._fsp--; - } - break; } - after(grammarAccess.getPublisherAccess().getGroup_6()); + after(grammarAccess.getParameterAccess().getTypeAssignment_5()); } @@ -26249,21 +25442,26 @@ public final void rule__Publisher__Group__6__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Publisher__Group__6__Impl" + // $ANTLR end "rule__Parameter__Group__5__Impl" - // $ANTLR start "rule__Publisher__Group__7" - // InternalRos.g:8556:1: rule__Publisher__Group__7 : rule__Publisher__Group__7__Impl ; - public final void rule__Publisher__Group__7() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__6" + // InternalRosParser.g:8432:1: rule__Parameter__Group__6 : rule__Parameter__Group__6__Impl rule__Parameter__Group__7 ; + public final void rule__Parameter__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8560:1: ( rule__Publisher__Group__7__Impl ) - // InternalRos.g:8561:2: rule__Publisher__Group__7__Impl + // InternalRosParser.g:8436:1: ( rule__Parameter__Group__6__Impl rule__Parameter__Group__7 ) + // InternalRosParser.g:8437:2: rule__Parameter__Group__6__Impl rule__Parameter__Group__7 { + pushFollow(FOLLOW_35); + rule__Parameter__Group__6__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Publisher__Group__7__Impl(); + rule__Parameter__Group__7(); state._fsp--; @@ -26282,25 +25480,46 @@ public final void rule__Publisher__Group__7() throws RecognitionException { } return ; } - // $ANTLR end "rule__Publisher__Group__7" + // $ANTLR end "rule__Parameter__Group__6" - // $ANTLR start "rule__Publisher__Group__7__Impl" - // InternalRos.g:8567:1: rule__Publisher__Group__7__Impl : ( '}' ) ; - public final void rule__Publisher__Group__7__Impl() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__6__Impl" + // InternalRosParser.g:8444:1: rule__Parameter__Group__6__Impl : ( ( rule__Parameter__Group_6__0 )? ) ; + public final void rule__Parameter__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8571:1: ( ( '}' ) ) - // InternalRos.g:8572:1: ( '}' ) + // InternalRosParser.g:8448:1: ( ( ( rule__Parameter__Group_6__0 )? ) ) + // InternalRosParser.g:8449:1: ( ( rule__Parameter__Group_6__0 )? ) { - // InternalRos.g:8572:1: ( '}' ) - // InternalRos.g:8573:2: '}' + // InternalRosParser.g:8449:1: ( ( rule__Parameter__Group_6__0 )? ) + // InternalRosParser.g:8450:2: ( rule__Parameter__Group_6__0 )? { - before(grammarAccess.getPublisherAccess().getRightCurlyBracketKeyword_7()); - match(input,42,FOLLOW_2); - after(grammarAccess.getPublisherAccess().getRightCurlyBracketKeyword_7()); + before(grammarAccess.getParameterAccess().getGroup_6()); + // InternalRosParser.g:8451:2: ( rule__Parameter__Group_6__0 )? + int alt47=2; + int LA47_0 = input.LA(1); + + if ( (LA47_0==Ns) ) { + alt47=1; + } + switch (alt47) { + case 1 : + // InternalRosParser.g:8451:3: rule__Parameter__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Parameter__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterAccess().getGroup_6()); } @@ -26319,26 +25538,26 @@ public final void rule__Publisher__Group__7__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Publisher__Group__7__Impl" + // $ANTLR end "rule__Parameter__Group__6__Impl" - // $ANTLR start "rule__Publisher__Group_6__0" - // InternalRos.g:8583:1: rule__Publisher__Group_6__0 : rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 ; - public final void rule__Publisher__Group_6__0() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__7" + // InternalRosParser.g:8459:1: rule__Parameter__Group__7 : rule__Parameter__Group__7__Impl rule__Parameter__Group__8 ; + public final void rule__Parameter__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8587:1: ( rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 ) - // InternalRos.g:8588:2: rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 + // InternalRosParser.g:8463:1: ( rule__Parameter__Group__7__Impl rule__Parameter__Group__8 ) + // InternalRosParser.g:8464:2: rule__Parameter__Group__7__Impl rule__Parameter__Group__8 { - pushFollow(FOLLOW_40); - rule__Publisher__Group_6__0__Impl(); + pushFollow(FOLLOW_42); + rule__Parameter__Group__7__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Publisher__Group_6__1(); + rule__Parameter__Group__8(); state._fsp--; @@ -26357,25 +25576,25 @@ public final void rule__Publisher__Group_6__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Publisher__Group_6__0" + // $ANTLR end "rule__Parameter__Group__7" - // $ANTLR start "rule__Publisher__Group_6__0__Impl" - // InternalRos.g:8595:1: rule__Publisher__Group_6__0__Impl : ( 'namespace' ) ; - public final void rule__Publisher__Group_6__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__7__Impl" + // InternalRosParser.g:8471:1: rule__Parameter__Group__7__Impl : ( RULE_END ) ; + public final void rule__Parameter__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8599:1: ( ( 'namespace' ) ) - // InternalRos.g:8600:1: ( 'namespace' ) + // InternalRosParser.g:8475:1: ( ( RULE_END ) ) + // InternalRosParser.g:8476:1: ( RULE_END ) { - // InternalRos.g:8600:1: ( 'namespace' ) - // InternalRos.g:8601:2: 'namespace' + // InternalRosParser.g:8476:1: ( RULE_END ) + // InternalRosParser.g:8477:2: RULE_END { - before(grammarAccess.getPublisherAccess().getNamespaceKeyword_6_0()); - match(input,65,FOLLOW_2); - after(grammarAccess.getPublisherAccess().getNamespaceKeyword_6_0()); + before(grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); } @@ -26394,21 +25613,21 @@ public final void rule__Publisher__Group_6__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Publisher__Group_6__0__Impl" + // $ANTLR end "rule__Parameter__Group__7__Impl" - // $ANTLR start "rule__Publisher__Group_6__1" - // InternalRos.g:8610:1: rule__Publisher__Group_6__1 : rule__Publisher__Group_6__1__Impl ; - public final void rule__Publisher__Group_6__1() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__8" + // InternalRosParser.g:8486:1: rule__Parameter__Group__8 : rule__Parameter__Group__8__Impl ; + public final void rule__Parameter__Group__8() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8614:1: ( rule__Publisher__Group_6__1__Impl ) - // InternalRos.g:8615:2: rule__Publisher__Group_6__1__Impl + // InternalRosParser.g:8490:1: ( rule__Parameter__Group__8__Impl ) + // InternalRosParser.g:8491:2: rule__Parameter__Group__8__Impl { pushFollow(FOLLOW_2); - rule__Publisher__Group_6__1__Impl(); + rule__Parameter__Group__8__Impl(); state._fsp--; @@ -26427,35 +25646,25 @@ public final void rule__Publisher__Group_6__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Publisher__Group_6__1" + // $ANTLR end "rule__Parameter__Group__8" - // $ANTLR start "rule__Publisher__Group_6__1__Impl" - // InternalRos.g:8621:1: rule__Publisher__Group_6__1__Impl : ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) ; - public final void rule__Publisher__Group_6__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group__8__Impl" + // InternalRosParser.g:8497:1: rule__Parameter__Group__8__Impl : ( RightCurlyBracket ) ; + public final void rule__Parameter__Group__8__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8625:1: ( ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) ) - // InternalRos.g:8626:1: ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) - { - // InternalRos.g:8626:1: ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) - // InternalRos.g:8627:2: ( rule__Publisher__NamespaceAssignment_6_1 ) + // InternalRosParser.g:8501:1: ( ( RightCurlyBracket ) ) + // InternalRosParser.g:8502:1: ( RightCurlyBracket ) { - before(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); - // InternalRos.g:8628:2: ( rule__Publisher__NamespaceAssignment_6_1 ) - // InternalRos.g:8628:3: rule__Publisher__NamespaceAssignment_6_1 + // InternalRosParser.g:8502:1: ( RightCurlyBracket ) + // InternalRosParser.g:8503:2: RightCurlyBracket { - pushFollow(FOLLOW_2); - rule__Publisher__NamespaceAssignment_6_1(); - - state._fsp--; - - - } - - after(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); + before(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); + match(input,RightCurlyBracket,FOLLOW_2); + after(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); } @@ -26474,26 +25683,26 @@ public final void rule__Publisher__Group_6__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Publisher__Group_6__1__Impl" + // $ANTLR end "rule__Parameter__Group__8__Impl" - // $ANTLR start "rule__Subscriber__Group__0" - // InternalRos.g:8637:1: rule__Subscriber__Group__0 : rule__Subscriber__Group__0__Impl rule__Subscriber__Group__1 ; - public final void rule__Subscriber__Group__0() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group_6__0" + // InternalRosParser.g:8513:1: rule__Parameter__Group_6__0 : rule__Parameter__Group_6__0__Impl rule__Parameter__Group_6__1 ; + public final void rule__Parameter__Group_6__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8641:1: ( rule__Subscriber__Group__0__Impl rule__Subscriber__Group__1 ) - // InternalRos.g:8642:2: rule__Subscriber__Group__0__Impl rule__Subscriber__Group__1 + // InternalRosParser.g:8517:1: ( rule__Parameter__Group_6__0__Impl rule__Parameter__Group_6__1 ) + // InternalRosParser.g:8518:2: rule__Parameter__Group_6__0__Impl rule__Parameter__Group_6__1 { - pushFollow(FOLLOW_4); - rule__Subscriber__Group__0__Impl(); + pushFollow(FOLLOW_36); + rule__Parameter__Group_6__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Subscriber__Group__1(); + rule__Parameter__Group_6__1(); state._fsp--; @@ -26512,25 +25721,25 @@ public final void rule__Subscriber__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Subscriber__Group__0" + // $ANTLR end "rule__Parameter__Group_6__0" - // $ANTLR start "rule__Subscriber__Group__0__Impl" - // InternalRos.g:8649:1: rule__Subscriber__Group__0__Impl : ( 'Subscriber' ) ; - public final void rule__Subscriber__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group_6__0__Impl" + // InternalRosParser.g:8525:1: rule__Parameter__Group_6__0__Impl : ( Ns ) ; + public final void rule__Parameter__Group_6__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8653:1: ( ( 'Subscriber' ) ) - // InternalRos.g:8654:1: ( 'Subscriber' ) + // InternalRosParser.g:8529:1: ( ( Ns ) ) + // InternalRosParser.g:8530:1: ( Ns ) { - // InternalRos.g:8654:1: ( 'Subscriber' ) - // InternalRos.g:8655:2: 'Subscriber' + // InternalRosParser.g:8530:1: ( Ns ) + // InternalRosParser.g:8531:2: Ns { - before(grammarAccess.getSubscriberAccess().getSubscriberKeyword_0()); - match(input,67,FOLLOW_2); - after(grammarAccess.getSubscriberAccess().getSubscriberKeyword_0()); + before(grammarAccess.getParameterAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getParameterAccess().getNsKeyword_6_0()); } @@ -26549,26 +25758,21 @@ public final void rule__Subscriber__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Subscriber__Group__0__Impl" + // $ANTLR end "rule__Parameter__Group_6__0__Impl" - // $ANTLR start "rule__Subscriber__Group__1" - // InternalRos.g:8664:1: rule__Subscriber__Group__1 : rule__Subscriber__Group__1__Impl rule__Subscriber__Group__2 ; - public final void rule__Subscriber__Group__1() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group_6__1" + // InternalRosParser.g:8540:1: rule__Parameter__Group_6__1 : rule__Parameter__Group_6__1__Impl ; + public final void rule__Parameter__Group_6__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8668:1: ( rule__Subscriber__Group__1__Impl rule__Subscriber__Group__2 ) - // InternalRos.g:8669:2: rule__Subscriber__Group__1__Impl rule__Subscriber__Group__2 + // InternalRosParser.g:8544:1: ( rule__Parameter__Group_6__1__Impl ) + // InternalRosParser.g:8545:2: rule__Parameter__Group_6__1__Impl { - pushFollow(FOLLOW_29); - rule__Subscriber__Group__1__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__Subscriber__Group__2(); + rule__Parameter__Group_6__1__Impl(); state._fsp--; @@ -26587,25 +25791,35 @@ public final void rule__Subscriber__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Subscriber__Group__1" + // $ANTLR end "rule__Parameter__Group_6__1" - // $ANTLR start "rule__Subscriber__Group__1__Impl" - // InternalRos.g:8676:1: rule__Subscriber__Group__1__Impl : ( '{' ) ; - public final void rule__Subscriber__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Parameter__Group_6__1__Impl" + // InternalRosParser.g:8551:1: rule__Parameter__Group_6__1__Impl : ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) ; + public final void rule__Parameter__Group_6__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8680:1: ( ( '{' ) ) - // InternalRos.g:8681:1: ( '{' ) + // InternalRosParser.g:8555:1: ( ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) ) + // InternalRosParser.g:8556:1: ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) { - // InternalRos.g:8681:1: ( '{' ) - // InternalRos.g:8682:2: '{' + // InternalRosParser.g:8556:1: ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) + // InternalRosParser.g:8557:2: ( rule__Parameter__NamespaceAssignment_6_1 ) { - before(grammarAccess.getSubscriberAccess().getLeftCurlyBracketKeyword_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getSubscriberAccess().getLeftCurlyBracketKeyword_1()); + before(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); + // InternalRosParser.g:8558:2: ( rule__Parameter__NamespaceAssignment_6_1 ) + // InternalRosParser.g:8558:3: rule__Parameter__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__Parameter__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); } @@ -26624,26 +25838,26 @@ public final void rule__Subscriber__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Subscriber__Group__1__Impl" + // $ANTLR end "rule__Parameter__Group_6__1__Impl" - // $ANTLR start "rule__Subscriber__Group__2" - // InternalRos.g:8691:1: rule__Subscriber__Group__2 : rule__Subscriber__Group__2__Impl rule__Subscriber__Group__3 ; - public final void rule__Subscriber__Group__2() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__0" + // InternalRosParser.g:8567:1: rule__ParameterListType__Group__0 : rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 ; + public final void rule__ParameterListType__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8695:1: ( rule__Subscriber__Group__2__Impl rule__Subscriber__Group__3 ) - // InternalRos.g:8696:2: rule__Subscriber__Group__2__Impl rule__Subscriber__Group__3 + // InternalRosParser.g:8571:1: ( rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 ) + // InternalRosParser.g:8572:2: rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 { - pushFollow(FOLLOW_10); - rule__Subscriber__Group__2__Impl(); + pushFollow(FOLLOW_43); + rule__ParameterListType__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Subscriber__Group__3(); + rule__ParameterListType__Group__1(); state._fsp--; @@ -26662,25 +25876,29 @@ public final void rule__Subscriber__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Subscriber__Group__2" + // $ANTLR end "rule__ParameterListType__Group__0" - // $ANTLR start "rule__Subscriber__Group__2__Impl" - // InternalRos.g:8703:1: rule__Subscriber__Group__2__Impl : ( 'name' ) ; - public final void rule__Subscriber__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__0__Impl" + // InternalRosParser.g:8579:1: rule__ParameterListType__Group__0__Impl : ( () ) ; + public final void rule__ParameterListType__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8707:1: ( ( 'name' ) ) - // InternalRos.g:8708:1: ( 'name' ) + // InternalRosParser.g:8583:1: ( ( () ) ) + // InternalRosParser.g:8584:1: ( () ) + { + // InternalRosParser.g:8584:1: ( () ) + // InternalRosParser.g:8585:2: () { - // InternalRos.g:8708:1: ( 'name' ) - // InternalRos.g:8709:2: 'name' + before(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); + // InternalRosParser.g:8586:2: () + // InternalRosParser.g:8586:3: { - before(grammarAccess.getSubscriberAccess().getNameKeyword_2()); - match(input,33,FOLLOW_2); - after(grammarAccess.getSubscriberAccess().getNameKeyword_2()); + } + + after(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); } @@ -26688,10 +25906,6 @@ public final void rule__Subscriber__Group__2__Impl() throws RecognitionException } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -26699,26 +25913,26 @@ public final void rule__Subscriber__Group__2__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Subscriber__Group__2__Impl" + // $ANTLR end "rule__ParameterListType__Group__0__Impl" - // $ANTLR start "rule__Subscriber__Group__3" - // InternalRos.g:8718:1: rule__Subscriber__Group__3 : rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 ; - public final void rule__Subscriber__Group__3() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__1" + // InternalRosParser.g:8594:1: rule__ParameterListType__Group__1 : rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 ; + public final void rule__ParameterListType__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8722:1: ( rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 ) - // InternalRos.g:8723:2: rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 + // InternalRosParser.g:8598:1: ( rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 ) + // InternalRosParser.g:8599:2: rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 { - pushFollow(FOLLOW_41); - rule__Subscriber__Group__3__Impl(); + pushFollow(FOLLOW_11); + rule__ParameterListType__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Subscriber__Group__4(); + rule__ParameterListType__Group__2(); state._fsp--; @@ -26737,35 +25951,25 @@ public final void rule__Subscriber__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Subscriber__Group__3" + // $ANTLR end "rule__ParameterListType__Group__1" - // $ANTLR start "rule__Subscriber__Group__3__Impl" - // InternalRos.g:8730:1: rule__Subscriber__Group__3__Impl : ( ( rule__Subscriber__NameAssignment_3 ) ) ; - public final void rule__Subscriber__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__1__Impl" + // InternalRosParser.g:8606:1: rule__ParameterListType__Group__1__Impl : ( List ) ; + public final void rule__ParameterListType__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8734:1: ( ( ( rule__Subscriber__NameAssignment_3 ) ) ) - // InternalRos.g:8735:1: ( ( rule__Subscriber__NameAssignment_3 ) ) + // InternalRosParser.g:8610:1: ( ( List ) ) + // InternalRosParser.g:8611:1: ( List ) { - // InternalRos.g:8735:1: ( ( rule__Subscriber__NameAssignment_3 ) ) - // InternalRos.g:8736:2: ( rule__Subscriber__NameAssignment_3 ) + // InternalRosParser.g:8611:1: ( List ) + // InternalRosParser.g:8612:2: List { - before(grammarAccess.getSubscriberAccess().getNameAssignment_3()); - // InternalRos.g:8737:2: ( rule__Subscriber__NameAssignment_3 ) - // InternalRos.g:8737:3: rule__Subscriber__NameAssignment_3 - { - pushFollow(FOLLOW_2); - rule__Subscriber__NameAssignment_3(); - - state._fsp--; - - - } - - after(grammarAccess.getSubscriberAccess().getNameAssignment_3()); + before(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); + match(input,List,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); } @@ -26784,26 +25988,26 @@ public final void rule__Subscriber__Group__3__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Subscriber__Group__3__Impl" + // $ANTLR end "rule__ParameterListType__Group__1__Impl" - // $ANTLR start "rule__Subscriber__Group__4" - // InternalRos.g:8745:1: rule__Subscriber__Group__4 : rule__Subscriber__Group__4__Impl rule__Subscriber__Group__5 ; - public final void rule__Subscriber__Group__4() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__2" + // InternalRosParser.g:8621:1: rule__ParameterListType__Group__2 : rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 ; + public final void rule__ParameterListType__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8749:1: ( rule__Subscriber__Group__4__Impl rule__Subscriber__Group__5 ) - // InternalRos.g:8750:2: rule__Subscriber__Group__4__Impl rule__Subscriber__Group__5 + // InternalRosParser.g:8625:1: ( rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 ) + // InternalRosParser.g:8626:2: rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 { - pushFollow(FOLLOW_10); - rule__Subscriber__Group__4__Impl(); + pushFollow(FOLLOW_41); + rule__ParameterListType__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Subscriber__Group__5(); + rule__ParameterListType__Group__3(); state._fsp--; @@ -26822,25 +26026,25 @@ public final void rule__Subscriber__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__Subscriber__Group__4" + // $ANTLR end "rule__ParameterListType__Group__2" - // $ANTLR start "rule__Subscriber__Group__4__Impl" - // InternalRos.g:8757:1: rule__Subscriber__Group__4__Impl : ( 'message' ) ; - public final void rule__Subscriber__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__2__Impl" + // InternalRosParser.g:8633:1: rule__ParameterListType__Group__2__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterListType__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8761:1: ( ( 'message' ) ) - // InternalRos.g:8762:1: ( 'message' ) + // InternalRosParser.g:8637:1: ( ( LeftSquareBracket ) ) + // InternalRosParser.g:8638:1: ( LeftSquareBracket ) { - // InternalRos.g:8762:1: ( 'message' ) - // InternalRos.g:8763:2: 'message' + // InternalRosParser.g:8638:1: ( LeftSquareBracket ) + // InternalRosParser.g:8639:2: LeftSquareBracket { - before(grammarAccess.getSubscriberAccess().getMessageKeyword_4()); - match(input,30,FOLLOW_2); - after(grammarAccess.getSubscriberAccess().getMessageKeyword_4()); + before(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); } @@ -26859,26 +26063,26 @@ public final void rule__Subscriber__Group__4__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Subscriber__Group__4__Impl" + // $ANTLR end "rule__ParameterListType__Group__2__Impl" - // $ANTLR start "rule__Subscriber__Group__5" - // InternalRos.g:8772:1: rule__Subscriber__Group__5 : rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 ; - public final void rule__Subscriber__Group__5() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__3" + // InternalRosParser.g:8648:1: rule__ParameterListType__Group__3 : rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 ; + public final void rule__ParameterListType__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8776:1: ( rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 ) - // InternalRos.g:8777:2: rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 + // InternalRosParser.g:8652:1: ( rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 ) + // InternalRosParser.g:8653:2: rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 { - pushFollow(FOLLOW_39); - rule__Subscriber__Group__5__Impl(); + pushFollow(FOLLOW_13); + rule__ParameterListType__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Subscriber__Group__6(); + rule__ParameterListType__Group__4(); state._fsp--; @@ -26897,35 +26101,35 @@ public final void rule__Subscriber__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__Subscriber__Group__5" + // $ANTLR end "rule__ParameterListType__Group__3" - // $ANTLR start "rule__Subscriber__Group__5__Impl" - // InternalRos.g:8784:1: rule__Subscriber__Group__5__Impl : ( ( rule__Subscriber__MessageAssignment_5 ) ) ; - public final void rule__Subscriber__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__3__Impl" + // InternalRosParser.g:8660:1: rule__ParameterListType__Group__3__Impl : ( ( rule__ParameterListType__SequenceAssignment_3 ) ) ; + public final void rule__ParameterListType__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8788:1: ( ( ( rule__Subscriber__MessageAssignment_5 ) ) ) - // InternalRos.g:8789:1: ( ( rule__Subscriber__MessageAssignment_5 ) ) + // InternalRosParser.g:8664:1: ( ( ( rule__ParameterListType__SequenceAssignment_3 ) ) ) + // InternalRosParser.g:8665:1: ( ( rule__ParameterListType__SequenceAssignment_3 ) ) { - // InternalRos.g:8789:1: ( ( rule__Subscriber__MessageAssignment_5 ) ) - // InternalRos.g:8790:2: ( rule__Subscriber__MessageAssignment_5 ) + // InternalRosParser.g:8665:1: ( ( rule__ParameterListType__SequenceAssignment_3 ) ) + // InternalRosParser.g:8666:2: ( rule__ParameterListType__SequenceAssignment_3 ) { - before(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); - // InternalRos.g:8791:2: ( rule__Subscriber__MessageAssignment_5 ) - // InternalRos.g:8791:3: rule__Subscriber__MessageAssignment_5 + before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); + // InternalRosParser.g:8667:2: ( rule__ParameterListType__SequenceAssignment_3 ) + // InternalRosParser.g:8667:3: rule__ParameterListType__SequenceAssignment_3 { pushFollow(FOLLOW_2); - rule__Subscriber__MessageAssignment_5(); + rule__ParameterListType__SequenceAssignment_3(); state._fsp--; } - after(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); + after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); } @@ -26944,26 +26148,26 @@ public final void rule__Subscriber__Group__5__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Subscriber__Group__5__Impl" + // $ANTLR end "rule__ParameterListType__Group__3__Impl" - // $ANTLR start "rule__Subscriber__Group__6" - // InternalRos.g:8799:1: rule__Subscriber__Group__6 : rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 ; - public final void rule__Subscriber__Group__6() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__4" + // InternalRosParser.g:8675:1: rule__ParameterListType__Group__4 : rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 ; + public final void rule__ParameterListType__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8803:1: ( rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 ) - // InternalRos.g:8804:2: rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 + // InternalRosParser.g:8679:1: ( rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 ) + // InternalRosParser.g:8680:2: rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 { - pushFollow(FOLLOW_39); - rule__Subscriber__Group__6__Impl(); + pushFollow(FOLLOW_13); + rule__ParameterListType__Group__4__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Subscriber__Group__7(); + rule__ParameterListType__Group__5(); state._fsp--; @@ -26982,46 +26186,53 @@ public final void rule__Subscriber__Group__6() throws RecognitionException { } return ; } - // $ANTLR end "rule__Subscriber__Group__6" + // $ANTLR end "rule__ParameterListType__Group__4" - // $ANTLR start "rule__Subscriber__Group__6__Impl" - // InternalRos.g:8811:1: rule__Subscriber__Group__6__Impl : ( ( rule__Subscriber__Group_6__0 )? ) ; - public final void rule__Subscriber__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__4__Impl" + // InternalRosParser.g:8687:1: rule__ParameterListType__Group__4__Impl : ( ( rule__ParameterListType__Group_4__0 )* ) ; + public final void rule__ParameterListType__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8815:1: ( ( ( rule__Subscriber__Group_6__0 )? ) ) - // InternalRos.g:8816:1: ( ( rule__Subscriber__Group_6__0 )? ) + // InternalRosParser.g:8691:1: ( ( ( rule__ParameterListType__Group_4__0 )* ) ) + // InternalRosParser.g:8692:1: ( ( rule__ParameterListType__Group_4__0 )* ) { - // InternalRos.g:8816:1: ( ( rule__Subscriber__Group_6__0 )? ) - // InternalRos.g:8817:2: ( rule__Subscriber__Group_6__0 )? + // InternalRosParser.g:8692:1: ( ( rule__ParameterListType__Group_4__0 )* ) + // InternalRosParser.g:8693:2: ( rule__ParameterListType__Group_4__0 )* { - before(grammarAccess.getSubscriberAccess().getGroup_6()); - // InternalRos.g:8818:2: ( rule__Subscriber__Group_6__0 )? - int alt59=2; - int LA59_0 = input.LA(1); + before(grammarAccess.getParameterListTypeAccess().getGroup_4()); + // InternalRosParser.g:8694:2: ( rule__ParameterListType__Group_4__0 )* + loop48: + do { + int alt48=2; + int LA48_0 = input.LA(1); - if ( (LA59_0==65) ) { - alt59=1; - } - switch (alt59) { - case 1 : - // InternalRos.g:8818:3: rule__Subscriber__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__Subscriber__Group_6__0(); + if ( (LA48_0==Comma) ) { + alt48=1; + } - state._fsp--; + switch (alt48) { + case 1 : + // InternalRosParser.g:8694:3: rule__ParameterListType__Group_4__0 + { + pushFollow(FOLLOW_14); + rule__ParameterListType__Group_4__0(); - } - break; + state._fsp--; - } - after(grammarAccess.getSubscriberAccess().getGroup_6()); + } + break; + + default : + break loop48; + } + } while (true); + + after(grammarAccess.getParameterListTypeAccess().getGroup_4()); } @@ -27040,21 +26251,21 @@ public final void rule__Subscriber__Group__6__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Subscriber__Group__6__Impl" + // $ANTLR end "rule__ParameterListType__Group__4__Impl" - // $ANTLR start "rule__Subscriber__Group__7" - // InternalRos.g:8826:1: rule__Subscriber__Group__7 : rule__Subscriber__Group__7__Impl ; - public final void rule__Subscriber__Group__7() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__5" + // InternalRosParser.g:8702:1: rule__ParameterListType__Group__5 : rule__ParameterListType__Group__5__Impl ; + public final void rule__ParameterListType__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8830:1: ( rule__Subscriber__Group__7__Impl ) - // InternalRos.g:8831:2: rule__Subscriber__Group__7__Impl + // InternalRosParser.g:8706:1: ( rule__ParameterListType__Group__5__Impl ) + // InternalRosParser.g:8707:2: rule__ParameterListType__Group__5__Impl { pushFollow(FOLLOW_2); - rule__Subscriber__Group__7__Impl(); + rule__ParameterListType__Group__5__Impl(); state._fsp--; @@ -27073,25 +26284,25 @@ public final void rule__Subscriber__Group__7() throws RecognitionException { } return ; } - // $ANTLR end "rule__Subscriber__Group__7" + // $ANTLR end "rule__ParameterListType__Group__5" - // $ANTLR start "rule__Subscriber__Group__7__Impl" - // InternalRos.g:8837:1: rule__Subscriber__Group__7__Impl : ( '}' ) ; - public final void rule__Subscriber__Group__7__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group__5__Impl" + // InternalRosParser.g:8713:1: rule__ParameterListType__Group__5__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterListType__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8841:1: ( ( '}' ) ) - // InternalRos.g:8842:1: ( '}' ) + // InternalRosParser.g:8717:1: ( ( RightSquareBracket ) ) + // InternalRosParser.g:8718:1: ( RightSquareBracket ) { - // InternalRos.g:8842:1: ( '}' ) - // InternalRos.g:8843:2: '}' + // InternalRosParser.g:8718:1: ( RightSquareBracket ) + // InternalRosParser.g:8719:2: RightSquareBracket { - before(grammarAccess.getSubscriberAccess().getRightCurlyBracketKeyword_7()); - match(input,42,FOLLOW_2); - after(grammarAccess.getSubscriberAccess().getRightCurlyBracketKeyword_7()); + before(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); } @@ -27110,26 +26321,26 @@ public final void rule__Subscriber__Group__7__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Subscriber__Group__7__Impl" + // $ANTLR end "rule__ParameterListType__Group__5__Impl" - // $ANTLR start "rule__Subscriber__Group_6__0" - // InternalRos.g:8853:1: rule__Subscriber__Group_6__0 : rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 ; - public final void rule__Subscriber__Group_6__0() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group_4__0" + // InternalRosParser.g:8729:1: rule__ParameterListType__Group_4__0 : rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 ; + public final void rule__ParameterListType__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8857:1: ( rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 ) - // InternalRos.g:8858:2: rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 + // InternalRosParser.g:8733:1: ( rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 ) + // InternalRosParser.g:8734:2: rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 { - pushFollow(FOLLOW_40); - rule__Subscriber__Group_6__0__Impl(); + pushFollow(FOLLOW_41); + rule__ParameterListType__Group_4__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Subscriber__Group_6__1(); + rule__ParameterListType__Group_4__1(); state._fsp--; @@ -27148,25 +26359,25 @@ public final void rule__Subscriber__Group_6__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Subscriber__Group_6__0" + // $ANTLR end "rule__ParameterListType__Group_4__0" - // $ANTLR start "rule__Subscriber__Group_6__0__Impl" - // InternalRos.g:8865:1: rule__Subscriber__Group_6__0__Impl : ( 'namespace' ) ; - public final void rule__Subscriber__Group_6__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group_4__0__Impl" + // InternalRosParser.g:8741:1: rule__ParameterListType__Group_4__0__Impl : ( Comma ) ; + public final void rule__ParameterListType__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8869:1: ( ( 'namespace' ) ) - // InternalRos.g:8870:1: ( 'namespace' ) + // InternalRosParser.g:8745:1: ( ( Comma ) ) + // InternalRosParser.g:8746:1: ( Comma ) { - // InternalRos.g:8870:1: ( 'namespace' ) - // InternalRos.g:8871:2: 'namespace' + // InternalRosParser.g:8746:1: ( Comma ) + // InternalRosParser.g:8747:2: Comma { - before(grammarAccess.getSubscriberAccess().getNamespaceKeyword_6_0()); - match(input,65,FOLLOW_2); - after(grammarAccess.getSubscriberAccess().getNamespaceKeyword_6_0()); + before(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); } @@ -27185,21 +26396,21 @@ public final void rule__Subscriber__Group_6__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Subscriber__Group_6__0__Impl" + // $ANTLR end "rule__ParameterListType__Group_4__0__Impl" - // $ANTLR start "rule__Subscriber__Group_6__1" - // InternalRos.g:8880:1: rule__Subscriber__Group_6__1 : rule__Subscriber__Group_6__1__Impl ; - public final void rule__Subscriber__Group_6__1() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group_4__1" + // InternalRosParser.g:8756:1: rule__ParameterListType__Group_4__1 : rule__ParameterListType__Group_4__1__Impl ; + public final void rule__ParameterListType__Group_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8884:1: ( rule__Subscriber__Group_6__1__Impl ) - // InternalRos.g:8885:2: rule__Subscriber__Group_6__1__Impl + // InternalRosParser.g:8760:1: ( rule__ParameterListType__Group_4__1__Impl ) + // InternalRosParser.g:8761:2: rule__ParameterListType__Group_4__1__Impl { pushFollow(FOLLOW_2); - rule__Subscriber__Group_6__1__Impl(); + rule__ParameterListType__Group_4__1__Impl(); state._fsp--; @@ -27218,35 +26429,35 @@ public final void rule__Subscriber__Group_6__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Subscriber__Group_6__1" + // $ANTLR end "rule__ParameterListType__Group_4__1" - // $ANTLR start "rule__Subscriber__Group_6__1__Impl" - // InternalRos.g:8891:1: rule__Subscriber__Group_6__1__Impl : ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) ; - public final void rule__Subscriber__Group_6__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterListType__Group_4__1__Impl" + // InternalRosParser.g:8767:1: rule__ParameterListType__Group_4__1__Impl : ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) ; + public final void rule__ParameterListType__Group_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8895:1: ( ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) ) - // InternalRos.g:8896:1: ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) + // InternalRosParser.g:8771:1: ( ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) ) + // InternalRosParser.g:8772:1: ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) { - // InternalRos.g:8896:1: ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) - // InternalRos.g:8897:2: ( rule__Subscriber__NamespaceAssignment_6_1 ) + // InternalRosParser.g:8772:1: ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) + // InternalRosParser.g:8773:2: ( rule__ParameterListType__SequenceAssignment_4_1 ) { - before(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); - // InternalRos.g:8898:2: ( rule__Subscriber__NamespaceAssignment_6_1 ) - // InternalRos.g:8898:3: rule__Subscriber__NamespaceAssignment_6_1 + before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); + // InternalRosParser.g:8774:2: ( rule__ParameterListType__SequenceAssignment_4_1 ) + // InternalRosParser.g:8774:3: rule__ParameterListType__SequenceAssignment_4_1 { pushFollow(FOLLOW_2); - rule__Subscriber__NamespaceAssignment_6_1(); + rule__ParameterListType__SequenceAssignment_4_1(); state._fsp--; } - after(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); + after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); } @@ -27265,26 +26476,26 @@ public final void rule__Subscriber__Group_6__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Subscriber__Group_6__1__Impl" + // $ANTLR end "rule__ParameterListType__Group_4__1__Impl" - // $ANTLR start "rule__ServiceClient__Group__0" - // InternalRos.g:8907:1: rule__ServiceClient__Group__0 : rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 ; - public final void rule__ServiceClient__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__0" + // InternalRosParser.g:8783:1: rule__ParameterStructType__Group__0 : rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 ; + public final void rule__ParameterStructType__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8911:1: ( rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 ) - // InternalRos.g:8912:2: rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 + // InternalRosParser.g:8787:1: ( rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 ) + // InternalRosParser.g:8788:2: rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 { - pushFollow(FOLLOW_4); - rule__ServiceClient__Group__0__Impl(); + pushFollow(FOLLOW_44); + rule__ParameterStructType__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceClient__Group__1(); + rule__ParameterStructType__Group__1(); state._fsp--; @@ -27303,25 +26514,29 @@ public final void rule__ServiceClient__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceClient__Group__0" + // $ANTLR end "rule__ParameterStructType__Group__0" - // $ANTLR start "rule__ServiceClient__Group__0__Impl" - // InternalRos.g:8919:1: rule__ServiceClient__Group__0__Impl : ( 'ServiceClient' ) ; - public final void rule__ServiceClient__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__0__Impl" + // InternalRosParser.g:8795:1: rule__ParameterStructType__Group__0__Impl : ( () ) ; + public final void rule__ParameterStructType__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8923:1: ( ( 'ServiceClient' ) ) - // InternalRos.g:8924:1: ( 'ServiceClient' ) + // InternalRosParser.g:8799:1: ( ( () ) ) + // InternalRosParser.g:8800:1: ( () ) { - // InternalRos.g:8924:1: ( 'ServiceClient' ) - // InternalRos.g:8925:2: 'ServiceClient' + // InternalRosParser.g:8800:1: ( () ) + // InternalRosParser.g:8801:2: () { - before(grammarAccess.getServiceClientAccess().getServiceClientKeyword_0()); - match(input,68,FOLLOW_2); - after(grammarAccess.getServiceClientAccess().getServiceClientKeyword_0()); + before(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); + // InternalRosParser.g:8802:2: () + // InternalRosParser.g:8802:3: + { + } + + after(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); } @@ -27329,10 +26544,6 @@ public final void rule__ServiceClient__Group__0__Impl() throws RecognitionExcept } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -27340,26 +26551,26 @@ public final void rule__ServiceClient__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceClient__Group__0__Impl" + // $ANTLR end "rule__ParameterStructType__Group__0__Impl" - // $ANTLR start "rule__ServiceClient__Group__1" - // InternalRos.g:8934:1: rule__ServiceClient__Group__1 : rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 ; - public final void rule__ServiceClient__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__1" + // InternalRosParser.g:8810:1: rule__ParameterStructType__Group__1 : rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 ; + public final void rule__ParameterStructType__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8938:1: ( rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 ) - // InternalRos.g:8939:2: rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 + // InternalRosParser.g:8814:1: ( rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 ) + // InternalRosParser.g:8815:2: rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 { - pushFollow(FOLLOW_29); - rule__ServiceClient__Group__1__Impl(); + pushFollow(FOLLOW_11); + rule__ParameterStructType__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceClient__Group__2(); + rule__ParameterStructType__Group__2(); state._fsp--; @@ -27378,25 +26589,25 @@ public final void rule__ServiceClient__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceClient__Group__1" + // $ANTLR end "rule__ParameterStructType__Group__1" - // $ANTLR start "rule__ServiceClient__Group__1__Impl" - // InternalRos.g:8946:1: rule__ServiceClient__Group__1__Impl : ( '{' ) ; - public final void rule__ServiceClient__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__1__Impl" + // InternalRosParser.g:8822:1: rule__ParameterStructType__Group__1__Impl : ( Struct ) ; + public final void rule__ParameterStructType__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8950:1: ( ( '{' ) ) - // InternalRos.g:8951:1: ( '{' ) + // InternalRosParser.g:8826:1: ( ( Struct ) ) + // InternalRosParser.g:8827:1: ( Struct ) { - // InternalRos.g:8951:1: ( '{' ) - // InternalRos.g:8952:2: '{' + // InternalRosParser.g:8827:1: ( Struct ) + // InternalRosParser.g:8828:2: Struct { - before(grammarAccess.getServiceClientAccess().getLeftCurlyBracketKeyword_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getServiceClientAccess().getLeftCurlyBracketKeyword_1()); + before(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); + match(input,Struct,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); } @@ -27415,26 +26626,26 @@ public final void rule__ServiceClient__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceClient__Group__1__Impl" + // $ANTLR end "rule__ParameterStructType__Group__1__Impl" - // $ANTLR start "rule__ServiceClient__Group__2" - // InternalRos.g:8961:1: rule__ServiceClient__Group__2 : rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 ; - public final void rule__ServiceClient__Group__2() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__2" + // InternalRosParser.g:8837:1: rule__ParameterStructType__Group__2 : rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 ; + public final void rule__ParameterStructType__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8965:1: ( rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 ) - // InternalRos.g:8966:2: rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 + // InternalRosParser.g:8841:1: ( rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 ) + // InternalRosParser.g:8842:2: rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 { - pushFollow(FOLLOW_10); - rule__ServiceClient__Group__2__Impl(); + pushFollow(FOLLOW_8); + rule__ParameterStructType__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ServiceClient__Group__3(); + rule__ParameterStructType__Group__3(); state._fsp--; @@ -27453,25 +26664,25 @@ public final void rule__ServiceClient__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__ServiceClient__Group__2" + // $ANTLR end "rule__ParameterStructType__Group__2" - // $ANTLR start "rule__ServiceClient__Group__2__Impl" - // InternalRos.g:8973:1: rule__ServiceClient__Group__2__Impl : ( 'name' ) ; - public final void rule__ServiceClient__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__2__Impl" + // InternalRosParser.g:8849:1: rule__ParameterStructType__Group__2__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterStructType__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:8977:1: ( ( 'name' ) ) - // InternalRos.g:8978:1: ( 'name' ) + // InternalRosParser.g:8853:1: ( ( LeftSquareBracket ) ) + // InternalRosParser.g:8854:1: ( LeftSquareBracket ) { - // InternalRos.g:8978:1: ( 'name' ) - // InternalRos.g:8979:2: 'name' + // InternalRosParser.g:8854:1: ( LeftSquareBracket ) + // InternalRosParser.g:8855:2: LeftSquareBracket { - before(grammarAccess.getServiceClientAccess().getNameKeyword_2()); - match(input,33,FOLLOW_2); - after(grammarAccess.getServiceClientAccess().getNameKeyword_2()); + before(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); } @@ -27490,8048 +26701,26 @@ public final void rule__ServiceClient__Group__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceClient__Group__2__Impl" - - - // $ANTLR start "rule__ServiceClient__Group__3" - // InternalRos.g:8988:1: rule__ServiceClient__Group__3 : rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 ; - public final void rule__ServiceClient__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:8992:1: ( rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 ) - // InternalRos.g:8993:2: rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 - { - pushFollow(FOLLOW_38); - rule__ServiceClient__Group__3__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ServiceClient__Group__4(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group__3" - - - // $ANTLR start "rule__ServiceClient__Group__3__Impl" - // InternalRos.g:9000:1: rule__ServiceClient__Group__3__Impl : ( ( rule__ServiceClient__NameAssignment_3 ) ) ; - public final void rule__ServiceClient__Group__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9004:1: ( ( ( rule__ServiceClient__NameAssignment_3 ) ) ) - // InternalRos.g:9005:1: ( ( rule__ServiceClient__NameAssignment_3 ) ) - { - // InternalRos.g:9005:1: ( ( rule__ServiceClient__NameAssignment_3 ) ) - // InternalRos.g:9006:2: ( rule__ServiceClient__NameAssignment_3 ) - { - before(grammarAccess.getServiceClientAccess().getNameAssignment_3()); - // InternalRos.g:9007:2: ( rule__ServiceClient__NameAssignment_3 ) - // InternalRos.g:9007:3: rule__ServiceClient__NameAssignment_3 - { - pushFollow(FOLLOW_2); - rule__ServiceClient__NameAssignment_3(); - - state._fsp--; - - - } - - after(grammarAccess.getServiceClientAccess().getNameAssignment_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group__3__Impl" - - - // $ANTLR start "rule__ServiceClient__Group__4" - // InternalRos.g:9015:1: rule__ServiceClient__Group__4 : rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 ; - public final void rule__ServiceClient__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9019:1: ( rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 ) - // InternalRos.g:9020:2: rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 - { - pushFollow(FOLLOW_10); - rule__ServiceClient__Group__4__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ServiceClient__Group__5(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group__4" - - - // $ANTLR start "rule__ServiceClient__Group__4__Impl" - // InternalRos.g:9027:1: rule__ServiceClient__Group__4__Impl : ( 'service' ) ; - public final void rule__ServiceClient__Group__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9031:1: ( ( 'service' ) ) - // InternalRos.g:9032:1: ( 'service' ) - { - // InternalRos.g:9032:1: ( 'service' ) - // InternalRos.g:9033:2: 'service' - { - before(grammarAccess.getServiceClientAccess().getServiceKeyword_4()); - match(input,35,FOLLOW_2); - after(grammarAccess.getServiceClientAccess().getServiceKeyword_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group__4__Impl" - - - // $ANTLR start "rule__ServiceClient__Group__5" - // InternalRos.g:9042:1: rule__ServiceClient__Group__5 : rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 ; - public final void rule__ServiceClient__Group__5() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9046:1: ( rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 ) - // InternalRos.g:9047:2: rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 - { - pushFollow(FOLLOW_39); - rule__ServiceClient__Group__5__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ServiceClient__Group__6(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group__5" - - - // $ANTLR start "rule__ServiceClient__Group__5__Impl" - // InternalRos.g:9054:1: rule__ServiceClient__Group__5__Impl : ( ( rule__ServiceClient__ServiceAssignment_5 ) ) ; - public final void rule__ServiceClient__Group__5__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9058:1: ( ( ( rule__ServiceClient__ServiceAssignment_5 ) ) ) - // InternalRos.g:9059:1: ( ( rule__ServiceClient__ServiceAssignment_5 ) ) - { - // InternalRos.g:9059:1: ( ( rule__ServiceClient__ServiceAssignment_5 ) ) - // InternalRos.g:9060:2: ( rule__ServiceClient__ServiceAssignment_5 ) - { - before(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); - // InternalRos.g:9061:2: ( rule__ServiceClient__ServiceAssignment_5 ) - // InternalRos.g:9061:3: rule__ServiceClient__ServiceAssignment_5 - { - pushFollow(FOLLOW_2); - rule__ServiceClient__ServiceAssignment_5(); - - state._fsp--; - - - } - - after(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group__5__Impl" - - - // $ANTLR start "rule__ServiceClient__Group__6" - // InternalRos.g:9069:1: rule__ServiceClient__Group__6 : rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 ; - public final void rule__ServiceClient__Group__6() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9073:1: ( rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 ) - // InternalRos.g:9074:2: rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 - { - pushFollow(FOLLOW_39); - rule__ServiceClient__Group__6__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ServiceClient__Group__7(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group__6" - - - // $ANTLR start "rule__ServiceClient__Group__6__Impl" - // InternalRos.g:9081:1: rule__ServiceClient__Group__6__Impl : ( ( rule__ServiceClient__Group_6__0 )? ) ; - public final void rule__ServiceClient__Group__6__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9085:1: ( ( ( rule__ServiceClient__Group_6__0 )? ) ) - // InternalRos.g:9086:1: ( ( rule__ServiceClient__Group_6__0 )? ) - { - // InternalRos.g:9086:1: ( ( rule__ServiceClient__Group_6__0 )? ) - // InternalRos.g:9087:2: ( rule__ServiceClient__Group_6__0 )? - { - before(grammarAccess.getServiceClientAccess().getGroup_6()); - // InternalRos.g:9088:2: ( rule__ServiceClient__Group_6__0 )? - int alt60=2; - int LA60_0 = input.LA(1); - - if ( (LA60_0==65) ) { - alt60=1; - } - switch (alt60) { - case 1 : - // InternalRos.g:9088:3: rule__ServiceClient__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__ServiceClient__Group_6__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getServiceClientAccess().getGroup_6()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group__6__Impl" - - - // $ANTLR start "rule__ServiceClient__Group__7" - // InternalRos.g:9096:1: rule__ServiceClient__Group__7 : rule__ServiceClient__Group__7__Impl ; - public final void rule__ServiceClient__Group__7() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9100:1: ( rule__ServiceClient__Group__7__Impl ) - // InternalRos.g:9101:2: rule__ServiceClient__Group__7__Impl - { - pushFollow(FOLLOW_2); - rule__ServiceClient__Group__7__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group__7" - - - // $ANTLR start "rule__ServiceClient__Group__7__Impl" - // InternalRos.g:9107:1: rule__ServiceClient__Group__7__Impl : ( '}' ) ; - public final void rule__ServiceClient__Group__7__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9111:1: ( ( '}' ) ) - // InternalRos.g:9112:1: ( '}' ) - { - // InternalRos.g:9112:1: ( '}' ) - // InternalRos.g:9113:2: '}' - { - before(grammarAccess.getServiceClientAccess().getRightCurlyBracketKeyword_7()); - match(input,42,FOLLOW_2); - after(grammarAccess.getServiceClientAccess().getRightCurlyBracketKeyword_7()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group__7__Impl" - - - // $ANTLR start "rule__ServiceClient__Group_6__0" - // InternalRos.g:9123:1: rule__ServiceClient__Group_6__0 : rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 ; - public final void rule__ServiceClient__Group_6__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9127:1: ( rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 ) - // InternalRos.g:9128:2: rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 - { - pushFollow(FOLLOW_40); - rule__ServiceClient__Group_6__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ServiceClient__Group_6__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group_6__0" - - - // $ANTLR start "rule__ServiceClient__Group_6__0__Impl" - // InternalRos.g:9135:1: rule__ServiceClient__Group_6__0__Impl : ( 'namespace' ) ; - public final void rule__ServiceClient__Group_6__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9139:1: ( ( 'namespace' ) ) - // InternalRos.g:9140:1: ( 'namespace' ) - { - // InternalRos.g:9140:1: ( 'namespace' ) - // InternalRos.g:9141:2: 'namespace' - { - before(grammarAccess.getServiceClientAccess().getNamespaceKeyword_6_0()); - match(input,65,FOLLOW_2); - after(grammarAccess.getServiceClientAccess().getNamespaceKeyword_6_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group_6__0__Impl" - - - // $ANTLR start "rule__ServiceClient__Group_6__1" - // InternalRos.g:9150:1: rule__ServiceClient__Group_6__1 : rule__ServiceClient__Group_6__1__Impl ; - public final void rule__ServiceClient__Group_6__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9154:1: ( rule__ServiceClient__Group_6__1__Impl ) - // InternalRos.g:9155:2: rule__ServiceClient__Group_6__1__Impl - { - pushFollow(FOLLOW_2); - rule__ServiceClient__Group_6__1__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group_6__1" - - - // $ANTLR start "rule__ServiceClient__Group_6__1__Impl" - // InternalRos.g:9161:1: rule__ServiceClient__Group_6__1__Impl : ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) ; - public final void rule__ServiceClient__Group_6__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9165:1: ( ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) ) - // InternalRos.g:9166:1: ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) - { - // InternalRos.g:9166:1: ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) - // InternalRos.g:9167:2: ( rule__ServiceClient__NamespaceAssignment_6_1 ) - { - before(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); - // InternalRos.g:9168:2: ( rule__ServiceClient__NamespaceAssignment_6_1 ) - // InternalRos.g:9168:3: rule__ServiceClient__NamespaceAssignment_6_1 - { - pushFollow(FOLLOW_2); - rule__ServiceClient__NamespaceAssignment_6_1(); - - state._fsp--; - - - } - - after(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ServiceClient__Group_6__1__Impl" - - - // $ANTLR start "rule__ActionServer__Group__0" - // InternalRos.g:9177:1: rule__ActionServer__Group__0 : rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 ; - public final void rule__ActionServer__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9181:1: ( rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 ) - // InternalRos.g:9182:2: rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 - { - pushFollow(FOLLOW_4); - rule__ActionServer__Group__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionServer__Group__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__0" - - - // $ANTLR start "rule__ActionServer__Group__0__Impl" - // InternalRos.g:9189:1: rule__ActionServer__Group__0__Impl : ( 'ActionServer' ) ; - public final void rule__ActionServer__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9193:1: ( ( 'ActionServer' ) ) - // InternalRos.g:9194:1: ( 'ActionServer' ) - { - // InternalRos.g:9194:1: ( 'ActionServer' ) - // InternalRos.g:9195:2: 'ActionServer' - { - before(grammarAccess.getActionServerAccess().getActionServerKeyword_0()); - match(input,69,FOLLOW_2); - after(grammarAccess.getActionServerAccess().getActionServerKeyword_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__0__Impl" - - - // $ANTLR start "rule__ActionServer__Group__1" - // InternalRos.g:9204:1: rule__ActionServer__Group__1 : rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 ; - public final void rule__ActionServer__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9208:1: ( rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 ) - // InternalRos.g:9209:2: rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 - { - pushFollow(FOLLOW_29); - rule__ActionServer__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionServer__Group__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__1" - - - // $ANTLR start "rule__ActionServer__Group__1__Impl" - // InternalRos.g:9216:1: rule__ActionServer__Group__1__Impl : ( '{' ) ; - public final void rule__ActionServer__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9220:1: ( ( '{' ) ) - // InternalRos.g:9221:1: ( '{' ) - { - // InternalRos.g:9221:1: ( '{' ) - // InternalRos.g:9222:2: '{' - { - before(grammarAccess.getActionServerAccess().getLeftCurlyBracketKeyword_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getActionServerAccess().getLeftCurlyBracketKeyword_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__1__Impl" - - - // $ANTLR start "rule__ActionServer__Group__2" - // InternalRos.g:9231:1: rule__ActionServer__Group__2 : rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 ; - public final void rule__ActionServer__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9235:1: ( rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 ) - // InternalRos.g:9236:2: rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 - { - pushFollow(FOLLOW_10); - rule__ActionServer__Group__2__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionServer__Group__3(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__2" - - - // $ANTLR start "rule__ActionServer__Group__2__Impl" - // InternalRos.g:9243:1: rule__ActionServer__Group__2__Impl : ( 'name' ) ; - public final void rule__ActionServer__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9247:1: ( ( 'name' ) ) - // InternalRos.g:9248:1: ( 'name' ) - { - // InternalRos.g:9248:1: ( 'name' ) - // InternalRos.g:9249:2: 'name' - { - before(grammarAccess.getActionServerAccess().getNameKeyword_2()); - match(input,33,FOLLOW_2); - after(grammarAccess.getActionServerAccess().getNameKeyword_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__2__Impl" - - - // $ANTLR start "rule__ActionServer__Group__3" - // InternalRos.g:9258:1: rule__ActionServer__Group__3 : rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 ; - public final void rule__ActionServer__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9262:1: ( rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 ) - // InternalRos.g:9263:2: rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 - { - pushFollow(FOLLOW_42); - rule__ActionServer__Group__3__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionServer__Group__4(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__3" - - - // $ANTLR start "rule__ActionServer__Group__3__Impl" - // InternalRos.g:9270:1: rule__ActionServer__Group__3__Impl : ( ( rule__ActionServer__NameAssignment_3 ) ) ; - public final void rule__ActionServer__Group__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9274:1: ( ( ( rule__ActionServer__NameAssignment_3 ) ) ) - // InternalRos.g:9275:1: ( ( rule__ActionServer__NameAssignment_3 ) ) - { - // InternalRos.g:9275:1: ( ( rule__ActionServer__NameAssignment_3 ) ) - // InternalRos.g:9276:2: ( rule__ActionServer__NameAssignment_3 ) - { - before(grammarAccess.getActionServerAccess().getNameAssignment_3()); - // InternalRos.g:9277:2: ( rule__ActionServer__NameAssignment_3 ) - // InternalRos.g:9277:3: rule__ActionServer__NameAssignment_3 - { - pushFollow(FOLLOW_2); - rule__ActionServer__NameAssignment_3(); - - state._fsp--; - - - } - - after(grammarAccess.getActionServerAccess().getNameAssignment_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__3__Impl" - - - // $ANTLR start "rule__ActionServer__Group__4" - // InternalRos.g:9285:1: rule__ActionServer__Group__4 : rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 ; - public final void rule__ActionServer__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9289:1: ( rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 ) - // InternalRos.g:9290:2: rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 - { - pushFollow(FOLLOW_10); - rule__ActionServer__Group__4__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionServer__Group__5(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__4" - - - // $ANTLR start "rule__ActionServer__Group__4__Impl" - // InternalRos.g:9297:1: rule__ActionServer__Group__4__Impl : ( 'action' ) ; - public final void rule__ActionServer__Group__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9301:1: ( ( 'action' ) ) - // InternalRos.g:9302:1: ( 'action' ) - { - // InternalRos.g:9302:1: ( 'action' ) - // InternalRos.g:9303:2: 'action' - { - before(grammarAccess.getActionServerAccess().getActionKeyword_4()); - match(input,37,FOLLOW_2); - after(grammarAccess.getActionServerAccess().getActionKeyword_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__4__Impl" - - - // $ANTLR start "rule__ActionServer__Group__5" - // InternalRos.g:9312:1: rule__ActionServer__Group__5 : rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 ; - public final void rule__ActionServer__Group__5() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9316:1: ( rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 ) - // InternalRos.g:9317:2: rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 - { - pushFollow(FOLLOW_39); - rule__ActionServer__Group__5__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionServer__Group__6(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__5" - - - // $ANTLR start "rule__ActionServer__Group__5__Impl" - // InternalRos.g:9324:1: rule__ActionServer__Group__5__Impl : ( ( rule__ActionServer__ActionAssignment_5 ) ) ; - public final void rule__ActionServer__Group__5__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9328:1: ( ( ( rule__ActionServer__ActionAssignment_5 ) ) ) - // InternalRos.g:9329:1: ( ( rule__ActionServer__ActionAssignment_5 ) ) - { - // InternalRos.g:9329:1: ( ( rule__ActionServer__ActionAssignment_5 ) ) - // InternalRos.g:9330:2: ( rule__ActionServer__ActionAssignment_5 ) - { - before(grammarAccess.getActionServerAccess().getActionAssignment_5()); - // InternalRos.g:9331:2: ( rule__ActionServer__ActionAssignment_5 ) - // InternalRos.g:9331:3: rule__ActionServer__ActionAssignment_5 - { - pushFollow(FOLLOW_2); - rule__ActionServer__ActionAssignment_5(); - - state._fsp--; - - - } - - after(grammarAccess.getActionServerAccess().getActionAssignment_5()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__5__Impl" - - - // $ANTLR start "rule__ActionServer__Group__6" - // InternalRos.g:9339:1: rule__ActionServer__Group__6 : rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 ; - public final void rule__ActionServer__Group__6() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9343:1: ( rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 ) - // InternalRos.g:9344:2: rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 - { - pushFollow(FOLLOW_39); - rule__ActionServer__Group__6__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionServer__Group__7(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__6" - - - // $ANTLR start "rule__ActionServer__Group__6__Impl" - // InternalRos.g:9351:1: rule__ActionServer__Group__6__Impl : ( ( rule__ActionServer__Group_6__0 )? ) ; - public final void rule__ActionServer__Group__6__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9355:1: ( ( ( rule__ActionServer__Group_6__0 )? ) ) - // InternalRos.g:9356:1: ( ( rule__ActionServer__Group_6__0 )? ) - { - // InternalRos.g:9356:1: ( ( rule__ActionServer__Group_6__0 )? ) - // InternalRos.g:9357:2: ( rule__ActionServer__Group_6__0 )? - { - before(grammarAccess.getActionServerAccess().getGroup_6()); - // InternalRos.g:9358:2: ( rule__ActionServer__Group_6__0 )? - int alt61=2; - int LA61_0 = input.LA(1); - - if ( (LA61_0==65) ) { - alt61=1; - } - switch (alt61) { - case 1 : - // InternalRos.g:9358:3: rule__ActionServer__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__ActionServer__Group_6__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getActionServerAccess().getGroup_6()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__6__Impl" - - - // $ANTLR start "rule__ActionServer__Group__7" - // InternalRos.g:9366:1: rule__ActionServer__Group__7 : rule__ActionServer__Group__7__Impl ; - public final void rule__ActionServer__Group__7() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9370:1: ( rule__ActionServer__Group__7__Impl ) - // InternalRos.g:9371:2: rule__ActionServer__Group__7__Impl - { - pushFollow(FOLLOW_2); - rule__ActionServer__Group__7__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__7" - - - // $ANTLR start "rule__ActionServer__Group__7__Impl" - // InternalRos.g:9377:1: rule__ActionServer__Group__7__Impl : ( '}' ) ; - public final void rule__ActionServer__Group__7__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9381:1: ( ( '}' ) ) - // InternalRos.g:9382:1: ( '}' ) - { - // InternalRos.g:9382:1: ( '}' ) - // InternalRos.g:9383:2: '}' - { - before(grammarAccess.getActionServerAccess().getRightCurlyBracketKeyword_7()); - match(input,42,FOLLOW_2); - after(grammarAccess.getActionServerAccess().getRightCurlyBracketKeyword_7()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group__7__Impl" - - - // $ANTLR start "rule__ActionServer__Group_6__0" - // InternalRos.g:9393:1: rule__ActionServer__Group_6__0 : rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 ; - public final void rule__ActionServer__Group_6__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9397:1: ( rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 ) - // InternalRos.g:9398:2: rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 - { - pushFollow(FOLLOW_40); - rule__ActionServer__Group_6__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionServer__Group_6__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group_6__0" - - - // $ANTLR start "rule__ActionServer__Group_6__0__Impl" - // InternalRos.g:9405:1: rule__ActionServer__Group_6__0__Impl : ( 'namespace' ) ; - public final void rule__ActionServer__Group_6__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9409:1: ( ( 'namespace' ) ) - // InternalRos.g:9410:1: ( 'namespace' ) - { - // InternalRos.g:9410:1: ( 'namespace' ) - // InternalRos.g:9411:2: 'namespace' - { - before(grammarAccess.getActionServerAccess().getNamespaceKeyword_6_0()); - match(input,65,FOLLOW_2); - after(grammarAccess.getActionServerAccess().getNamespaceKeyword_6_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group_6__0__Impl" - - - // $ANTLR start "rule__ActionServer__Group_6__1" - // InternalRos.g:9420:1: rule__ActionServer__Group_6__1 : rule__ActionServer__Group_6__1__Impl ; - public final void rule__ActionServer__Group_6__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9424:1: ( rule__ActionServer__Group_6__1__Impl ) - // InternalRos.g:9425:2: rule__ActionServer__Group_6__1__Impl - { - pushFollow(FOLLOW_2); - rule__ActionServer__Group_6__1__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group_6__1" - - - // $ANTLR start "rule__ActionServer__Group_6__1__Impl" - // InternalRos.g:9431:1: rule__ActionServer__Group_6__1__Impl : ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) ; - public final void rule__ActionServer__Group_6__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9435:1: ( ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) ) - // InternalRos.g:9436:1: ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) - { - // InternalRos.g:9436:1: ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) - // InternalRos.g:9437:2: ( rule__ActionServer__NamespaceAssignment_6_1 ) - { - before(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); - // InternalRos.g:9438:2: ( rule__ActionServer__NamespaceAssignment_6_1 ) - // InternalRos.g:9438:3: rule__ActionServer__NamespaceAssignment_6_1 - { - pushFollow(FOLLOW_2); - rule__ActionServer__NamespaceAssignment_6_1(); - - state._fsp--; - - - } - - after(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionServer__Group_6__1__Impl" - - - // $ANTLR start "rule__ActionClient__Group__0" - // InternalRos.g:9447:1: rule__ActionClient__Group__0 : rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 ; - public final void rule__ActionClient__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9451:1: ( rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 ) - // InternalRos.g:9452:2: rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 - { - pushFollow(FOLLOW_4); - rule__ActionClient__Group__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionClient__Group__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__0" - - - // $ANTLR start "rule__ActionClient__Group__0__Impl" - // InternalRos.g:9459:1: rule__ActionClient__Group__0__Impl : ( 'ActionClient' ) ; - public final void rule__ActionClient__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9463:1: ( ( 'ActionClient' ) ) - // InternalRos.g:9464:1: ( 'ActionClient' ) - { - // InternalRos.g:9464:1: ( 'ActionClient' ) - // InternalRos.g:9465:2: 'ActionClient' - { - before(grammarAccess.getActionClientAccess().getActionClientKeyword_0()); - match(input,70,FOLLOW_2); - after(grammarAccess.getActionClientAccess().getActionClientKeyword_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__0__Impl" - - - // $ANTLR start "rule__ActionClient__Group__1" - // InternalRos.g:9474:1: rule__ActionClient__Group__1 : rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 ; - public final void rule__ActionClient__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9478:1: ( rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 ) - // InternalRos.g:9479:2: rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 - { - pushFollow(FOLLOW_29); - rule__ActionClient__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionClient__Group__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__1" - - - // $ANTLR start "rule__ActionClient__Group__1__Impl" - // InternalRos.g:9486:1: rule__ActionClient__Group__1__Impl : ( '{' ) ; - public final void rule__ActionClient__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9490:1: ( ( '{' ) ) - // InternalRos.g:9491:1: ( '{' ) - { - // InternalRos.g:9491:1: ( '{' ) - // InternalRos.g:9492:2: '{' - { - before(grammarAccess.getActionClientAccess().getLeftCurlyBracketKeyword_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getActionClientAccess().getLeftCurlyBracketKeyword_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__1__Impl" - - - // $ANTLR start "rule__ActionClient__Group__2" - // InternalRos.g:9501:1: rule__ActionClient__Group__2 : rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 ; - public final void rule__ActionClient__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9505:1: ( rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 ) - // InternalRos.g:9506:2: rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 - { - pushFollow(FOLLOW_10); - rule__ActionClient__Group__2__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionClient__Group__3(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__2" - - - // $ANTLR start "rule__ActionClient__Group__2__Impl" - // InternalRos.g:9513:1: rule__ActionClient__Group__2__Impl : ( 'name' ) ; - public final void rule__ActionClient__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9517:1: ( ( 'name' ) ) - // InternalRos.g:9518:1: ( 'name' ) - { - // InternalRos.g:9518:1: ( 'name' ) - // InternalRos.g:9519:2: 'name' - { - before(grammarAccess.getActionClientAccess().getNameKeyword_2()); - match(input,33,FOLLOW_2); - after(grammarAccess.getActionClientAccess().getNameKeyword_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__2__Impl" - - - // $ANTLR start "rule__ActionClient__Group__3" - // InternalRos.g:9528:1: rule__ActionClient__Group__3 : rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 ; - public final void rule__ActionClient__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9532:1: ( rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 ) - // InternalRos.g:9533:2: rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 - { - pushFollow(FOLLOW_42); - rule__ActionClient__Group__3__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionClient__Group__4(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__3" - - - // $ANTLR start "rule__ActionClient__Group__3__Impl" - // InternalRos.g:9540:1: rule__ActionClient__Group__3__Impl : ( ( rule__ActionClient__NameAssignment_3 ) ) ; - public final void rule__ActionClient__Group__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9544:1: ( ( ( rule__ActionClient__NameAssignment_3 ) ) ) - // InternalRos.g:9545:1: ( ( rule__ActionClient__NameAssignment_3 ) ) - { - // InternalRos.g:9545:1: ( ( rule__ActionClient__NameAssignment_3 ) ) - // InternalRos.g:9546:2: ( rule__ActionClient__NameAssignment_3 ) - { - before(grammarAccess.getActionClientAccess().getNameAssignment_3()); - // InternalRos.g:9547:2: ( rule__ActionClient__NameAssignment_3 ) - // InternalRos.g:9547:3: rule__ActionClient__NameAssignment_3 - { - pushFollow(FOLLOW_2); - rule__ActionClient__NameAssignment_3(); - - state._fsp--; - - - } - - after(grammarAccess.getActionClientAccess().getNameAssignment_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__3__Impl" - - - // $ANTLR start "rule__ActionClient__Group__4" - // InternalRos.g:9555:1: rule__ActionClient__Group__4 : rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 ; - public final void rule__ActionClient__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9559:1: ( rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 ) - // InternalRos.g:9560:2: rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 - { - pushFollow(FOLLOW_10); - rule__ActionClient__Group__4__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionClient__Group__5(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__4" - - - // $ANTLR start "rule__ActionClient__Group__4__Impl" - // InternalRos.g:9567:1: rule__ActionClient__Group__4__Impl : ( 'action' ) ; - public final void rule__ActionClient__Group__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9571:1: ( ( 'action' ) ) - // InternalRos.g:9572:1: ( 'action' ) - { - // InternalRos.g:9572:1: ( 'action' ) - // InternalRos.g:9573:2: 'action' - { - before(grammarAccess.getActionClientAccess().getActionKeyword_4()); - match(input,37,FOLLOW_2); - after(grammarAccess.getActionClientAccess().getActionKeyword_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__4__Impl" - - - // $ANTLR start "rule__ActionClient__Group__5" - // InternalRos.g:9582:1: rule__ActionClient__Group__5 : rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 ; - public final void rule__ActionClient__Group__5() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9586:1: ( rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 ) - // InternalRos.g:9587:2: rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 - { - pushFollow(FOLLOW_39); - rule__ActionClient__Group__5__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionClient__Group__6(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__5" - - - // $ANTLR start "rule__ActionClient__Group__5__Impl" - // InternalRos.g:9594:1: rule__ActionClient__Group__5__Impl : ( ( rule__ActionClient__ActionAssignment_5 ) ) ; - public final void rule__ActionClient__Group__5__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9598:1: ( ( ( rule__ActionClient__ActionAssignment_5 ) ) ) - // InternalRos.g:9599:1: ( ( rule__ActionClient__ActionAssignment_5 ) ) - { - // InternalRos.g:9599:1: ( ( rule__ActionClient__ActionAssignment_5 ) ) - // InternalRos.g:9600:2: ( rule__ActionClient__ActionAssignment_5 ) - { - before(grammarAccess.getActionClientAccess().getActionAssignment_5()); - // InternalRos.g:9601:2: ( rule__ActionClient__ActionAssignment_5 ) - // InternalRos.g:9601:3: rule__ActionClient__ActionAssignment_5 - { - pushFollow(FOLLOW_2); - rule__ActionClient__ActionAssignment_5(); - - state._fsp--; - - - } - - after(grammarAccess.getActionClientAccess().getActionAssignment_5()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__5__Impl" - - - // $ANTLR start "rule__ActionClient__Group__6" - // InternalRos.g:9609:1: rule__ActionClient__Group__6 : rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 ; - public final void rule__ActionClient__Group__6() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9613:1: ( rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 ) - // InternalRos.g:9614:2: rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 - { - pushFollow(FOLLOW_39); - rule__ActionClient__Group__6__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionClient__Group__7(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__6" - - - // $ANTLR start "rule__ActionClient__Group__6__Impl" - // InternalRos.g:9621:1: rule__ActionClient__Group__6__Impl : ( ( rule__ActionClient__Group_6__0 )? ) ; - public final void rule__ActionClient__Group__6__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9625:1: ( ( ( rule__ActionClient__Group_6__0 )? ) ) - // InternalRos.g:9626:1: ( ( rule__ActionClient__Group_6__0 )? ) - { - // InternalRos.g:9626:1: ( ( rule__ActionClient__Group_6__0 )? ) - // InternalRos.g:9627:2: ( rule__ActionClient__Group_6__0 )? - { - before(grammarAccess.getActionClientAccess().getGroup_6()); - // InternalRos.g:9628:2: ( rule__ActionClient__Group_6__0 )? - int alt62=2; - int LA62_0 = input.LA(1); - - if ( (LA62_0==65) ) { - alt62=1; - } - switch (alt62) { - case 1 : - // InternalRos.g:9628:3: rule__ActionClient__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__ActionClient__Group_6__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getActionClientAccess().getGroup_6()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__6__Impl" - - - // $ANTLR start "rule__ActionClient__Group__7" - // InternalRos.g:9636:1: rule__ActionClient__Group__7 : rule__ActionClient__Group__7__Impl ; - public final void rule__ActionClient__Group__7() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9640:1: ( rule__ActionClient__Group__7__Impl ) - // InternalRos.g:9641:2: rule__ActionClient__Group__7__Impl - { - pushFollow(FOLLOW_2); - rule__ActionClient__Group__7__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__7" - - - // $ANTLR start "rule__ActionClient__Group__7__Impl" - // InternalRos.g:9647:1: rule__ActionClient__Group__7__Impl : ( '}' ) ; - public final void rule__ActionClient__Group__7__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9651:1: ( ( '}' ) ) - // InternalRos.g:9652:1: ( '}' ) - { - // InternalRos.g:9652:1: ( '}' ) - // InternalRos.g:9653:2: '}' - { - before(grammarAccess.getActionClientAccess().getRightCurlyBracketKeyword_7()); - match(input,42,FOLLOW_2); - after(grammarAccess.getActionClientAccess().getRightCurlyBracketKeyword_7()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group__7__Impl" - - - // $ANTLR start "rule__ActionClient__Group_6__0" - // InternalRos.g:9663:1: rule__ActionClient__Group_6__0 : rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 ; - public final void rule__ActionClient__Group_6__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9667:1: ( rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 ) - // InternalRos.g:9668:2: rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 - { - pushFollow(FOLLOW_40); - rule__ActionClient__Group_6__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ActionClient__Group_6__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group_6__0" - - - // $ANTLR start "rule__ActionClient__Group_6__0__Impl" - // InternalRos.g:9675:1: rule__ActionClient__Group_6__0__Impl : ( 'namespace' ) ; - public final void rule__ActionClient__Group_6__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9679:1: ( ( 'namespace' ) ) - // InternalRos.g:9680:1: ( 'namespace' ) - { - // InternalRos.g:9680:1: ( 'namespace' ) - // InternalRos.g:9681:2: 'namespace' - { - before(grammarAccess.getActionClientAccess().getNamespaceKeyword_6_0()); - match(input,65,FOLLOW_2); - after(grammarAccess.getActionClientAccess().getNamespaceKeyword_6_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group_6__0__Impl" - - - // $ANTLR start "rule__ActionClient__Group_6__1" - // InternalRos.g:9690:1: rule__ActionClient__Group_6__1 : rule__ActionClient__Group_6__1__Impl ; - public final void rule__ActionClient__Group_6__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9694:1: ( rule__ActionClient__Group_6__1__Impl ) - // InternalRos.g:9695:2: rule__ActionClient__Group_6__1__Impl - { - pushFollow(FOLLOW_2); - rule__ActionClient__Group_6__1__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group_6__1" - - - // $ANTLR start "rule__ActionClient__Group_6__1__Impl" - // InternalRos.g:9701:1: rule__ActionClient__Group_6__1__Impl : ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) ; - public final void rule__ActionClient__Group_6__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9705:1: ( ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) ) - // InternalRos.g:9706:1: ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) - { - // InternalRos.g:9706:1: ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) - // InternalRos.g:9707:2: ( rule__ActionClient__NamespaceAssignment_6_1 ) - { - before(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); - // InternalRos.g:9708:2: ( rule__ActionClient__NamespaceAssignment_6_1 ) - // InternalRos.g:9708:3: rule__ActionClient__NamespaceAssignment_6_1 - { - pushFollow(FOLLOW_2); - rule__ActionClient__NamespaceAssignment_6_1(); - - state._fsp--; - - - } - - after(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ActionClient__Group_6__1__Impl" - - - // $ANTLR start "rule__ExternalDependency__Group__0" - // InternalRos.g:9717: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 { - // InternalRos.g:9721:1: ( rule__ExternalDependency__Group__0__Impl rule__ExternalDependency__Group__1 ) - // InternalRos.g:9722:2: rule__ExternalDependency__Group__0__Impl rule__ExternalDependency__Group__1 - { - pushFollow(FOLLOW_19); - 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" - // InternalRos.g:9729:1: rule__ExternalDependency__Group__0__Impl : ( () ) ; - public final void rule__ExternalDependency__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9733:1: ( ( () ) ) - // InternalRos.g:9734:1: ( () ) - { - // InternalRos.g:9734:1: ( () ) - // InternalRos.g:9735:2: () - { - before(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); - // InternalRos.g:9736:2: () - // InternalRos.g:9736:3: - { - } - - after(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); - - } - - - } - - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ExternalDependency__Group__0__Impl" - - - // $ANTLR start "rule__ExternalDependency__Group__1" - // InternalRos.g:9744: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 { - // InternalRos.g:9748:1: ( rule__ExternalDependency__Group__1__Impl rule__ExternalDependency__Group__2 ) - // InternalRos.g:9749:2: rule__ExternalDependency__Group__1__Impl rule__ExternalDependency__Group__2 - { - pushFollow(FOLLOW_10); - 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" - // InternalRos.g:9756:1: rule__ExternalDependency__Group__1__Impl : ( 'ExternalDependency' ) ; - public final void rule__ExternalDependency__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9760:1: ( ( 'ExternalDependency' ) ) - // InternalRos.g:9761:1: ( 'ExternalDependency' ) - { - // InternalRos.g:9761:1: ( 'ExternalDependency' ) - // InternalRos.g:9762:2: 'ExternalDependency' - { - before(grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); - match(input,71,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" - // InternalRos.g:9771:1: rule__ExternalDependency__Group__2 : rule__ExternalDependency__Group__2__Impl ; - public final void rule__ExternalDependency__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9775:1: ( rule__ExternalDependency__Group__2__Impl ) - // InternalRos.g:9776: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" - // InternalRos.g:9782:1: rule__ExternalDependency__Group__2__Impl : ( ( rule__ExternalDependency__NameAssignment_2 ) ) ; - public final void rule__ExternalDependency__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9786:1: ( ( ( rule__ExternalDependency__NameAssignment_2 ) ) ) - // InternalRos.g:9787:1: ( ( rule__ExternalDependency__NameAssignment_2 ) ) - { - // InternalRos.g:9787:1: ( ( rule__ExternalDependency__NameAssignment_2 ) ) - // InternalRos.g:9788:2: ( rule__ExternalDependency__NameAssignment_2 ) - { - before(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); - // InternalRos.g:9789:2: ( rule__ExternalDependency__NameAssignment_2 ) - // InternalRos.g:9789: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__GlobalNamespace__Group__0" - // InternalRos.g:9798:1: rule__GlobalNamespace__Group__0 : rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 ; - public final void rule__GlobalNamespace__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9802:1: ( rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 ) - // InternalRos.g:9803:2: rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 - { - pushFollow(FOLLOW_43); - rule__GlobalNamespace__Group__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group__0" - - - // $ANTLR start "rule__GlobalNamespace__Group__0__Impl" - // InternalRos.g:9810:1: rule__GlobalNamespace__Group__0__Impl : ( () ) ; - public final void rule__GlobalNamespace__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9814:1: ( ( () ) ) - // InternalRos.g:9815:1: ( () ) - { - // InternalRos.g:9815:1: ( () ) - // InternalRos.g:9816:2: () - { - before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); - // InternalRos.g:9817:2: () - // InternalRos.g:9817:3: - { - } - - after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); - - } - - - } - - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group__0__Impl" - - - // $ANTLR start "rule__GlobalNamespace__Group__1" - // InternalRos.g:9825:1: rule__GlobalNamespace__Group__1 : rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 ; - public final void rule__GlobalNamespace__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9829:1: ( rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 ) - // InternalRos.g:9830:2: rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 - { - pushFollow(FOLLOW_4); - rule__GlobalNamespace__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group__1" - - - // $ANTLR start "rule__GlobalNamespace__Group__1__Impl" - // InternalRos.g:9837:1: rule__GlobalNamespace__Group__1__Impl : ( 'GlobalNamespace' ) ; - public final void rule__GlobalNamespace__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9841:1: ( ( 'GlobalNamespace' ) ) - // InternalRos.g:9842:1: ( 'GlobalNamespace' ) - { - // InternalRos.g:9842:1: ( 'GlobalNamespace' ) - // InternalRos.g:9843:2: 'GlobalNamespace' - { - before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); - match(input,72,FOLLOW_2); - after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group__1__Impl" - - - // $ANTLR start "rule__GlobalNamespace__Group__2" - // InternalRos.g:9852:1: rule__GlobalNamespace__Group__2 : rule__GlobalNamespace__Group__2__Impl rule__GlobalNamespace__Group__3 ; - public final void rule__GlobalNamespace__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9856:1: ( rule__GlobalNamespace__Group__2__Impl rule__GlobalNamespace__Group__3 ) - // InternalRos.g:9857:2: rule__GlobalNamespace__Group__2__Impl rule__GlobalNamespace__Group__3 - { - pushFollow(FOLLOW_44); - rule__GlobalNamespace__Group__2__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group__3(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group__2" - - - // $ANTLR start "rule__GlobalNamespace__Group__2__Impl" - // InternalRos.g:9864:1: rule__GlobalNamespace__Group__2__Impl : ( '{' ) ; - public final void rule__GlobalNamespace__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9868:1: ( ( '{' ) ) - // InternalRos.g:9869:1: ( '{' ) - { - // InternalRos.g:9869:1: ( '{' ) - // InternalRos.g:9870:2: '{' - { - before(grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_2()); - match(input,41,FOLLOW_2); - after(grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group__2__Impl" - - - // $ANTLR start "rule__GlobalNamespace__Group__3" - // InternalRos.g:9879:1: rule__GlobalNamespace__Group__3 : rule__GlobalNamespace__Group__3__Impl rule__GlobalNamespace__Group__4 ; - public final void rule__GlobalNamespace__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9883:1: ( rule__GlobalNamespace__Group__3__Impl rule__GlobalNamespace__Group__4 ) - // InternalRos.g:9884:2: rule__GlobalNamespace__Group__3__Impl rule__GlobalNamespace__Group__4 - { - pushFollow(FOLLOW_44); - rule__GlobalNamespace__Group__3__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group__4(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group__3" - - - // $ANTLR start "rule__GlobalNamespace__Group__3__Impl" - // InternalRos.g:9891:1: rule__GlobalNamespace__Group__3__Impl : ( ( rule__GlobalNamespace__Group_3__0 )? ) ; - public final void rule__GlobalNamespace__Group__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9895:1: ( ( ( rule__GlobalNamespace__Group_3__0 )? ) ) - // InternalRos.g:9896:1: ( ( rule__GlobalNamespace__Group_3__0 )? ) - { - // InternalRos.g:9896:1: ( ( rule__GlobalNamespace__Group_3__0 )? ) - // InternalRos.g:9897:2: ( rule__GlobalNamespace__Group_3__0 )? - { - before(grammarAccess.getGlobalNamespaceAccess().getGroup_3()); - // InternalRos.g:9898:2: ( rule__GlobalNamespace__Group_3__0 )? - int alt63=2; - int LA63_0 = input.LA(1); - - if ( (LA63_0==73) ) { - alt63=1; - } - switch (alt63) { - case 1 : - // InternalRos.g:9898:3: rule__GlobalNamespace__Group_3__0 - { - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group_3__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getGlobalNamespaceAccess().getGroup_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group__3__Impl" - - - // $ANTLR start "rule__GlobalNamespace__Group__4" - // InternalRos.g:9906:1: rule__GlobalNamespace__Group__4 : rule__GlobalNamespace__Group__4__Impl ; - public final void rule__GlobalNamespace__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9910:1: ( rule__GlobalNamespace__Group__4__Impl ) - // InternalRos.g:9911:2: rule__GlobalNamespace__Group__4__Impl - { - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group__4__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group__4" - - - // $ANTLR start "rule__GlobalNamespace__Group__4__Impl" - // InternalRos.g:9917:1: rule__GlobalNamespace__Group__4__Impl : ( '}' ) ; - public final void rule__GlobalNamespace__Group__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9921:1: ( ( '}' ) ) - // InternalRos.g:9922:1: ( '}' ) - { - // InternalRos.g:9922:1: ( '}' ) - // InternalRos.g:9923:2: '}' - { - before(grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group__4__Impl" - - - // $ANTLR start "rule__GlobalNamespace__Group_3__0" - // InternalRos.g:9933:1: rule__GlobalNamespace__Group_3__0 : rule__GlobalNamespace__Group_3__0__Impl rule__GlobalNamespace__Group_3__1 ; - public final void rule__GlobalNamespace__Group_3__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9937:1: ( rule__GlobalNamespace__Group_3__0__Impl rule__GlobalNamespace__Group_3__1 ) - // InternalRos.g:9938:2: rule__GlobalNamespace__Group_3__0__Impl rule__GlobalNamespace__Group_3__1 - { - pushFollow(FOLLOW_4); - rule__GlobalNamespace__Group_3__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group_3__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3__0" - - - // $ANTLR start "rule__GlobalNamespace__Group_3__0__Impl" - // InternalRos.g:9945:1: rule__GlobalNamespace__Group_3__0__Impl : ( 'parts' ) ; - public final void rule__GlobalNamespace__Group_3__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9949:1: ( ( 'parts' ) ) - // InternalRos.g:9950:1: ( 'parts' ) - { - // InternalRos.g:9950:1: ( 'parts' ) - // InternalRos.g:9951:2: 'parts' - { - before(grammarAccess.getGlobalNamespaceAccess().getPartsKeyword_3_0()); - match(input,73,FOLLOW_2); - after(grammarAccess.getGlobalNamespaceAccess().getPartsKeyword_3_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3__0__Impl" - - - // $ANTLR start "rule__GlobalNamespace__Group_3__1" - // InternalRos.g:9960:1: rule__GlobalNamespace__Group_3__1 : rule__GlobalNamespace__Group_3__1__Impl rule__GlobalNamespace__Group_3__2 ; - public final void rule__GlobalNamespace__Group_3__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9964:1: ( rule__GlobalNamespace__Group_3__1__Impl rule__GlobalNamespace__Group_3__2 ) - // InternalRos.g:9965:2: rule__GlobalNamespace__Group_3__1__Impl rule__GlobalNamespace__Group_3__2 - { - pushFollow(FOLLOW_45); - rule__GlobalNamespace__Group_3__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group_3__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3__1" - - - // $ANTLR start "rule__GlobalNamespace__Group_3__1__Impl" - // InternalRos.g:9972:1: rule__GlobalNamespace__Group_3__1__Impl : ( '{' ) ; - public final void rule__GlobalNamespace__Group_3__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9976:1: ( ( '{' ) ) - // InternalRos.g:9977:1: ( '{' ) - { - // InternalRos.g:9977:1: ( '{' ) - // InternalRos.g:9978:2: '{' - { - before(grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3__1__Impl" - - - // $ANTLR start "rule__GlobalNamespace__Group_3__2" - // InternalRos.g:9987:1: rule__GlobalNamespace__Group_3__2 : rule__GlobalNamespace__Group_3__2__Impl rule__GlobalNamespace__Group_3__3 ; - public final void rule__GlobalNamespace__Group_3__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:9991:1: ( rule__GlobalNamespace__Group_3__2__Impl rule__GlobalNamespace__Group_3__3 ) - // InternalRos.g:9992:2: rule__GlobalNamespace__Group_3__2__Impl rule__GlobalNamespace__Group_3__3 - { - pushFollow(FOLLOW_13); - rule__GlobalNamespace__Group_3__2__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group_3__3(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3__2" - - - // $ANTLR start "rule__GlobalNamespace__Group_3__2__Impl" - // InternalRos.g:9999:1: rule__GlobalNamespace__Group_3__2__Impl : ( ( rule__GlobalNamespace__PartsAssignment_3_2 ) ) ; - public final void rule__GlobalNamespace__Group_3__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10003:1: ( ( ( rule__GlobalNamespace__PartsAssignment_3_2 ) ) ) - // InternalRos.g:10004:1: ( ( rule__GlobalNamespace__PartsAssignment_3_2 ) ) - { - // InternalRos.g:10004:1: ( ( rule__GlobalNamespace__PartsAssignment_3_2 ) ) - // InternalRos.g:10005:2: ( rule__GlobalNamespace__PartsAssignment_3_2 ) - { - before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_3_2()); - // InternalRos.g:10006:2: ( rule__GlobalNamespace__PartsAssignment_3_2 ) - // InternalRos.g:10006:3: rule__GlobalNamespace__PartsAssignment_3_2 - { - pushFollow(FOLLOW_2); - rule__GlobalNamespace__PartsAssignment_3_2(); - - state._fsp--; - - - } - - after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_3_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3__2__Impl" - - - // $ANTLR start "rule__GlobalNamespace__Group_3__3" - // InternalRos.g:10014:1: rule__GlobalNamespace__Group_3__3 : rule__GlobalNamespace__Group_3__3__Impl rule__GlobalNamespace__Group_3__4 ; - public final void rule__GlobalNamespace__Group_3__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10018:1: ( rule__GlobalNamespace__Group_3__3__Impl rule__GlobalNamespace__Group_3__4 ) - // InternalRos.g:10019:2: rule__GlobalNamespace__Group_3__3__Impl rule__GlobalNamespace__Group_3__4 - { - pushFollow(FOLLOW_13); - rule__GlobalNamespace__Group_3__3__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group_3__4(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3__3" - - - // $ANTLR start "rule__GlobalNamespace__Group_3__3__Impl" - // InternalRos.g:10026:1: rule__GlobalNamespace__Group_3__3__Impl : ( ( rule__GlobalNamespace__Group_3_3__0 )* ) ; - public final void rule__GlobalNamespace__Group_3__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10030:1: ( ( ( rule__GlobalNamespace__Group_3_3__0 )* ) ) - // InternalRos.g:10031:1: ( ( rule__GlobalNamespace__Group_3_3__0 )* ) - { - // InternalRos.g:10031:1: ( ( rule__GlobalNamespace__Group_3_3__0 )* ) - // InternalRos.g:10032:2: ( rule__GlobalNamespace__Group_3_3__0 )* - { - before(grammarAccess.getGlobalNamespaceAccess().getGroup_3_3()); - // InternalRos.g:10033:2: ( rule__GlobalNamespace__Group_3_3__0 )* - loop64: - do { - int alt64=2; - int LA64_0 = input.LA(1); - - if ( (LA64_0==43) ) { - alt64=1; - } - - - switch (alt64) { - case 1 : - // InternalRos.g:10033:3: rule__GlobalNamespace__Group_3_3__0 - { - pushFollow(FOLLOW_7); - rule__GlobalNamespace__Group_3_3__0(); - - state._fsp--; - - - } - break; - - default : - break loop64; - } - } while (true); - - after(grammarAccess.getGlobalNamespaceAccess().getGroup_3_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3__3__Impl" - - - // $ANTLR start "rule__GlobalNamespace__Group_3__4" - // InternalRos.g:10041:1: rule__GlobalNamespace__Group_3__4 : rule__GlobalNamespace__Group_3__4__Impl ; - public final void rule__GlobalNamespace__Group_3__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10045:1: ( rule__GlobalNamespace__Group_3__4__Impl ) - // InternalRos.g:10046:2: rule__GlobalNamespace__Group_3__4__Impl - { - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group_3__4__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3__4" - - - // $ANTLR start "rule__GlobalNamespace__Group_3__4__Impl" - // InternalRos.g:10052:1: rule__GlobalNamespace__Group_3__4__Impl : ( '}' ) ; - public final void rule__GlobalNamespace__Group_3__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10056:1: ( ( '}' ) ) - // InternalRos.g:10057:1: ( '}' ) - { - // InternalRos.g:10057:1: ( '}' ) - // InternalRos.g:10058:2: '}' - { - before(grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_3_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_3_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3__4__Impl" - - - // $ANTLR start "rule__GlobalNamespace__Group_3_3__0" - // InternalRos.g:10068:1: rule__GlobalNamespace__Group_3_3__0 : rule__GlobalNamespace__Group_3_3__0__Impl rule__GlobalNamespace__Group_3_3__1 ; - public final void rule__GlobalNamespace__Group_3_3__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10072:1: ( rule__GlobalNamespace__Group_3_3__0__Impl rule__GlobalNamespace__Group_3_3__1 ) - // InternalRos.g:10073:2: rule__GlobalNamespace__Group_3_3__0__Impl rule__GlobalNamespace__Group_3_3__1 - { - pushFollow(FOLLOW_45); - rule__GlobalNamespace__Group_3_3__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group_3_3__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3_3__0" - - - // $ANTLR start "rule__GlobalNamespace__Group_3_3__0__Impl" - // InternalRos.g:10080:1: rule__GlobalNamespace__Group_3_3__0__Impl : ( ',' ) ; - public final void rule__GlobalNamespace__Group_3_3__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10084:1: ( ( ',' ) ) - // InternalRos.g:10085:1: ( ',' ) - { - // InternalRos.g:10085:1: ( ',' ) - // InternalRos.g:10086:2: ',' - { - before(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_3_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_3_3_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3_3__0__Impl" - - - // $ANTLR start "rule__GlobalNamespace__Group_3_3__1" - // InternalRos.g:10095:1: rule__GlobalNamespace__Group_3_3__1 : rule__GlobalNamespace__Group_3_3__1__Impl ; - public final void rule__GlobalNamespace__Group_3_3__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10099:1: ( rule__GlobalNamespace__Group_3_3__1__Impl ) - // InternalRos.g:10100:2: rule__GlobalNamespace__Group_3_3__1__Impl - { - pushFollow(FOLLOW_2); - rule__GlobalNamespace__Group_3_3__1__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3_3__1" - - - // $ANTLR start "rule__GlobalNamespace__Group_3_3__1__Impl" - // InternalRos.g:10106:1: rule__GlobalNamespace__Group_3_3__1__Impl : ( ( rule__GlobalNamespace__PartsAssignment_3_3_1 ) ) ; - public final void rule__GlobalNamespace__Group_3_3__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10110:1: ( ( ( rule__GlobalNamespace__PartsAssignment_3_3_1 ) ) ) - // InternalRos.g:10111:1: ( ( rule__GlobalNamespace__PartsAssignment_3_3_1 ) ) - { - // InternalRos.g:10111:1: ( ( rule__GlobalNamespace__PartsAssignment_3_3_1 ) ) - // InternalRos.g:10112:2: ( rule__GlobalNamespace__PartsAssignment_3_3_1 ) - { - before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_3_3_1()); - // InternalRos.g:10113:2: ( rule__GlobalNamespace__PartsAssignment_3_3_1 ) - // InternalRos.g:10113:3: rule__GlobalNamespace__PartsAssignment_3_3_1 - { - pushFollow(FOLLOW_2); - rule__GlobalNamespace__PartsAssignment_3_3_1(); - - state._fsp--; - - - } - - after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_3_3_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__GlobalNamespace__Group_3_3__1__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group__0" - // InternalRos.g:10122:1: rule__RelativeNamespace_Impl__Group__0 : rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 ; - public final void rule__RelativeNamespace_Impl__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10126:1: ( rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 ) - // InternalRos.g:10127:2: rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 - { - pushFollow(FOLLOW_46); - rule__RelativeNamespace_Impl__Group__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group__0" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group__0__Impl" - // InternalRos.g:10134:1: rule__RelativeNamespace_Impl__Group__0__Impl : ( () ) ; - public final void rule__RelativeNamespace_Impl__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10138:1: ( ( () ) ) - // InternalRos.g:10139:1: ( () ) - { - // InternalRos.g:10139:1: ( () ) - // InternalRos.g:10140:2: () - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); - // InternalRos.g:10141:2: () - // InternalRos.g:10141:3: - { - } - - after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); - - } - - - } - - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group__0__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group__1" - // InternalRos.g:10149:1: rule__RelativeNamespace_Impl__Group__1 : rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 ; - public final void rule__RelativeNamespace_Impl__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10153:1: ( rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 ) - // InternalRos.g:10154:2: rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 - { - pushFollow(FOLLOW_4); - rule__RelativeNamespace_Impl__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group__1" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group__1__Impl" - // InternalRos.g:10161:1: rule__RelativeNamespace_Impl__Group__1__Impl : ( 'RelativeNamespace' ) ; - public final void rule__RelativeNamespace_Impl__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10165:1: ( ( 'RelativeNamespace' ) ) - // InternalRos.g:10166:1: ( 'RelativeNamespace' ) - { - // InternalRos.g:10166:1: ( 'RelativeNamespace' ) - // InternalRos.g:10167:2: 'RelativeNamespace' - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); - match(input,74,FOLLOW_2); - after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group__1__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group__2" - // InternalRos.g:10176:1: rule__RelativeNamespace_Impl__Group__2 : rule__RelativeNamespace_Impl__Group__2__Impl rule__RelativeNamespace_Impl__Group__3 ; - public final void rule__RelativeNamespace_Impl__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10180:1: ( rule__RelativeNamespace_Impl__Group__2__Impl rule__RelativeNamespace_Impl__Group__3 ) - // InternalRos.g:10181:2: rule__RelativeNamespace_Impl__Group__2__Impl rule__RelativeNamespace_Impl__Group__3 - { - pushFollow(FOLLOW_44); - rule__RelativeNamespace_Impl__Group__2__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group__3(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group__2" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group__2__Impl" - // InternalRos.g:10188:1: rule__RelativeNamespace_Impl__Group__2__Impl : ( '{' ) ; - public final void rule__RelativeNamespace_Impl__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10192:1: ( ( '{' ) ) - // InternalRos.g:10193:1: ( '{' ) - { - // InternalRos.g:10193:1: ( '{' ) - // InternalRos.g:10194:2: '{' - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_2()); - match(input,41,FOLLOW_2); - after(grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group__2__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group__3" - // InternalRos.g:10203:1: rule__RelativeNamespace_Impl__Group__3 : rule__RelativeNamespace_Impl__Group__3__Impl rule__RelativeNamespace_Impl__Group__4 ; - public final void rule__RelativeNamespace_Impl__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10207:1: ( rule__RelativeNamespace_Impl__Group__3__Impl rule__RelativeNamespace_Impl__Group__4 ) - // InternalRos.g:10208:2: rule__RelativeNamespace_Impl__Group__3__Impl rule__RelativeNamespace_Impl__Group__4 - { - pushFollow(FOLLOW_44); - rule__RelativeNamespace_Impl__Group__3__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group__4(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group__3" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group__3__Impl" - // InternalRos.g:10215:1: rule__RelativeNamespace_Impl__Group__3__Impl : ( ( rule__RelativeNamespace_Impl__Group_3__0 )? ) ; - public final void rule__RelativeNamespace_Impl__Group__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10219:1: ( ( ( rule__RelativeNamespace_Impl__Group_3__0 )? ) ) - // InternalRos.g:10220:1: ( ( rule__RelativeNamespace_Impl__Group_3__0 )? ) - { - // InternalRos.g:10220:1: ( ( rule__RelativeNamespace_Impl__Group_3__0 )? ) - // InternalRos.g:10221:2: ( rule__RelativeNamespace_Impl__Group_3__0 )? - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_3()); - // InternalRos.g:10222:2: ( rule__RelativeNamespace_Impl__Group_3__0 )? - int alt65=2; - int LA65_0 = input.LA(1); - - if ( (LA65_0==73) ) { - alt65=1; - } - switch (alt65) { - case 1 : - // InternalRos.g:10222:3: rule__RelativeNamespace_Impl__Group_3__0 - { - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group_3__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group__3__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group__4" - // InternalRos.g:10230:1: rule__RelativeNamespace_Impl__Group__4 : rule__RelativeNamespace_Impl__Group__4__Impl ; - public final void rule__RelativeNamespace_Impl__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10234:1: ( rule__RelativeNamespace_Impl__Group__4__Impl ) - // InternalRos.g:10235:2: rule__RelativeNamespace_Impl__Group__4__Impl - { - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group__4__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group__4" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group__4__Impl" - // InternalRos.g:10241:1: rule__RelativeNamespace_Impl__Group__4__Impl : ( '}' ) ; - public final void rule__RelativeNamespace_Impl__Group__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10245:1: ( ( '}' ) ) - // InternalRos.g:10246:1: ( '}' ) - { - // InternalRos.g:10246:1: ( '}' ) - // InternalRos.g:10247:2: '}' - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group__4__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3__0" - // InternalRos.g:10257:1: rule__RelativeNamespace_Impl__Group_3__0 : rule__RelativeNamespace_Impl__Group_3__0__Impl rule__RelativeNamespace_Impl__Group_3__1 ; - public final void rule__RelativeNamespace_Impl__Group_3__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10261:1: ( rule__RelativeNamespace_Impl__Group_3__0__Impl rule__RelativeNamespace_Impl__Group_3__1 ) - // InternalRos.g:10262:2: rule__RelativeNamespace_Impl__Group_3__0__Impl rule__RelativeNamespace_Impl__Group_3__1 - { - pushFollow(FOLLOW_4); - rule__RelativeNamespace_Impl__Group_3__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group_3__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3__0" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3__0__Impl" - // InternalRos.g:10269:1: rule__RelativeNamespace_Impl__Group_3__0__Impl : ( 'parts' ) ; - public final void rule__RelativeNamespace_Impl__Group_3__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10273:1: ( ( 'parts' ) ) - // InternalRos.g:10274:1: ( 'parts' ) - { - // InternalRos.g:10274:1: ( 'parts' ) - // InternalRos.g:10275:2: 'parts' - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsKeyword_3_0()); - match(input,73,FOLLOW_2); - after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsKeyword_3_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3__0__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3__1" - // InternalRos.g:10284:1: rule__RelativeNamespace_Impl__Group_3__1 : rule__RelativeNamespace_Impl__Group_3__1__Impl rule__RelativeNamespace_Impl__Group_3__2 ; - public final void rule__RelativeNamespace_Impl__Group_3__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10288:1: ( rule__RelativeNamespace_Impl__Group_3__1__Impl rule__RelativeNamespace_Impl__Group_3__2 ) - // InternalRos.g:10289:2: rule__RelativeNamespace_Impl__Group_3__1__Impl rule__RelativeNamespace_Impl__Group_3__2 - { - pushFollow(FOLLOW_45); - rule__RelativeNamespace_Impl__Group_3__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group_3__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3__1" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3__1__Impl" - // InternalRos.g:10296:1: rule__RelativeNamespace_Impl__Group_3__1__Impl : ( '{' ) ; - public final void rule__RelativeNamespace_Impl__Group_3__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10300:1: ( ( '{' ) ) - // InternalRos.g:10301:1: ( '{' ) - { - // InternalRos.g:10301:1: ( '{' ) - // InternalRos.g:10302:2: '{' - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_3_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_3_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3__1__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3__2" - // InternalRos.g:10311:1: rule__RelativeNamespace_Impl__Group_3__2 : rule__RelativeNamespace_Impl__Group_3__2__Impl rule__RelativeNamespace_Impl__Group_3__3 ; - public final void rule__RelativeNamespace_Impl__Group_3__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10315:1: ( rule__RelativeNamespace_Impl__Group_3__2__Impl rule__RelativeNamespace_Impl__Group_3__3 ) - // InternalRos.g:10316:2: rule__RelativeNamespace_Impl__Group_3__2__Impl rule__RelativeNamespace_Impl__Group_3__3 - { - pushFollow(FOLLOW_13); - rule__RelativeNamespace_Impl__Group_3__2__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group_3__3(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3__2" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3__2__Impl" - // InternalRos.g:10323:1: rule__RelativeNamespace_Impl__Group_3__2__Impl : ( ( rule__RelativeNamespace_Impl__PartsAssignment_3_2 ) ) ; - public final void rule__RelativeNamespace_Impl__Group_3__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10327:1: ( ( ( rule__RelativeNamespace_Impl__PartsAssignment_3_2 ) ) ) - // InternalRos.g:10328:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_3_2 ) ) - { - // InternalRos.g:10328:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_3_2 ) ) - // InternalRos.g:10329:2: ( rule__RelativeNamespace_Impl__PartsAssignment_3_2 ) - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_3_2()); - // InternalRos.g:10330:2: ( rule__RelativeNamespace_Impl__PartsAssignment_3_2 ) - // InternalRos.g:10330:3: rule__RelativeNamespace_Impl__PartsAssignment_3_2 - { - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__PartsAssignment_3_2(); - - state._fsp--; - - - } - - after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_3_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3__2__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3__3" - // InternalRos.g:10338:1: rule__RelativeNamespace_Impl__Group_3__3 : rule__RelativeNamespace_Impl__Group_3__3__Impl rule__RelativeNamespace_Impl__Group_3__4 ; - public final void rule__RelativeNamespace_Impl__Group_3__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10342:1: ( rule__RelativeNamespace_Impl__Group_3__3__Impl rule__RelativeNamespace_Impl__Group_3__4 ) - // InternalRos.g:10343:2: rule__RelativeNamespace_Impl__Group_3__3__Impl rule__RelativeNamespace_Impl__Group_3__4 - { - pushFollow(FOLLOW_13); - rule__RelativeNamespace_Impl__Group_3__3__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group_3__4(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3__3" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3__3__Impl" - // InternalRos.g:10350:1: rule__RelativeNamespace_Impl__Group_3__3__Impl : ( ( rule__RelativeNamespace_Impl__Group_3_3__0 )* ) ; - public final void rule__RelativeNamespace_Impl__Group_3__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10354:1: ( ( ( rule__RelativeNamespace_Impl__Group_3_3__0 )* ) ) - // InternalRos.g:10355:1: ( ( rule__RelativeNamespace_Impl__Group_3_3__0 )* ) - { - // InternalRos.g:10355:1: ( ( rule__RelativeNamespace_Impl__Group_3_3__0 )* ) - // InternalRos.g:10356:2: ( rule__RelativeNamespace_Impl__Group_3_3__0 )* - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_3_3()); - // InternalRos.g:10357:2: ( rule__RelativeNamespace_Impl__Group_3_3__0 )* - loop66: - do { - int alt66=2; - int LA66_0 = input.LA(1); - - if ( (LA66_0==43) ) { - alt66=1; - } - - - switch (alt66) { - case 1 : - // InternalRos.g:10357:3: rule__RelativeNamespace_Impl__Group_3_3__0 - { - pushFollow(FOLLOW_7); - rule__RelativeNamespace_Impl__Group_3_3__0(); - - state._fsp--; - - - } - break; - - default : - break loop66; - } - } while (true); - - after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_3_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3__3__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3__4" - // InternalRos.g:10365:1: rule__RelativeNamespace_Impl__Group_3__4 : rule__RelativeNamespace_Impl__Group_3__4__Impl ; - public final void rule__RelativeNamespace_Impl__Group_3__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10369:1: ( rule__RelativeNamespace_Impl__Group_3__4__Impl ) - // InternalRos.g:10370:2: rule__RelativeNamespace_Impl__Group_3__4__Impl - { - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group_3__4__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3__4" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3__4__Impl" - // InternalRos.g:10376:1: rule__RelativeNamespace_Impl__Group_3__4__Impl : ( '}' ) ; - public final void rule__RelativeNamespace_Impl__Group_3__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10380:1: ( ( '}' ) ) - // InternalRos.g:10381:1: ( '}' ) - { - // InternalRos.g:10381:1: ( '}' ) - // InternalRos.g:10382:2: '}' - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_3_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_3_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3__4__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3_3__0" - // InternalRos.g:10392:1: rule__RelativeNamespace_Impl__Group_3_3__0 : rule__RelativeNamespace_Impl__Group_3_3__0__Impl rule__RelativeNamespace_Impl__Group_3_3__1 ; - public final void rule__RelativeNamespace_Impl__Group_3_3__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10396:1: ( rule__RelativeNamespace_Impl__Group_3_3__0__Impl rule__RelativeNamespace_Impl__Group_3_3__1 ) - // InternalRos.g:10397:2: rule__RelativeNamespace_Impl__Group_3_3__0__Impl rule__RelativeNamespace_Impl__Group_3_3__1 - { - pushFollow(FOLLOW_45); - rule__RelativeNamespace_Impl__Group_3_3__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group_3_3__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3_3__0" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3_3__0__Impl" - // InternalRos.g:10404:1: rule__RelativeNamespace_Impl__Group_3_3__0__Impl : ( ',' ) ; - public final void rule__RelativeNamespace_Impl__Group_3_3__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10408:1: ( ( ',' ) ) - // InternalRos.g:10409:1: ( ',' ) - { - // InternalRos.g:10409:1: ( ',' ) - // InternalRos.g:10410:2: ',' - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_3_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_3_3_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3_3__0__Impl" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3_3__1" - // InternalRos.g:10419:1: rule__RelativeNamespace_Impl__Group_3_3__1 : rule__RelativeNamespace_Impl__Group_3_3__1__Impl ; - public final void rule__RelativeNamespace_Impl__Group_3_3__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10423:1: ( rule__RelativeNamespace_Impl__Group_3_3__1__Impl ) - // InternalRos.g:10424:2: rule__RelativeNamespace_Impl__Group_3_3__1__Impl - { - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__Group_3_3__1__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3_3__1" - - - // $ANTLR start "rule__RelativeNamespace_Impl__Group_3_3__1__Impl" - // InternalRos.g:10430:1: rule__RelativeNamespace_Impl__Group_3_3__1__Impl : ( ( rule__RelativeNamespace_Impl__PartsAssignment_3_3_1 ) ) ; - public final void rule__RelativeNamespace_Impl__Group_3_3__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10434:1: ( ( ( rule__RelativeNamespace_Impl__PartsAssignment_3_3_1 ) ) ) - // InternalRos.g:10435:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_3_3_1 ) ) - { - // InternalRos.g:10435:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_3_3_1 ) ) - // InternalRos.g:10436:2: ( rule__RelativeNamespace_Impl__PartsAssignment_3_3_1 ) - { - before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_3_3_1()); - // InternalRos.g:10437:2: ( rule__RelativeNamespace_Impl__PartsAssignment_3_3_1 ) - // InternalRos.g:10437:3: rule__RelativeNamespace_Impl__PartsAssignment_3_3_1 - { - pushFollow(FOLLOW_2); - rule__RelativeNamespace_Impl__PartsAssignment_3_3_1(); - - state._fsp--; - - - } - - after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_3_3_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelativeNamespace_Impl__Group_3_3__1__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group__0" - // InternalRos.g:10446:1: rule__PrivateNamespace__Group__0 : rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 ; - public final void rule__PrivateNamespace__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10450:1: ( rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 ) - // InternalRos.g:10451:2: rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 - { - pushFollow(FOLLOW_40); - rule__PrivateNamespace__Group__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group__0" - - - // $ANTLR start "rule__PrivateNamespace__Group__0__Impl" - // InternalRos.g:10458:1: rule__PrivateNamespace__Group__0__Impl : ( () ) ; - public final void rule__PrivateNamespace__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10462:1: ( ( () ) ) - // InternalRos.g:10463:1: ( () ) - { - // InternalRos.g:10463:1: ( () ) - // InternalRos.g:10464:2: () - { - before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); - // InternalRos.g:10465:2: () - // InternalRos.g:10465:3: - { - } - - after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); - - } - - - } - - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group__0__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group__1" - // InternalRos.g:10473:1: rule__PrivateNamespace__Group__1 : rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 ; - public final void rule__PrivateNamespace__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10477:1: ( rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 ) - // InternalRos.g:10478:2: rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 - { - pushFollow(FOLLOW_4); - rule__PrivateNamespace__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group__1" - - - // $ANTLR start "rule__PrivateNamespace__Group__1__Impl" - // InternalRos.g:10485:1: rule__PrivateNamespace__Group__1__Impl : ( 'PrivateNamespace' ) ; - public final void rule__PrivateNamespace__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10489:1: ( ( 'PrivateNamespace' ) ) - // InternalRos.g:10490:1: ( 'PrivateNamespace' ) - { - // InternalRos.g:10490:1: ( 'PrivateNamespace' ) - // InternalRos.g:10491:2: 'PrivateNamespace' - { - before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); - match(input,75,FOLLOW_2); - after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group__1__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group__2" - // InternalRos.g:10500:1: rule__PrivateNamespace__Group__2 : rule__PrivateNamespace__Group__2__Impl rule__PrivateNamespace__Group__3 ; - public final void rule__PrivateNamespace__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10504:1: ( rule__PrivateNamespace__Group__2__Impl rule__PrivateNamespace__Group__3 ) - // InternalRos.g:10505:2: rule__PrivateNamespace__Group__2__Impl rule__PrivateNamespace__Group__3 - { - pushFollow(FOLLOW_44); - rule__PrivateNamespace__Group__2__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group__3(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group__2" - - - // $ANTLR start "rule__PrivateNamespace__Group__2__Impl" - // InternalRos.g:10512:1: rule__PrivateNamespace__Group__2__Impl : ( '{' ) ; - public final void rule__PrivateNamespace__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10516:1: ( ( '{' ) ) - // InternalRos.g:10517:1: ( '{' ) - { - // InternalRos.g:10517:1: ( '{' ) - // InternalRos.g:10518:2: '{' - { - before(grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_2()); - match(input,41,FOLLOW_2); - after(grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group__2__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group__3" - // InternalRos.g:10527:1: rule__PrivateNamespace__Group__3 : rule__PrivateNamespace__Group__3__Impl rule__PrivateNamespace__Group__4 ; - public final void rule__PrivateNamespace__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10531:1: ( rule__PrivateNamespace__Group__3__Impl rule__PrivateNamespace__Group__4 ) - // InternalRos.g:10532:2: rule__PrivateNamespace__Group__3__Impl rule__PrivateNamespace__Group__4 - { - pushFollow(FOLLOW_44); - rule__PrivateNamespace__Group__3__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group__4(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group__3" - - - // $ANTLR start "rule__PrivateNamespace__Group__3__Impl" - // InternalRos.g:10539:1: rule__PrivateNamespace__Group__3__Impl : ( ( rule__PrivateNamespace__Group_3__0 )? ) ; - public final void rule__PrivateNamespace__Group__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10543:1: ( ( ( rule__PrivateNamespace__Group_3__0 )? ) ) - // InternalRos.g:10544:1: ( ( rule__PrivateNamespace__Group_3__0 )? ) - { - // InternalRos.g:10544:1: ( ( rule__PrivateNamespace__Group_3__0 )? ) - // InternalRos.g:10545:2: ( rule__PrivateNamespace__Group_3__0 )? - { - before(grammarAccess.getPrivateNamespaceAccess().getGroup_3()); - // InternalRos.g:10546:2: ( rule__PrivateNamespace__Group_3__0 )? - int alt67=2; - int LA67_0 = input.LA(1); - - if ( (LA67_0==73) ) { - alt67=1; - } - switch (alt67) { - case 1 : - // InternalRos.g:10546:3: rule__PrivateNamespace__Group_3__0 - { - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group_3__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getPrivateNamespaceAccess().getGroup_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group__3__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group__4" - // InternalRos.g:10554:1: rule__PrivateNamespace__Group__4 : rule__PrivateNamespace__Group__4__Impl ; - public final void rule__PrivateNamespace__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10558:1: ( rule__PrivateNamespace__Group__4__Impl ) - // InternalRos.g:10559:2: rule__PrivateNamespace__Group__4__Impl - { - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group__4__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group__4" - - - // $ANTLR start "rule__PrivateNamespace__Group__4__Impl" - // InternalRos.g:10565:1: rule__PrivateNamespace__Group__4__Impl : ( '}' ) ; - public final void rule__PrivateNamespace__Group__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10569:1: ( ( '}' ) ) - // InternalRos.g:10570:1: ( '}' ) - { - // InternalRos.g:10570:1: ( '}' ) - // InternalRos.g:10571:2: '}' - { - before(grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group__4__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group_3__0" - // InternalRos.g:10581:1: rule__PrivateNamespace__Group_3__0 : rule__PrivateNamespace__Group_3__0__Impl rule__PrivateNamespace__Group_3__1 ; - public final void rule__PrivateNamespace__Group_3__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10585:1: ( rule__PrivateNamespace__Group_3__0__Impl rule__PrivateNamespace__Group_3__1 ) - // InternalRos.g:10586:2: rule__PrivateNamespace__Group_3__0__Impl rule__PrivateNamespace__Group_3__1 - { - pushFollow(FOLLOW_4); - rule__PrivateNamespace__Group_3__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group_3__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3__0" - - - // $ANTLR start "rule__PrivateNamespace__Group_3__0__Impl" - // InternalRos.g:10593:1: rule__PrivateNamespace__Group_3__0__Impl : ( 'parts' ) ; - public final void rule__PrivateNamespace__Group_3__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10597:1: ( ( 'parts' ) ) - // InternalRos.g:10598:1: ( 'parts' ) - { - // InternalRos.g:10598:1: ( 'parts' ) - // InternalRos.g:10599:2: 'parts' - { - before(grammarAccess.getPrivateNamespaceAccess().getPartsKeyword_3_0()); - match(input,73,FOLLOW_2); - after(grammarAccess.getPrivateNamespaceAccess().getPartsKeyword_3_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3__0__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group_3__1" - // InternalRos.g:10608:1: rule__PrivateNamespace__Group_3__1 : rule__PrivateNamespace__Group_3__1__Impl rule__PrivateNamespace__Group_3__2 ; - public final void rule__PrivateNamespace__Group_3__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10612:1: ( rule__PrivateNamespace__Group_3__1__Impl rule__PrivateNamespace__Group_3__2 ) - // InternalRos.g:10613:2: rule__PrivateNamespace__Group_3__1__Impl rule__PrivateNamespace__Group_3__2 - { - pushFollow(FOLLOW_45); - rule__PrivateNamespace__Group_3__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group_3__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3__1" - - - // $ANTLR start "rule__PrivateNamespace__Group_3__1__Impl" - // InternalRos.g:10620:1: rule__PrivateNamespace__Group_3__1__Impl : ( '{' ) ; - public final void rule__PrivateNamespace__Group_3__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10624:1: ( ( '{' ) ) - // InternalRos.g:10625:1: ( '{' ) - { - // InternalRos.g:10625:1: ( '{' ) - // InternalRos.g:10626:2: '{' - { - before(grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3__1__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group_3__2" - // InternalRos.g:10635:1: rule__PrivateNamespace__Group_3__2 : rule__PrivateNamespace__Group_3__2__Impl rule__PrivateNamespace__Group_3__3 ; - public final void rule__PrivateNamespace__Group_3__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10639:1: ( rule__PrivateNamespace__Group_3__2__Impl rule__PrivateNamespace__Group_3__3 ) - // InternalRos.g:10640:2: rule__PrivateNamespace__Group_3__2__Impl rule__PrivateNamespace__Group_3__3 - { - pushFollow(FOLLOW_13); - rule__PrivateNamespace__Group_3__2__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group_3__3(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3__2" - - - // $ANTLR start "rule__PrivateNamespace__Group_3__2__Impl" - // InternalRos.g:10647:1: rule__PrivateNamespace__Group_3__2__Impl : ( ( rule__PrivateNamespace__PartsAssignment_3_2 ) ) ; - public final void rule__PrivateNamespace__Group_3__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10651:1: ( ( ( rule__PrivateNamespace__PartsAssignment_3_2 ) ) ) - // InternalRos.g:10652:1: ( ( rule__PrivateNamespace__PartsAssignment_3_2 ) ) - { - // InternalRos.g:10652:1: ( ( rule__PrivateNamespace__PartsAssignment_3_2 ) ) - // InternalRos.g:10653:2: ( rule__PrivateNamespace__PartsAssignment_3_2 ) - { - before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_3_2()); - // InternalRos.g:10654:2: ( rule__PrivateNamespace__PartsAssignment_3_2 ) - // InternalRos.g:10654:3: rule__PrivateNamespace__PartsAssignment_3_2 - { - pushFollow(FOLLOW_2); - rule__PrivateNamespace__PartsAssignment_3_2(); - - state._fsp--; - - - } - - after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_3_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3__2__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group_3__3" - // InternalRos.g:10662:1: rule__PrivateNamespace__Group_3__3 : rule__PrivateNamespace__Group_3__3__Impl rule__PrivateNamespace__Group_3__4 ; - public final void rule__PrivateNamespace__Group_3__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10666:1: ( rule__PrivateNamespace__Group_3__3__Impl rule__PrivateNamespace__Group_3__4 ) - // InternalRos.g:10667:2: rule__PrivateNamespace__Group_3__3__Impl rule__PrivateNamespace__Group_3__4 - { - pushFollow(FOLLOW_13); - rule__PrivateNamespace__Group_3__3__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group_3__4(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3__3" - - - // $ANTLR start "rule__PrivateNamespace__Group_3__3__Impl" - // InternalRos.g:10674:1: rule__PrivateNamespace__Group_3__3__Impl : ( ( rule__PrivateNamespace__Group_3_3__0 )* ) ; - public final void rule__PrivateNamespace__Group_3__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10678:1: ( ( ( rule__PrivateNamespace__Group_3_3__0 )* ) ) - // InternalRos.g:10679:1: ( ( rule__PrivateNamespace__Group_3_3__0 )* ) - { - // InternalRos.g:10679:1: ( ( rule__PrivateNamespace__Group_3_3__0 )* ) - // InternalRos.g:10680:2: ( rule__PrivateNamespace__Group_3_3__0 )* - { - before(grammarAccess.getPrivateNamespaceAccess().getGroup_3_3()); - // InternalRos.g:10681:2: ( rule__PrivateNamespace__Group_3_3__0 )* - loop68: - do { - int alt68=2; - int LA68_0 = input.LA(1); - - if ( (LA68_0==43) ) { - alt68=1; - } - - - switch (alt68) { - case 1 : - // InternalRos.g:10681:3: rule__PrivateNamespace__Group_3_3__0 - { - pushFollow(FOLLOW_7); - rule__PrivateNamespace__Group_3_3__0(); - - state._fsp--; - - - } - break; - - default : - break loop68; - } - } while (true); - - after(grammarAccess.getPrivateNamespaceAccess().getGroup_3_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3__3__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group_3__4" - // InternalRos.g:10689:1: rule__PrivateNamespace__Group_3__4 : rule__PrivateNamespace__Group_3__4__Impl ; - public final void rule__PrivateNamespace__Group_3__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10693:1: ( rule__PrivateNamespace__Group_3__4__Impl ) - // InternalRos.g:10694:2: rule__PrivateNamespace__Group_3__4__Impl - { - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group_3__4__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3__4" - - - // $ANTLR start "rule__PrivateNamespace__Group_3__4__Impl" - // InternalRos.g:10700:1: rule__PrivateNamespace__Group_3__4__Impl : ( '}' ) ; - public final void rule__PrivateNamespace__Group_3__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10704:1: ( ( '}' ) ) - // InternalRos.g:10705:1: ( '}' ) - { - // InternalRos.g:10705:1: ( '}' ) - // InternalRos.g:10706:2: '}' - { - before(grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_3_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_3_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3__4__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group_3_3__0" - // InternalRos.g:10716:1: rule__PrivateNamespace__Group_3_3__0 : rule__PrivateNamespace__Group_3_3__0__Impl rule__PrivateNamespace__Group_3_3__1 ; - public final void rule__PrivateNamespace__Group_3_3__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10720:1: ( rule__PrivateNamespace__Group_3_3__0__Impl rule__PrivateNamespace__Group_3_3__1 ) - // InternalRos.g:10721:2: rule__PrivateNamespace__Group_3_3__0__Impl rule__PrivateNamespace__Group_3_3__1 - { - pushFollow(FOLLOW_45); - rule__PrivateNamespace__Group_3_3__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group_3_3__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3_3__0" - - - // $ANTLR start "rule__PrivateNamespace__Group_3_3__0__Impl" - // InternalRos.g:10728:1: rule__PrivateNamespace__Group_3_3__0__Impl : ( ',' ) ; - public final void rule__PrivateNamespace__Group_3_3__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10732:1: ( ( ',' ) ) - // InternalRos.g:10733:1: ( ',' ) - { - // InternalRos.g:10733:1: ( ',' ) - // InternalRos.g:10734:2: ',' - { - before(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_3_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_3_3_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3_3__0__Impl" - - - // $ANTLR start "rule__PrivateNamespace__Group_3_3__1" - // InternalRos.g:10743:1: rule__PrivateNamespace__Group_3_3__1 : rule__PrivateNamespace__Group_3_3__1__Impl ; - public final void rule__PrivateNamespace__Group_3_3__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10747:1: ( rule__PrivateNamespace__Group_3_3__1__Impl ) - // InternalRos.g:10748:2: rule__PrivateNamespace__Group_3_3__1__Impl - { - pushFollow(FOLLOW_2); - rule__PrivateNamespace__Group_3_3__1__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3_3__1" - - - // $ANTLR start "rule__PrivateNamespace__Group_3_3__1__Impl" - // InternalRos.g:10754:1: rule__PrivateNamespace__Group_3_3__1__Impl : ( ( rule__PrivateNamespace__PartsAssignment_3_3_1 ) ) ; - public final void rule__PrivateNamespace__Group_3_3__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10758:1: ( ( ( rule__PrivateNamespace__PartsAssignment_3_3_1 ) ) ) - // InternalRos.g:10759:1: ( ( rule__PrivateNamespace__PartsAssignment_3_3_1 ) ) - { - // InternalRos.g:10759:1: ( ( rule__PrivateNamespace__PartsAssignment_3_3_1 ) ) - // InternalRos.g:10760:2: ( rule__PrivateNamespace__PartsAssignment_3_3_1 ) - { - before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_3_3_1()); - // InternalRos.g:10761:2: ( rule__PrivateNamespace__PartsAssignment_3_3_1 ) - // InternalRos.g:10761:3: rule__PrivateNamespace__PartsAssignment_3_3_1 - { - pushFollow(FOLLOW_2); - rule__PrivateNamespace__PartsAssignment_3_3_1(); - - state._fsp--; - - - } - - after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_3_3_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__PrivateNamespace__Group_3_3__1__Impl" - - - // $ANTLR start "rule__Parameter__Group__0" - // InternalRos.g:10770: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 { - // InternalRos.g:10774:1: ( rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ) - // InternalRos.g:10775:2: rule__Parameter__Group__0__Impl rule__Parameter__Group__1 - { - pushFollow(FOLLOW_4); - 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" - // InternalRos.g:10782:1: rule__Parameter__Group__0__Impl : ( 'Parameter' ) ; - public final void rule__Parameter__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10786:1: ( ( 'Parameter' ) ) - // InternalRos.g:10787:1: ( 'Parameter' ) - { - // InternalRos.g:10787:1: ( 'Parameter' ) - // InternalRos.g:10788:2: 'Parameter' - { - before(grammarAccess.getParameterAccess().getParameterKeyword_0()); - match(input,76,FOLLOW_2); - after(grammarAccess.getParameterAccess().getParameterKeyword_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Parameter__Group__0__Impl" - - - // $ANTLR start "rule__Parameter__Group__1" - // InternalRos.g:10797: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 { - // InternalRos.g:10801:1: ( rule__Parameter__Group__1__Impl rule__Parameter__Group__2 ) - // InternalRos.g:10802:2: rule__Parameter__Group__1__Impl rule__Parameter__Group__2 - { - pushFollow(FOLLOW_29); - 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" - // InternalRos.g:10809:1: rule__Parameter__Group__1__Impl : ( '{' ) ; - public final void rule__Parameter__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10813:1: ( ( '{' ) ) - // InternalRos.g:10814:1: ( '{' ) - { - // InternalRos.g:10814:1: ( '{' ) - // InternalRos.g:10815:2: '{' - { - before(grammarAccess.getParameterAccess().getLeftCurlyBracketKeyword_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getParameterAccess().getLeftCurlyBracketKeyword_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" - // InternalRos.g:10824: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 { - // InternalRos.g:10828:1: ( rule__Parameter__Group__2__Impl rule__Parameter__Group__3 ) - // InternalRos.g:10829:2: rule__Parameter__Group__2__Impl rule__Parameter__Group__3 - { - pushFollow(FOLLOW_10); - 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" - // InternalRos.g:10836:1: rule__Parameter__Group__2__Impl : ( 'name' ) ; - public final void rule__Parameter__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10840:1: ( ( 'name' ) ) - // InternalRos.g:10841:1: ( 'name' ) - { - // InternalRos.g:10841:1: ( 'name' ) - // InternalRos.g:10842:2: 'name' - { - before(grammarAccess.getParameterAccess().getNameKeyword_2()); - match(input,33,FOLLOW_2); - after(grammarAccess.getParameterAccess().getNameKeyword_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" - // InternalRos.g:10851: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 { - // InternalRos.g:10855:1: ( rule__Parameter__Group__3__Impl rule__Parameter__Group__4 ) - // InternalRos.g:10856:2: rule__Parameter__Group__3__Impl rule__Parameter__Group__4 - { - pushFollow(FOLLOW_47); - 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" - // InternalRos.g:10863:1: rule__Parameter__Group__3__Impl : ( ( rule__Parameter__NameAssignment_3 ) ) ; - public final void rule__Parameter__Group__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10867:1: ( ( ( rule__Parameter__NameAssignment_3 ) ) ) - // InternalRos.g:10868:1: ( ( rule__Parameter__NameAssignment_3 ) ) - { - // InternalRos.g:10868:1: ( ( rule__Parameter__NameAssignment_3 ) ) - // InternalRos.g:10869:2: ( rule__Parameter__NameAssignment_3 ) - { - before(grammarAccess.getParameterAccess().getNameAssignment_3()); - // InternalRos.g:10870:2: ( rule__Parameter__NameAssignment_3 ) - // InternalRos.g:10870:3: rule__Parameter__NameAssignment_3 - { - pushFollow(FOLLOW_2); - rule__Parameter__NameAssignment_3(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterAccess().getNameAssignment_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" - // InternalRos.g:10878: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 { - // InternalRos.g:10882:1: ( rule__Parameter__Group__4__Impl rule__Parameter__Group__5 ) - // InternalRos.g:10883:2: rule__Parameter__Group__4__Impl rule__Parameter__Group__5 - { - pushFollow(FOLLOW_47); - 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" - // InternalRos.g:10890:1: rule__Parameter__Group__4__Impl : ( ( rule__Parameter__Group_4__0 )? ) ; - public final void rule__Parameter__Group__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10894:1: ( ( ( rule__Parameter__Group_4__0 )? ) ) - // InternalRos.g:10895:1: ( ( rule__Parameter__Group_4__0 )? ) - { - // InternalRos.g:10895:1: ( ( rule__Parameter__Group_4__0 )? ) - // InternalRos.g:10896:2: ( rule__Parameter__Group_4__0 )? - { - before(grammarAccess.getParameterAccess().getGroup_4()); - // InternalRos.g:10897:2: ( rule__Parameter__Group_4__0 )? - int alt69=2; - int LA69_0 = input.LA(1); - - if ( (LA69_0==65) ) { - alt69=1; - } - switch (alt69) { - case 1 : - // InternalRos.g:10897:3: rule__Parameter__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__Parameter__Group_4__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getParameterAccess().getGroup_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" - // InternalRos.g:10905:1: rule__Parameter__Group__5 : rule__Parameter__Group__5__Impl rule__Parameter__Group__6 ; - public final void rule__Parameter__Group__5() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10909:1: ( rule__Parameter__Group__5__Impl rule__Parameter__Group__6 ) - // InternalRos.g:10910:2: rule__Parameter__Group__5__Impl rule__Parameter__Group__6 - { - pushFollow(FOLLOW_48); - rule__Parameter__Group__5__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__Parameter__Group__6(); - - 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" - // InternalRos.g:10917:1: rule__Parameter__Group__5__Impl : ( 'type' ) ; - public final void rule__Parameter__Group__5__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10921:1: ( ( 'type' ) ) - // InternalRos.g:10922:1: ( 'type' ) - { - // InternalRos.g:10922:1: ( 'type' ) - // InternalRos.g:10923:2: 'type' - { - before(grammarAccess.getParameterAccess().getTypeKeyword_5()); - match(input,36,FOLLOW_2); - after(grammarAccess.getParameterAccess().getTypeKeyword_5()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Parameter__Group__5__Impl" - - - // $ANTLR start "rule__Parameter__Group__6" - // InternalRos.g:10932:1: rule__Parameter__Group__6 : rule__Parameter__Group__6__Impl rule__Parameter__Group__7 ; - public final void rule__Parameter__Group__6() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10936:1: ( rule__Parameter__Group__6__Impl rule__Parameter__Group__7 ) - // InternalRos.g:10937:2: rule__Parameter__Group__6__Impl rule__Parameter__Group__7 - { - pushFollow(FOLLOW_49); - rule__Parameter__Group__6__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__Parameter__Group__7(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Parameter__Group__6" - - - // $ANTLR start "rule__Parameter__Group__6__Impl" - // InternalRos.g:10944:1: rule__Parameter__Group__6__Impl : ( ( rule__Parameter__TypeAssignment_6 ) ) ; - public final void rule__Parameter__Group__6__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10948:1: ( ( ( rule__Parameter__TypeAssignment_6 ) ) ) - // InternalRos.g:10949:1: ( ( rule__Parameter__TypeAssignment_6 ) ) - { - // InternalRos.g:10949:1: ( ( rule__Parameter__TypeAssignment_6 ) ) - // InternalRos.g:10950:2: ( rule__Parameter__TypeAssignment_6 ) - { - before(grammarAccess.getParameterAccess().getTypeAssignment_6()); - // InternalRos.g:10951:2: ( rule__Parameter__TypeAssignment_6 ) - // InternalRos.g:10951:3: rule__Parameter__TypeAssignment_6 - { - pushFollow(FOLLOW_2); - rule__Parameter__TypeAssignment_6(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterAccess().getTypeAssignment_6()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Parameter__Group__6__Impl" - - - // $ANTLR start "rule__Parameter__Group__7" - // InternalRos.g:10959:1: rule__Parameter__Group__7 : rule__Parameter__Group__7__Impl ; - public final void rule__Parameter__Group__7() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10963:1: ( rule__Parameter__Group__7__Impl ) - // InternalRos.g:10964:2: rule__Parameter__Group__7__Impl - { - pushFollow(FOLLOW_2); - rule__Parameter__Group__7__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Parameter__Group__7" - - - // $ANTLR start "rule__Parameter__Group__7__Impl" - // InternalRos.g:10970:1: rule__Parameter__Group__7__Impl : ( '}' ) ; - public final void rule__Parameter__Group__7__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10974:1: ( ( '}' ) ) - // InternalRos.g:10975:1: ( '}' ) - { - // InternalRos.g:10975:1: ( '}' ) - // InternalRos.g:10976:2: '}' - { - before(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_7()); - match(input,42,FOLLOW_2); - after(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_7()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Parameter__Group__7__Impl" - - - // $ANTLR start "rule__Parameter__Group_4__0" - // InternalRos.g:10986:1: rule__Parameter__Group_4__0 : rule__Parameter__Group_4__0__Impl rule__Parameter__Group_4__1 ; - public final void rule__Parameter__Group_4__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:10990:1: ( rule__Parameter__Group_4__0__Impl rule__Parameter__Group_4__1 ) - // InternalRos.g:10991:2: rule__Parameter__Group_4__0__Impl rule__Parameter__Group_4__1 - { - pushFollow(FOLLOW_40); - rule__Parameter__Group_4__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__Parameter__Group_4__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Parameter__Group_4__0" - - - // $ANTLR start "rule__Parameter__Group_4__0__Impl" - // InternalRos.g:10998:1: rule__Parameter__Group_4__0__Impl : ( 'namespace' ) ; - public final void rule__Parameter__Group_4__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11002:1: ( ( 'namespace' ) ) - // InternalRos.g:11003:1: ( 'namespace' ) - { - // InternalRos.g:11003:1: ( 'namespace' ) - // InternalRos.g:11004:2: 'namespace' - { - before(grammarAccess.getParameterAccess().getNamespaceKeyword_4_0()); - match(input,65,FOLLOW_2); - after(grammarAccess.getParameterAccess().getNamespaceKeyword_4_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Parameter__Group_4__0__Impl" - - - // $ANTLR start "rule__Parameter__Group_4__1" - // InternalRos.g:11013:1: rule__Parameter__Group_4__1 : rule__Parameter__Group_4__1__Impl ; - public final void rule__Parameter__Group_4__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11017:1: ( rule__Parameter__Group_4__1__Impl ) - // InternalRos.g:11018:2: rule__Parameter__Group_4__1__Impl - { - pushFollow(FOLLOW_2); - rule__Parameter__Group_4__1__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Parameter__Group_4__1" - - - // $ANTLR start "rule__Parameter__Group_4__1__Impl" - // InternalRos.g:11024:1: rule__Parameter__Group_4__1__Impl : ( ( rule__Parameter__NamespaceAssignment_4_1 ) ) ; - public final void rule__Parameter__Group_4__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11028:1: ( ( ( rule__Parameter__NamespaceAssignment_4_1 ) ) ) - // InternalRos.g:11029:1: ( ( rule__Parameter__NamespaceAssignment_4_1 ) ) - { - // InternalRos.g:11029:1: ( ( rule__Parameter__NamespaceAssignment_4_1 ) ) - // InternalRos.g:11030:2: ( rule__Parameter__NamespaceAssignment_4_1 ) - { - before(grammarAccess.getParameterAccess().getNamespaceAssignment_4_1()); - // InternalRos.g:11031:2: ( rule__Parameter__NamespaceAssignment_4_1 ) - // InternalRos.g:11031:3: rule__Parameter__NamespaceAssignment_4_1 - { - pushFollow(FOLLOW_2); - rule__Parameter__NamespaceAssignment_4_1(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterAccess().getNamespaceAssignment_4_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Parameter__Group_4__1__Impl" - - - // $ANTLR start "rule__ParameterListType__Group__0" - // InternalRos.g:11040:1: rule__ParameterListType__Group__0 : rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 ; - public final void rule__ParameterListType__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11044:1: ( rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 ) - // InternalRos.g:11045:2: rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 - { - pushFollow(FOLLOW_50); - rule__ParameterListType__Group__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterListType__Group__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__0" - - - // $ANTLR start "rule__ParameterListType__Group__0__Impl" - // InternalRos.g:11052:1: rule__ParameterListType__Group__0__Impl : ( () ) ; - public final void rule__ParameterListType__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11056:1: ( ( () ) ) - // InternalRos.g:11057:1: ( () ) - { - // InternalRos.g:11057:1: ( () ) - // InternalRos.g:11058:2: () - { - before(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); - // InternalRos.g:11059:2: () - // InternalRos.g:11059:3: - { - } - - after(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); - - } - - - } - - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__0__Impl" - - - // $ANTLR start "rule__ParameterListType__Group__1" - // InternalRos.g:11067:1: rule__ParameterListType__Group__1 : rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 ; - public final void rule__ParameterListType__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11071:1: ( rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 ) - // InternalRos.g:11072:2: rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 - { - pushFollow(FOLLOW_4); - rule__ParameterListType__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterListType__Group__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__1" - - - // $ANTLR start "rule__ParameterListType__Group__1__Impl" - // InternalRos.g:11079:1: rule__ParameterListType__Group__1__Impl : ( 'List' ) ; - public final void rule__ParameterListType__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11083:1: ( ( 'List' ) ) - // InternalRos.g:11084:1: ( 'List' ) - { - // InternalRos.g:11084:1: ( 'List' ) - // InternalRos.g:11085:2: 'List' - { - before(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); - match(input,77,FOLLOW_2); - after(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__1__Impl" - - - // $ANTLR start "rule__ParameterListType__Group__2" - // InternalRos.g:11094:1: rule__ParameterListType__Group__2 : rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 ; - public final void rule__ParameterListType__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11098:1: ( rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 ) - // InternalRos.g:11099:2: rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 - { - pushFollow(FOLLOW_48); - rule__ParameterListType__Group__2__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterListType__Group__3(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__2" - - - // $ANTLR start "rule__ParameterListType__Group__2__Impl" - // InternalRos.g:11106:1: rule__ParameterListType__Group__2__Impl : ( '{' ) ; - public final void rule__ParameterListType__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11110:1: ( ( '{' ) ) - // InternalRos.g:11111:1: ( '{' ) - { - // InternalRos.g:11111:1: ( '{' ) - // InternalRos.g:11112:2: '{' - { - before(grammarAccess.getParameterListTypeAccess().getLeftCurlyBracketKeyword_2()); - match(input,41,FOLLOW_2); - after(grammarAccess.getParameterListTypeAccess().getLeftCurlyBracketKeyword_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__2__Impl" - - - // $ANTLR start "rule__ParameterListType__Group__3" - // InternalRos.g:11121:1: rule__ParameterListType__Group__3 : rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 ; - public final void rule__ParameterListType__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11125:1: ( rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 ) - // InternalRos.g:11126:2: rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 - { - pushFollow(FOLLOW_13); - rule__ParameterListType__Group__3__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterListType__Group__4(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__3" - - - // $ANTLR start "rule__ParameterListType__Group__3__Impl" - // InternalRos.g:11133:1: rule__ParameterListType__Group__3__Impl : ( ( rule__ParameterListType__SequenceAssignment_3 ) ) ; - public final void rule__ParameterListType__Group__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11137:1: ( ( ( rule__ParameterListType__SequenceAssignment_3 ) ) ) - // InternalRos.g:11138:1: ( ( rule__ParameterListType__SequenceAssignment_3 ) ) - { - // InternalRos.g:11138:1: ( ( rule__ParameterListType__SequenceAssignment_3 ) ) - // InternalRos.g:11139:2: ( rule__ParameterListType__SequenceAssignment_3 ) - { - before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); - // InternalRos.g:11140:2: ( rule__ParameterListType__SequenceAssignment_3 ) - // InternalRos.g:11140:3: rule__ParameterListType__SequenceAssignment_3 - { - pushFollow(FOLLOW_2); - rule__ParameterListType__SequenceAssignment_3(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__3__Impl" - - - // $ANTLR start "rule__ParameterListType__Group__4" - // InternalRos.g:11148:1: rule__ParameterListType__Group__4 : rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 ; - public final void rule__ParameterListType__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11152:1: ( rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 ) - // InternalRos.g:11153:2: rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 - { - pushFollow(FOLLOW_13); - rule__ParameterListType__Group__4__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterListType__Group__5(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__4" - - - // $ANTLR start "rule__ParameterListType__Group__4__Impl" - // InternalRos.g:11160:1: rule__ParameterListType__Group__4__Impl : ( ( rule__ParameterListType__Group_4__0 )* ) ; - public final void rule__ParameterListType__Group__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11164:1: ( ( ( rule__ParameterListType__Group_4__0 )* ) ) - // InternalRos.g:11165:1: ( ( rule__ParameterListType__Group_4__0 )* ) - { - // InternalRos.g:11165:1: ( ( rule__ParameterListType__Group_4__0 )* ) - // InternalRos.g:11166:2: ( rule__ParameterListType__Group_4__0 )* - { - before(grammarAccess.getParameterListTypeAccess().getGroup_4()); - // InternalRos.g:11167:2: ( rule__ParameterListType__Group_4__0 )* - loop70: - do { - int alt70=2; - int LA70_0 = input.LA(1); - - if ( (LA70_0==43) ) { - alt70=1; - } - - - switch (alt70) { - case 1 : - // InternalRos.g:11167:3: rule__ParameterListType__Group_4__0 - { - pushFollow(FOLLOW_7); - rule__ParameterListType__Group_4__0(); - - state._fsp--; - - - } - break; - - default : - break loop70; - } - } while (true); - - after(grammarAccess.getParameterListTypeAccess().getGroup_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__4__Impl" - - - // $ANTLR start "rule__ParameterListType__Group__5" - // InternalRos.g:11175:1: rule__ParameterListType__Group__5 : rule__ParameterListType__Group__5__Impl ; - public final void rule__ParameterListType__Group__5() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11179:1: ( rule__ParameterListType__Group__5__Impl ) - // InternalRos.g:11180:2: rule__ParameterListType__Group__5__Impl - { - pushFollow(FOLLOW_2); - rule__ParameterListType__Group__5__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__5" - - - // $ANTLR start "rule__ParameterListType__Group__5__Impl" - // InternalRos.g:11186:1: rule__ParameterListType__Group__5__Impl : ( '}' ) ; - public final void rule__ParameterListType__Group__5__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11190:1: ( ( '}' ) ) - // InternalRos.g:11191:1: ( '}' ) - { - // InternalRos.g:11191:1: ( '}' ) - // InternalRos.g:11192:2: '}' - { - before(grammarAccess.getParameterListTypeAccess().getRightCurlyBracketKeyword_5()); - match(input,42,FOLLOW_2); - after(grammarAccess.getParameterListTypeAccess().getRightCurlyBracketKeyword_5()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group__5__Impl" - - - // $ANTLR start "rule__ParameterListType__Group_4__0" - // InternalRos.g:11202:1: rule__ParameterListType__Group_4__0 : rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 ; - public final void rule__ParameterListType__Group_4__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11206:1: ( rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 ) - // InternalRos.g:11207:2: rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 - { - pushFollow(FOLLOW_48); - rule__ParameterListType__Group_4__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterListType__Group_4__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group_4__0" - - - // $ANTLR start "rule__ParameterListType__Group_4__0__Impl" - // InternalRos.g:11214:1: rule__ParameterListType__Group_4__0__Impl : ( ',' ) ; - public final void rule__ParameterListType__Group_4__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11218:1: ( ( ',' ) ) - // InternalRos.g:11219:1: ( ',' ) - { - // InternalRos.g:11219:1: ( ',' ) - // InternalRos.g:11220:2: ',' - { - before(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group_4__0__Impl" - - - // $ANTLR start "rule__ParameterListType__Group_4__1" - // InternalRos.g:11229:1: rule__ParameterListType__Group_4__1 : rule__ParameterListType__Group_4__1__Impl ; - public final void rule__ParameterListType__Group_4__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11233:1: ( rule__ParameterListType__Group_4__1__Impl ) - // InternalRos.g:11234:2: rule__ParameterListType__Group_4__1__Impl - { - pushFollow(FOLLOW_2); - rule__ParameterListType__Group_4__1__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group_4__1" - - - // $ANTLR start "rule__ParameterListType__Group_4__1__Impl" - // InternalRos.g:11240:1: rule__ParameterListType__Group_4__1__Impl : ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) ; - public final void rule__ParameterListType__Group_4__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11244:1: ( ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) ) - // InternalRos.g:11245:1: ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) - { - // InternalRos.g:11245:1: ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) - // InternalRos.g:11246:2: ( rule__ParameterListType__SequenceAssignment_4_1 ) - { - before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); - // InternalRos.g:11247:2: ( rule__ParameterListType__SequenceAssignment_4_1 ) - // InternalRos.g:11247:3: rule__ParameterListType__SequenceAssignment_4_1 - { - pushFollow(FOLLOW_2); - rule__ParameterListType__SequenceAssignment_4_1(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterListType__Group_4__1__Impl" - - - // $ANTLR start "rule__ParameterStructType__Group__0" - // InternalRos.g:11256:1: rule__ParameterStructType__Group__0 : rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 ; - public final void rule__ParameterStructType__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11260:1: ( rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 ) - // InternalRos.g:11261:2: rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 - { - pushFollow(FOLLOW_51); - rule__ParameterStructType__Group__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterStructType__Group__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__0" - - - // $ANTLR start "rule__ParameterStructType__Group__0__Impl" - // InternalRos.g:11268:1: rule__ParameterStructType__Group__0__Impl : ( () ) ; - public final void rule__ParameterStructType__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11272:1: ( ( () ) ) - // InternalRos.g:11273:1: ( () ) - { - // InternalRos.g:11273:1: ( () ) - // InternalRos.g:11274:2: () - { - before(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); - // InternalRos.g:11275:2: () - // InternalRos.g:11275:3: - { - } - - after(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); - - } - - - } - - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__0__Impl" - - - // $ANTLR start "rule__ParameterStructType__Group__1" - // InternalRos.g:11283:1: rule__ParameterStructType__Group__1 : rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 ; - public final void rule__ParameterStructType__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11287:1: ( rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 ) - // InternalRos.g:11288:2: rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 - { - pushFollow(FOLLOW_4); - rule__ParameterStructType__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterStructType__Group__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__1" - - - // $ANTLR start "rule__ParameterStructType__Group__1__Impl" - // InternalRos.g:11295:1: rule__ParameterStructType__Group__1__Impl : ( 'Struct' ) ; - public final void rule__ParameterStructType__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11299:1: ( ( 'Struct' ) ) - // InternalRos.g:11300:1: ( 'Struct' ) - { - // InternalRos.g:11300:1: ( 'Struct' ) - // InternalRos.g:11301:2: 'Struct' - { - before(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); - match(input,78,FOLLOW_2); - after(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__1__Impl" - - - // $ANTLR start "rule__ParameterStructType__Group__2" - // InternalRos.g:11310:1: rule__ParameterStructType__Group__2 : rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 ; - public final void rule__ParameterStructType__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11314:1: ( rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 ) - // InternalRos.g:11315:2: rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 - { - pushFollow(FOLLOW_10); - rule__ParameterStructType__Group__2__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterStructType__Group__3(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__2" - - - // $ANTLR start "rule__ParameterStructType__Group__2__Impl" - // InternalRos.g:11322:1: rule__ParameterStructType__Group__2__Impl : ( '{' ) ; - public final void rule__ParameterStructType__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11326:1: ( ( '{' ) ) - // InternalRos.g:11327:1: ( '{' ) - { - // InternalRos.g:11327:1: ( '{' ) - // InternalRos.g:11328:2: '{' - { - before(grammarAccess.getParameterStructTypeAccess().getLeftCurlyBracketKeyword_2()); - match(input,41,FOLLOW_2); - after(grammarAccess.getParameterStructTypeAccess().getLeftCurlyBracketKeyword_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__2__Impl" - - - // $ANTLR start "rule__ParameterStructType__Group__3" - // InternalRos.g:11337:1: rule__ParameterStructType__Group__3 : rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 ; - public final void rule__ParameterStructType__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11341:1: ( rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 ) - // InternalRos.g:11342:2: rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 - { - pushFollow(FOLLOW_13); - rule__ParameterStructType__Group__3__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterStructType__Group__4(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__3" - - - // $ANTLR start "rule__ParameterStructType__Group__3__Impl" - // InternalRos.g:11349:1: rule__ParameterStructType__Group__3__Impl : ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) ; - public final void rule__ParameterStructType__Group__3__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11353:1: ( ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) ) - // InternalRos.g:11354:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) - { - // InternalRos.g:11354:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) - // InternalRos.g:11355:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) - { - before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); - // InternalRos.g:11356:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) - // InternalRos.g:11356:3: rule__ParameterStructType__ParameterstructypetmemberAssignment_3 - { - pushFollow(FOLLOW_2); - rule__ParameterStructType__ParameterstructypetmemberAssignment_3(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__3__Impl" - - - // $ANTLR start "rule__ParameterStructType__Group__4" - // InternalRos.g:11364:1: rule__ParameterStructType__Group__4 : rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 ; - public final void rule__ParameterStructType__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11368:1: ( rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 ) - // InternalRos.g:11369:2: rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 - { - pushFollow(FOLLOW_13); - rule__ParameterStructType__Group__4__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterStructType__Group__5(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__4" - - - // $ANTLR start "rule__ParameterStructType__Group__4__Impl" - // InternalRos.g:11376:1: rule__ParameterStructType__Group__4__Impl : ( ( rule__ParameterStructType__Group_4__0 )* ) ; - public final void rule__ParameterStructType__Group__4__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11380:1: ( ( ( rule__ParameterStructType__Group_4__0 )* ) ) - // InternalRos.g:11381:1: ( ( rule__ParameterStructType__Group_4__0 )* ) - { - // InternalRos.g:11381:1: ( ( rule__ParameterStructType__Group_4__0 )* ) - // InternalRos.g:11382:2: ( rule__ParameterStructType__Group_4__0 )* - { - before(grammarAccess.getParameterStructTypeAccess().getGroup_4()); - // InternalRos.g:11383:2: ( rule__ParameterStructType__Group_4__0 )* - loop71: - do { - int alt71=2; - int LA71_0 = input.LA(1); - - if ( (LA71_0==43) ) { - alt71=1; - } - - - switch (alt71) { - case 1 : - // InternalRos.g:11383:3: rule__ParameterStructType__Group_4__0 - { - pushFollow(FOLLOW_7); - rule__ParameterStructType__Group_4__0(); - - state._fsp--; - - - } - break; - - default : - break loop71; - } - } while (true); - - after(grammarAccess.getParameterStructTypeAccess().getGroup_4()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__4__Impl" - - - // $ANTLR start "rule__ParameterStructType__Group__5" - // InternalRos.g:11391:1: rule__ParameterStructType__Group__5 : rule__ParameterStructType__Group__5__Impl ; - public final void rule__ParameterStructType__Group__5() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11395:1: ( rule__ParameterStructType__Group__5__Impl ) - // InternalRos.g:11396:2: rule__ParameterStructType__Group__5__Impl - { - pushFollow(FOLLOW_2); - rule__ParameterStructType__Group__5__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__5" - - - // $ANTLR start "rule__ParameterStructType__Group__5__Impl" - // InternalRos.g:11402:1: rule__ParameterStructType__Group__5__Impl : ( '}' ) ; - public final void rule__ParameterStructType__Group__5__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11406:1: ( ( '}' ) ) - // InternalRos.g:11407:1: ( '}' ) - { - // InternalRos.g:11407:1: ( '}' ) - // InternalRos.g:11408:2: '}' - { - before(grammarAccess.getParameterStructTypeAccess().getRightCurlyBracketKeyword_5()); - match(input,42,FOLLOW_2); - after(grammarAccess.getParameterStructTypeAccess().getRightCurlyBracketKeyword_5()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group__5__Impl" - - - // $ANTLR start "rule__ParameterStructType__Group_4__0" - // InternalRos.g:11418:1: rule__ParameterStructType__Group_4__0 : rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 ; - public final void rule__ParameterStructType__Group_4__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11422:1: ( rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 ) - // InternalRos.g:11423:2: rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 - { - pushFollow(FOLLOW_10); - rule__ParameterStructType__Group_4__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterStructType__Group_4__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group_4__0" - - - // $ANTLR start "rule__ParameterStructType__Group_4__0__Impl" - // InternalRos.g:11430:1: rule__ParameterStructType__Group_4__0__Impl : ( ',' ) ; - public final void rule__ParameterStructType__Group_4__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11434:1: ( ( ',' ) ) - // InternalRos.g:11435:1: ( ',' ) - { - // InternalRos.g:11435:1: ( ',' ) - // InternalRos.g:11436:2: ',' - { - before(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group_4__0__Impl" - - - // $ANTLR start "rule__ParameterStructType__Group_4__1" - // InternalRos.g:11445:1: rule__ParameterStructType__Group_4__1 : rule__ParameterStructType__Group_4__1__Impl ; - public final void rule__ParameterStructType__Group_4__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11449:1: ( rule__ParameterStructType__Group_4__1__Impl ) - // InternalRos.g:11450:2: rule__ParameterStructType__Group_4__1__Impl - { - pushFollow(FOLLOW_2); - rule__ParameterStructType__Group_4__1__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group_4__1" - - - // $ANTLR start "rule__ParameterStructType__Group_4__1__Impl" - // InternalRos.g:11456:1: rule__ParameterStructType__Group_4__1__Impl : ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) ; - public final void rule__ParameterStructType__Group_4__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11460:1: ( ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) ) - // InternalRos.g:11461:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) - { - // InternalRos.g:11461:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) - // InternalRos.g:11462:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) - { - before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); - // InternalRos.g:11463:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) - // InternalRos.g:11463:3: rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 - { - pushFollow(FOLLOW_2); - rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructType__Group_4__1__Impl" - - - // $ANTLR start "rule__ParameterIntegerType__Group__0" - // InternalRos.g:11472:1: rule__ParameterIntegerType__Group__0 : rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 ; - public final void rule__ParameterIntegerType__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11476:1: ( rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 ) - // InternalRos.g:11477:2: rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 - { - pushFollow(FOLLOW_52); - rule__ParameterIntegerType__Group__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterIntegerType__Group__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterIntegerType__Group__0" - - - // $ANTLR start "rule__ParameterIntegerType__Group__0__Impl" - // InternalRos.g:11484:1: rule__ParameterIntegerType__Group__0__Impl : ( () ) ; - public final void rule__ParameterIntegerType__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11488:1: ( ( () ) ) - // InternalRos.g:11489:1: ( () ) - { - // InternalRos.g:11489:1: ( () ) - // InternalRos.g:11490:2: () - { - before(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); - // InternalRos.g:11491:2: () - // InternalRos.g:11491:3: - { - } - - after(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); - - } - - - } - - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterIntegerType__Group__0__Impl" - - - // $ANTLR start "rule__ParameterIntegerType__Group__1" - // InternalRos.g:11499:1: rule__ParameterIntegerType__Group__1 : rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 ; - public final void rule__ParameterIntegerType__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11503:1: ( rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 ) - // InternalRos.g:11504:2: rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 - { - pushFollow(FOLLOW_53); - rule__ParameterIntegerType__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterIntegerType__Group__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterIntegerType__Group__1" - - - // $ANTLR start "rule__ParameterIntegerType__Group__1__Impl" - // InternalRos.g:11511:1: rule__ParameterIntegerType__Group__1__Impl : ( 'Integer' ) ; - public final void rule__ParameterIntegerType__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11515:1: ( ( 'Integer' ) ) - // InternalRos.g:11516:1: ( 'Integer' ) - { - // InternalRos.g:11516:1: ( 'Integer' ) - // InternalRos.g:11517:2: 'Integer' - { - before(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); - match(input,79,FOLLOW_2); - after(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterIntegerType__Group__1__Impl" - - - // $ANTLR start "rule__ParameterIntegerType__Group__2" - // InternalRos.g:11526:1: rule__ParameterIntegerType__Group__2 : rule__ParameterIntegerType__Group__2__Impl ; - public final void rule__ParameterIntegerType__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11530:1: ( rule__ParameterIntegerType__Group__2__Impl ) - // InternalRos.g:11531:2: rule__ParameterIntegerType__Group__2__Impl - { - pushFollow(FOLLOW_2); - rule__ParameterIntegerType__Group__2__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterIntegerType__Group__2" - - - // $ANTLR start "rule__ParameterIntegerType__Group__2__Impl" - // InternalRos.g:11537:1: rule__ParameterIntegerType__Group__2__Impl : ( ( rule__ParameterIntegerType__Group_2__0 )? ) ; - public final void rule__ParameterIntegerType__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11541:1: ( ( ( rule__ParameterIntegerType__Group_2__0 )? ) ) - // InternalRos.g:11542:1: ( ( rule__ParameterIntegerType__Group_2__0 )? ) - { - // InternalRos.g:11542:1: ( ( rule__ParameterIntegerType__Group_2__0 )? ) - // InternalRos.g:11543:2: ( rule__ParameterIntegerType__Group_2__0 )? - { - before(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); - // InternalRos.g:11544:2: ( rule__ParameterIntegerType__Group_2__0 )? - int alt72=2; - int LA72_0 = input.LA(1); - - if ( (LA72_0==80) ) { - int LA72_1 = input.LA(2); - - if ( (LA72_1==RULE_DECINT) ) { - alt72=1; - } - } - switch (alt72) { - case 1 : - // InternalRos.g:11544:3: rule__ParameterIntegerType__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__ParameterIntegerType__Group_2__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterIntegerType__Group__2__Impl" - - - // $ANTLR start "rule__ParameterIntegerType__Group_2__0" - // InternalRos.g:11553:1: rule__ParameterIntegerType__Group_2__0 : rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 ; - public final void rule__ParameterIntegerType__Group_2__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11557:1: ( rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 ) - // InternalRos.g:11558:2: rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 - { - pushFollow(FOLLOW_54); - rule__ParameterIntegerType__Group_2__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterIntegerType__Group_2__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterIntegerType__Group_2__0" - - - // $ANTLR start "rule__ParameterIntegerType__Group_2__0__Impl" - // InternalRos.g:11565:1: rule__ParameterIntegerType__Group_2__0__Impl : ( 'default' ) ; - public final void rule__ParameterIntegerType__Group_2__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11569:1: ( ( 'default' ) ) - // InternalRos.g:11570:1: ( 'default' ) - { - // InternalRos.g:11570:1: ( 'default' ) - // InternalRos.g:11571:2: 'default' - { - before(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); - match(input,80,FOLLOW_2); - after(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterIntegerType__Group_2__0__Impl" - - - // $ANTLR start "rule__ParameterIntegerType__Group_2__1" - // InternalRos.g:11580:1: rule__ParameterIntegerType__Group_2__1 : rule__ParameterIntegerType__Group_2__1__Impl ; - public final void rule__ParameterIntegerType__Group_2__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11584:1: ( rule__ParameterIntegerType__Group_2__1__Impl ) - // InternalRos.g:11585:2: rule__ParameterIntegerType__Group_2__1__Impl - { - pushFollow(FOLLOW_2); - rule__ParameterIntegerType__Group_2__1__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterIntegerType__Group_2__1" - - - // $ANTLR start "rule__ParameterIntegerType__Group_2__1__Impl" - // InternalRos.g:11591:1: rule__ParameterIntegerType__Group_2__1__Impl : ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) ; - public final void rule__ParameterIntegerType__Group_2__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11595:1: ( ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) ) - // InternalRos.g:11596:1: ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) - { - // InternalRos.g:11596:1: ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) - // InternalRos.g:11597:2: ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) - { - before(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); - // InternalRos.g:11598:2: ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) - // InternalRos.g:11598:3: rule__ParameterIntegerType__DefaultAssignment_2_1 - { - pushFollow(FOLLOW_2); - rule__ParameterIntegerType__DefaultAssignment_2_1(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterIntegerType__Group_2__1__Impl" - - - // $ANTLR start "rule__ParameterStringType__Group__0" - // InternalRos.g:11607:1: rule__ParameterStringType__Group__0 : rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 ; - public final void rule__ParameterStringType__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11611:1: ( rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 ) - // InternalRos.g:11612:2: rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 - { - pushFollow(FOLLOW_55); - rule__ParameterStringType__Group__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterStringType__Group__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStringType__Group__0" - - - // $ANTLR start "rule__ParameterStringType__Group__0__Impl" - // InternalRos.g:11619:1: rule__ParameterStringType__Group__0__Impl : ( () ) ; - public final void rule__ParameterStringType__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11623:1: ( ( () ) ) - // InternalRos.g:11624:1: ( () ) - { - // InternalRos.g:11624:1: ( () ) - // InternalRos.g:11625:2: () - { - before(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); - // InternalRos.g:11626:2: () - // InternalRos.g:11626:3: - { - } - - after(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); - - } - - - } - - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStringType__Group__0__Impl" - - - // $ANTLR start "rule__ParameterStringType__Group__1" - // InternalRos.g:11634:1: rule__ParameterStringType__Group__1 : rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 ; - public final void rule__ParameterStringType__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11638:1: ( rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 ) - // InternalRos.g:11639:2: rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 - { - pushFollow(FOLLOW_53); - rule__ParameterStringType__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterStringType__Group__2(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStringType__Group__1" - - - // $ANTLR start "rule__ParameterStringType__Group__1__Impl" - // InternalRos.g:11646:1: rule__ParameterStringType__Group__1__Impl : ( 'String' ) ; - public final void rule__ParameterStringType__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11650:1: ( ( 'String' ) ) - // InternalRos.g:11651:1: ( 'String' ) - { - // InternalRos.g:11651:1: ( 'String' ) - // InternalRos.g:11652:2: 'String' - { - before(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); - match(input,28,FOLLOW_2); - after(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStringType__Group__1__Impl" - - - // $ANTLR start "rule__ParameterStringType__Group__2" - // InternalRos.g:11661:1: rule__ParameterStringType__Group__2 : rule__ParameterStringType__Group__2__Impl ; - public final void rule__ParameterStringType__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11665:1: ( rule__ParameterStringType__Group__2__Impl ) - // InternalRos.g:11666:2: rule__ParameterStringType__Group__2__Impl - { - pushFollow(FOLLOW_2); - rule__ParameterStringType__Group__2__Impl(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStringType__Group__2" - - - // $ANTLR start "rule__ParameterStringType__Group__2__Impl" - // InternalRos.g:11672:1: rule__ParameterStringType__Group__2__Impl : ( ( rule__ParameterStringType__Group_2__0 )? ) ; - public final void rule__ParameterStringType__Group__2__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11676:1: ( ( ( rule__ParameterStringType__Group_2__0 )? ) ) - // InternalRos.g:11677:1: ( ( rule__ParameterStringType__Group_2__0 )? ) - { - // InternalRos.g:11677:1: ( ( rule__ParameterStringType__Group_2__0 )? ) - // InternalRos.g:11678:2: ( rule__ParameterStringType__Group_2__0 )? - { - before(grammarAccess.getParameterStringTypeAccess().getGroup_2()); - // InternalRos.g:11679:2: ( rule__ParameterStringType__Group_2__0 )? - int alt73=2; - int LA73_0 = input.LA(1); - - if ( (LA73_0==80) ) { - int LA73_1 = input.LA(2); - - if ( ((LA73_1>=RULE_STRING && LA73_1<=RULE_ID)) ) { - alt73=1; - } - } - switch (alt73) { - case 1 : - // InternalRos.g:11679:3: rule__ParameterStringType__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__ParameterStringType__Group_2__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getParameterStringTypeAccess().getGroup_2()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStringType__Group__2__Impl" - - - // $ANTLR start "rule__ParameterStringType__Group_2__0" - // InternalRos.g:11688:1: rule__ParameterStringType__Group_2__0 : rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 ; - public final void rule__ParameterStringType__Group_2__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11692:1: ( rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 ) - // InternalRos.g:11693:2: rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 - { - pushFollow(FOLLOW_10); - rule__ParameterStringType__Group_2__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterStringType__Group_2__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStringType__Group_2__0" + // $ANTLR end "rule__ParameterStructType__Group__2__Impl" - // $ANTLR start "rule__ParameterStringType__Group_2__0__Impl" - // InternalRos.g:11700:1: rule__ParameterStringType__Group_2__0__Impl : ( 'default' ) ; - public final void rule__ParameterStringType__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__3" + // InternalRosParser.g:8864:1: rule__ParameterStructType__Group__3 : rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 ; + public final void rule__ParameterStructType__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11704:1: ( ( 'default' ) ) - // InternalRos.g:11705:1: ( 'default' ) + // InternalRosParser.g:8868:1: ( rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 ) + // InternalRosParser.g:8869:2: rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 { - // InternalRos.g:11705:1: ( 'default' ) - // InternalRos.g:11706:2: 'default' - { - before(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); - match(input,80,FOLLOW_2); - after(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStringType__Group_2__0__Impl" - - - // $ANTLR start "rule__ParameterStringType__Group_2__1" - // InternalRos.g:11715:1: rule__ParameterStringType__Group_2__1 : rule__ParameterStringType__Group_2__1__Impl ; - public final void rule__ParameterStringType__Group_2__1() throws RecognitionException { + pushFollow(FOLLOW_13); + rule__ParameterStructType__Group__3__Impl(); + + state._fsp--; - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11719:1: ( rule__ParameterStringType__Group_2__1__Impl ) - // InternalRos.g:11720:2: rule__ParameterStringType__Group_2__1__Impl - { pushFollow(FOLLOW_2); - rule__ParameterStringType__Group_2__1__Impl(); + rule__ParameterStructType__Group__4(); state._fsp--; @@ -35550,35 +26739,35 @@ public final void rule__ParameterStringType__Group_2__1() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterStringType__Group_2__1" + // $ANTLR end "rule__ParameterStructType__Group__3" - // $ANTLR start "rule__ParameterStringType__Group_2__1__Impl" - // InternalRos.g:11726:1: rule__ParameterStringType__Group_2__1__Impl : ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) ; - public final void rule__ParameterStringType__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__3__Impl" + // InternalRosParser.g:8876:1: rule__ParameterStructType__Group__3__Impl : ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) ; + public final void rule__ParameterStructType__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11730:1: ( ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) ) - // InternalRos.g:11731:1: ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) + // InternalRosParser.g:8880:1: ( ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) ) + // InternalRosParser.g:8881:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) { - // InternalRos.g:11731:1: ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) - // InternalRos.g:11732:2: ( rule__ParameterStringType__DefaultAssignment_2_1 ) + // InternalRosParser.g:8881:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) + // InternalRosParser.g:8882:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) { - before(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); - // InternalRos.g:11733:2: ( rule__ParameterStringType__DefaultAssignment_2_1 ) - // InternalRos.g:11733:3: rule__ParameterStringType__DefaultAssignment_2_1 + before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); + // InternalRosParser.g:8883:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) + // InternalRosParser.g:8883:3: rule__ParameterStructType__ParameterstructypetmemberAssignment_3 { pushFollow(FOLLOW_2); - rule__ParameterStringType__DefaultAssignment_2_1(); + rule__ParameterStructType__ParameterstructypetmemberAssignment_3(); state._fsp--; } - after(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); + after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); } @@ -35597,26 +26786,26 @@ public final void rule__ParameterStringType__Group_2__1__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__ParameterStringType__Group_2__1__Impl" + // $ANTLR end "rule__ParameterStructType__Group__3__Impl" - // $ANTLR start "rule__ParameterDoubleType__Group__0" - // InternalRos.g:11742:1: rule__ParameterDoubleType__Group__0 : rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 ; - public final void rule__ParameterDoubleType__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__4" + // InternalRosParser.g:8891:1: rule__ParameterStructType__Group__4 : rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 ; + public final void rule__ParameterStructType__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11746:1: ( rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 ) - // InternalRos.g:11747:2: rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 + // InternalRosParser.g:8895:1: ( rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 ) + // InternalRosParser.g:8896:2: rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 { - pushFollow(FOLLOW_56); - rule__ParameterDoubleType__Group__0__Impl(); + pushFollow(FOLLOW_13); + rule__ParameterStructType__Group__4__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterDoubleType__Group__1(); + rule__ParameterStructType__Group__5(); state._fsp--; @@ -35635,100 +26824,53 @@ public final void rule__ParameterDoubleType__Group__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterDoubleType__Group__0" + // $ANTLR end "rule__ParameterStructType__Group__4" - // $ANTLR start "rule__ParameterDoubleType__Group__0__Impl" - // InternalRos.g:11754:1: rule__ParameterDoubleType__Group__0__Impl : ( () ) ; - public final void rule__ParameterDoubleType__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__4__Impl" + // InternalRosParser.g:8903:1: rule__ParameterStructType__Group__4__Impl : ( ( rule__ParameterStructType__Group_4__0 )* ) ; + public final void rule__ParameterStructType__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11758:1: ( ( () ) ) - // InternalRos.g:11759:1: ( () ) - { - // InternalRos.g:11759:1: ( () ) - // InternalRos.g:11760:2: () - { - before(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); - // InternalRos.g:11761:2: () - // InternalRos.g:11761:3: + // InternalRosParser.g:8907:1: ( ( ( rule__ParameterStructType__Group_4__0 )* ) ) + // InternalRosParser.g:8908:1: ( ( rule__ParameterStructType__Group_4__0 )* ) { - } - - after(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); - - } - - - } - - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterDoubleType__Group__0__Impl" - - - // $ANTLR start "rule__ParameterDoubleType__Group__1" - // InternalRos.g:11769:1: rule__ParameterDoubleType__Group__1 : rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 ; - public final void rule__ParameterDoubleType__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11773:1: ( rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 ) - // InternalRos.g:11774:2: rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 + // InternalRosParser.g:8908:1: ( ( rule__ParameterStructType__Group_4__0 )* ) + // InternalRosParser.g:8909:2: ( rule__ParameterStructType__Group_4__0 )* { - pushFollow(FOLLOW_53); - rule__ParameterDoubleType__Group__1__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterDoubleType__Group__2(); - - state._fsp--; + before(grammarAccess.getParameterStructTypeAccess().getGroup_4()); + // InternalRosParser.g:8910:2: ( rule__ParameterStructType__Group_4__0 )* + loop49: + do { + int alt49=2; + int LA49_0 = input.LA(1); + if ( (LA49_0==Comma) ) { + alt49=1; + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt49) { + case 1 : + // InternalRosParser.g:8910:3: rule__ParameterStructType__Group_4__0 + { + pushFollow(FOLLOW_14); + rule__ParameterStructType__Group_4__0(); - restoreStackSize(stackSize); + state._fsp--; - } - return ; - } - // $ANTLR end "rule__ParameterDoubleType__Group__1" + } + break; - // $ANTLR start "rule__ParameterDoubleType__Group__1__Impl" - // InternalRos.g:11781:1: rule__ParameterDoubleType__Group__1__Impl : ( 'Double' ) ; - public final void rule__ParameterDoubleType__Group__1__Impl() throws RecognitionException { + default : + break loop49; + } + } while (true); - int stackSize = keepStackSize(); - - try { - // InternalRos.g:11785:1: ( ( 'Double' ) ) - // InternalRos.g:11786:1: ( 'Double' ) - { - // InternalRos.g:11786:1: ( 'Double' ) - // InternalRos.g:11787:2: 'Double' - { - before(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); - match(input,81,FOLLOW_2); - after(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); + after(grammarAccess.getParameterStructTypeAccess().getGroup_4()); } @@ -35747,21 +26889,21 @@ public final void rule__ParameterDoubleType__Group__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ParameterDoubleType__Group__1__Impl" + // $ANTLR end "rule__ParameterStructType__Group__4__Impl" - // $ANTLR start "rule__ParameterDoubleType__Group__2" - // InternalRos.g:11796:1: rule__ParameterDoubleType__Group__2 : rule__ParameterDoubleType__Group__2__Impl ; - public final void rule__ParameterDoubleType__Group__2() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__5" + // InternalRosParser.g:8918:1: rule__ParameterStructType__Group__5 : rule__ParameterStructType__Group__5__Impl ; + public final void rule__ParameterStructType__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11800:1: ( rule__ParameterDoubleType__Group__2__Impl ) - // InternalRos.g:11801:2: rule__ParameterDoubleType__Group__2__Impl + // InternalRosParser.g:8922:1: ( rule__ParameterStructType__Group__5__Impl ) + // InternalRosParser.g:8923:2: rule__ParameterStructType__Group__5__Impl { pushFollow(FOLLOW_2); - rule__ParameterDoubleType__Group__2__Impl(); + rule__ParameterStructType__Group__5__Impl(); state._fsp--; @@ -35780,50 +26922,25 @@ public final void rule__ParameterDoubleType__Group__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterDoubleType__Group__2" + // $ANTLR end "rule__ParameterStructType__Group__5" - // $ANTLR start "rule__ParameterDoubleType__Group__2__Impl" - // InternalRos.g:11807:1: rule__ParameterDoubleType__Group__2__Impl : ( ( rule__ParameterDoubleType__Group_2__0 )? ) ; - public final void rule__ParameterDoubleType__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group__5__Impl" + // InternalRosParser.g:8929:1: rule__ParameterStructType__Group__5__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterStructType__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11811:1: ( ( ( rule__ParameterDoubleType__Group_2__0 )? ) ) - // InternalRos.g:11812:1: ( ( rule__ParameterDoubleType__Group_2__0 )? ) + // InternalRosParser.g:8933:1: ( ( RightSquareBracket ) ) + // InternalRosParser.g:8934:1: ( RightSquareBracket ) { - // InternalRos.g:11812:1: ( ( rule__ParameterDoubleType__Group_2__0 )? ) - // InternalRos.g:11813:2: ( rule__ParameterDoubleType__Group_2__0 )? + // InternalRosParser.g:8934:1: ( RightSquareBracket ) + // InternalRosParser.g:8935:2: RightSquareBracket { - before(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); - // InternalRos.g:11814:2: ( rule__ParameterDoubleType__Group_2__0 )? - int alt74=2; - int LA74_0 = input.LA(1); - - if ( (LA74_0==80) ) { - int LA74_1 = input.LA(2); - - if ( (LA74_1==RULE_DOUBLE) ) { - alt74=1; - } - } - switch (alt74) { - case 1 : - // InternalRos.g:11814:3: rule__ParameterDoubleType__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__ParameterDoubleType__Group_2__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); + before(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); } @@ -35842,26 +26959,26 @@ public final void rule__ParameterDoubleType__Group__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ParameterDoubleType__Group__2__Impl" + // $ANTLR end "rule__ParameterStructType__Group__5__Impl" - // $ANTLR start "rule__ParameterDoubleType__Group_2__0" - // InternalRos.g:11823:1: rule__ParameterDoubleType__Group_2__0 : rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 ; - public final void rule__ParameterDoubleType__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group_4__0" + // InternalRosParser.g:8945:1: rule__ParameterStructType__Group_4__0 : rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 ; + public final void rule__ParameterStructType__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11827:1: ( rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 ) - // InternalRos.g:11828:2: rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 + // InternalRosParser.g:8949:1: ( rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 ) + // InternalRosParser.g:8950:2: rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 { - pushFollow(FOLLOW_57); - rule__ParameterDoubleType__Group_2__0__Impl(); + pushFollow(FOLLOW_8); + rule__ParameterStructType__Group_4__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterDoubleType__Group_2__1(); + rule__ParameterStructType__Group_4__1(); state._fsp--; @@ -35880,25 +26997,25 @@ public final void rule__ParameterDoubleType__Group_2__0() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterDoubleType__Group_2__0" + // $ANTLR end "rule__ParameterStructType__Group_4__0" - // $ANTLR start "rule__ParameterDoubleType__Group_2__0__Impl" - // InternalRos.g:11835:1: rule__ParameterDoubleType__Group_2__0__Impl : ( 'default' ) ; - public final void rule__ParameterDoubleType__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group_4__0__Impl" + // InternalRosParser.g:8957:1: rule__ParameterStructType__Group_4__0__Impl : ( Comma ) ; + public final void rule__ParameterStructType__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11839:1: ( ( 'default' ) ) - // InternalRos.g:11840:1: ( 'default' ) + // InternalRosParser.g:8961:1: ( ( Comma ) ) + // InternalRosParser.g:8962:1: ( Comma ) { - // InternalRos.g:11840:1: ( 'default' ) - // InternalRos.g:11841:2: 'default' + // InternalRosParser.g:8962:1: ( Comma ) + // InternalRosParser.g:8963:2: Comma { - before(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); - match(input,80,FOLLOW_2); - after(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); + before(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); } @@ -35917,21 +27034,21 @@ public final void rule__ParameterDoubleType__Group_2__0__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__ParameterDoubleType__Group_2__0__Impl" + // $ANTLR end "rule__ParameterStructType__Group_4__0__Impl" - // $ANTLR start "rule__ParameterDoubleType__Group_2__1" - // InternalRos.g:11850:1: rule__ParameterDoubleType__Group_2__1 : rule__ParameterDoubleType__Group_2__1__Impl ; - public final void rule__ParameterDoubleType__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group_4__1" + // InternalRosParser.g:8972:1: rule__ParameterStructType__Group_4__1 : rule__ParameterStructType__Group_4__1__Impl ; + public final void rule__ParameterStructType__Group_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11854:1: ( rule__ParameterDoubleType__Group_2__1__Impl ) - // InternalRos.g:11855:2: rule__ParameterDoubleType__Group_2__1__Impl + // InternalRosParser.g:8976:1: ( rule__ParameterStructType__Group_4__1__Impl ) + // InternalRosParser.g:8977:2: rule__ParameterStructType__Group_4__1__Impl { pushFollow(FOLLOW_2); - rule__ParameterDoubleType__Group_2__1__Impl(); + rule__ParameterStructType__Group_4__1__Impl(); state._fsp--; @@ -35950,35 +27067,35 @@ public final void rule__ParameterDoubleType__Group_2__1() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterDoubleType__Group_2__1" + // $ANTLR end "rule__ParameterStructType__Group_4__1" - // $ANTLR start "rule__ParameterDoubleType__Group_2__1__Impl" - // InternalRos.g:11861:1: rule__ParameterDoubleType__Group_2__1__Impl : ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) ; - public final void rule__ParameterDoubleType__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructType__Group_4__1__Impl" + // InternalRosParser.g:8983:1: rule__ParameterStructType__Group_4__1__Impl : ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) ; + public final void rule__ParameterStructType__Group_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11865:1: ( ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) ) - // InternalRos.g:11866:1: ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) + // InternalRosParser.g:8987:1: ( ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) ) + // InternalRosParser.g:8988:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) { - // InternalRos.g:11866:1: ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) - // InternalRos.g:11867:2: ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) + // InternalRosParser.g:8988:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) + // InternalRosParser.g:8989:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) { - before(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); - // InternalRos.g:11868:2: ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) - // InternalRos.g:11868:3: rule__ParameterDoubleType__DefaultAssignment_2_1 + before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); + // InternalRosParser.g:8990:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) + // InternalRosParser.g:8990:3: rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 { pushFollow(FOLLOW_2); - rule__ParameterDoubleType__DefaultAssignment_2_1(); + rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1(); state._fsp--; } - after(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); + after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); } @@ -35997,26 +27114,26 @@ public final void rule__ParameterDoubleType__Group_2__1__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__ParameterDoubleType__Group_2__1__Impl" + // $ANTLR end "rule__ParameterStructType__Group_4__1__Impl" - // $ANTLR start "rule__ParameterBooleanType__Group__0" - // InternalRos.g:11877:1: rule__ParameterBooleanType__Group__0 : rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 ; - public final void rule__ParameterBooleanType__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterIntegerType__Group__0" + // InternalRosParser.g:8999:1: rule__ParameterIntegerType__Group__0 : rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 ; + public final void rule__ParameterIntegerType__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11881:1: ( rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 ) - // InternalRos.g:11882:2: rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 + // InternalRosParser.g:9003:1: ( rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 ) + // InternalRosParser.g:9004:2: rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 { - pushFollow(FOLLOW_58); - rule__ParameterBooleanType__Group__0__Impl(); + pushFollow(FOLLOW_45); + rule__ParameterIntegerType__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterBooleanType__Group__1(); + rule__ParameterIntegerType__Group__1(); state._fsp--; @@ -36035,29 +27152,29 @@ public final void rule__ParameterBooleanType__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ParameterBooleanType__Group__0" + // $ANTLR end "rule__ParameterIntegerType__Group__0" - // $ANTLR start "rule__ParameterBooleanType__Group__0__Impl" - // InternalRos.g:11889:1: rule__ParameterBooleanType__Group__0__Impl : ( () ) ; - public final void rule__ParameterBooleanType__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterIntegerType__Group__0__Impl" + // InternalRosParser.g:9011:1: rule__ParameterIntegerType__Group__0__Impl : ( () ) ; + public final void rule__ParameterIntegerType__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11893:1: ( ( () ) ) - // InternalRos.g:11894:1: ( () ) + // InternalRosParser.g:9015:1: ( ( () ) ) + // InternalRosParser.g:9016:1: ( () ) { - // InternalRos.g:11894:1: ( () ) - // InternalRos.g:11895:2: () + // InternalRosParser.g:9016:1: ( () ) + // InternalRosParser.g:9017:2: () { - before(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); - // InternalRos.g:11896:2: () - // InternalRos.g:11896:3: + before(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); + // InternalRosParser.g:9018:2: () + // InternalRosParser.g:9018:3: { } - after(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); + after(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); } @@ -36072,26 +27189,26 @@ public final void rule__ParameterBooleanType__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__ParameterBooleanType__Group__0__Impl" + // $ANTLR end "rule__ParameterIntegerType__Group__0__Impl" - // $ANTLR start "rule__ParameterBooleanType__Group__1" - // InternalRos.g:11904:1: rule__ParameterBooleanType__Group__1 : rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 ; - public final void rule__ParameterBooleanType__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterIntegerType__Group__1" + // InternalRosParser.g:9026:1: rule__ParameterIntegerType__Group__1 : rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 ; + public final void rule__ParameterIntegerType__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11908:1: ( rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 ) - // InternalRos.g:11909:2: rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 + // InternalRosParser.g:9030:1: ( rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 ) + // InternalRosParser.g:9031:2: rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 { - pushFollow(FOLLOW_53); - rule__ParameterBooleanType__Group__1__Impl(); + pushFollow(FOLLOW_46); + rule__ParameterIntegerType__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterBooleanType__Group__2(); + rule__ParameterIntegerType__Group__2(); state._fsp--; @@ -36110,25 +27227,25 @@ public final void rule__ParameterBooleanType__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ParameterBooleanType__Group__1" + // $ANTLR end "rule__ParameterIntegerType__Group__1" - // $ANTLR start "rule__ParameterBooleanType__Group__1__Impl" - // InternalRos.g:11916:1: rule__ParameterBooleanType__Group__1__Impl : ( 'Boolean' ) ; - public final void rule__ParameterBooleanType__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterIntegerType__Group__1__Impl" + // InternalRosParser.g:9038:1: rule__ParameterIntegerType__Group__1__Impl : ( Integer ) ; + public final void rule__ParameterIntegerType__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11920:1: ( ( 'Boolean' ) ) - // InternalRos.g:11921:1: ( 'Boolean' ) + // InternalRosParser.g:9042:1: ( ( Integer ) ) + // InternalRosParser.g:9043:1: ( Integer ) { - // InternalRos.g:11921:1: ( 'Boolean' ) - // InternalRos.g:11922:2: 'Boolean' + // InternalRosParser.g:9043:1: ( Integer ) + // InternalRosParser.g:9044:2: Integer { - before(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); - match(input,82,FOLLOW_2); - after(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); + before(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); + match(input,Integer,FOLLOW_2); + after(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); } @@ -36147,21 +27264,21 @@ public final void rule__ParameterBooleanType__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__ParameterBooleanType__Group__1__Impl" + // $ANTLR end "rule__ParameterIntegerType__Group__1__Impl" - // $ANTLR start "rule__ParameterBooleanType__Group__2" - // InternalRos.g:11931:1: rule__ParameterBooleanType__Group__2 : rule__ParameterBooleanType__Group__2__Impl ; - public final void rule__ParameterBooleanType__Group__2() throws RecognitionException { + // $ANTLR start "rule__ParameterIntegerType__Group__2" + // InternalRosParser.g:9053:1: rule__ParameterIntegerType__Group__2 : rule__ParameterIntegerType__Group__2__Impl ; + public final void rule__ParameterIntegerType__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11935:1: ( rule__ParameterBooleanType__Group__2__Impl ) - // InternalRos.g:11936:2: rule__ParameterBooleanType__Group__2__Impl + // InternalRosParser.g:9057:1: ( rule__ParameterIntegerType__Group__2__Impl ) + // InternalRosParser.g:9058:2: rule__ParameterIntegerType__Group__2__Impl { pushFollow(FOLLOW_2); - rule__ParameterBooleanType__Group__2__Impl(); + rule__ParameterIntegerType__Group__2__Impl(); state._fsp--; @@ -36180,40 +27297,40 @@ public final void rule__ParameterBooleanType__Group__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ParameterBooleanType__Group__2" + // $ANTLR end "rule__ParameterIntegerType__Group__2" - // $ANTLR start "rule__ParameterBooleanType__Group__2__Impl" - // InternalRos.g:11942:1: rule__ParameterBooleanType__Group__2__Impl : ( ( rule__ParameterBooleanType__Group_2__0 )? ) ; - public final void rule__ParameterBooleanType__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterIntegerType__Group__2__Impl" + // InternalRosParser.g:9064:1: rule__ParameterIntegerType__Group__2__Impl : ( ( rule__ParameterIntegerType__Group_2__0 )? ) ; + public final void rule__ParameterIntegerType__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11946:1: ( ( ( rule__ParameterBooleanType__Group_2__0 )? ) ) - // InternalRos.g:11947:1: ( ( rule__ParameterBooleanType__Group_2__0 )? ) + // InternalRosParser.g:9068:1: ( ( ( rule__ParameterIntegerType__Group_2__0 )? ) ) + // InternalRosParser.g:9069:1: ( ( rule__ParameterIntegerType__Group_2__0 )? ) { - // InternalRos.g:11947:1: ( ( rule__ParameterBooleanType__Group_2__0 )? ) - // InternalRos.g:11948:2: ( rule__ParameterBooleanType__Group_2__0 )? + // InternalRosParser.g:9069:1: ( ( rule__ParameterIntegerType__Group_2__0 )? ) + // InternalRosParser.g:9070:2: ( rule__ParameterIntegerType__Group_2__0 )? { - before(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); - // InternalRos.g:11949:2: ( rule__ParameterBooleanType__Group_2__0 )? - int alt75=2; - int LA75_0 = input.LA(1); + before(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); + // InternalRosParser.g:9071:2: ( rule__ParameterIntegerType__Group_2__0 )? + int alt50=2; + int LA50_0 = input.LA(1); - if ( (LA75_0==80) ) { - int LA75_1 = input.LA(2); + if ( (LA50_0==Default) ) { + int LA50_1 = input.LA(2); - if ( (LA75_1==RULE_BOOLEAN) ) { - alt75=1; + if ( (LA50_1==RULE_DECINT) ) { + alt50=1; } } - switch (alt75) { + switch (alt50) { case 1 : - // InternalRos.g:11949:3: rule__ParameterBooleanType__Group_2__0 + // InternalRosParser.g:9071:3: rule__ParameterIntegerType__Group_2__0 { pushFollow(FOLLOW_2); - rule__ParameterBooleanType__Group_2__0(); + rule__ParameterIntegerType__Group_2__0(); state._fsp--; @@ -36223,7 +27340,7 @@ public final void rule__ParameterBooleanType__Group__2__Impl() throws Recognitio } - after(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); + after(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); } @@ -36242,26 +27359,26 @@ public final void rule__ParameterBooleanType__Group__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__ParameterBooleanType__Group__2__Impl" + // $ANTLR end "rule__ParameterIntegerType__Group__2__Impl" - // $ANTLR start "rule__ParameterBooleanType__Group_2__0" - // InternalRos.g:11958:1: rule__ParameterBooleanType__Group_2__0 : rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 ; - public final void rule__ParameterBooleanType__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__ParameterIntegerType__Group_2__0" + // InternalRosParser.g:9080:1: rule__ParameterIntegerType__Group_2__0 : rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 ; + public final void rule__ParameterIntegerType__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11962:1: ( rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 ) - // InternalRos.g:11963:2: rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 + // InternalRosParser.g:9084:1: ( rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 ) + // InternalRosParser.g:9085:2: rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 { - pushFollow(FOLLOW_59); - rule__ParameterBooleanType__Group_2__0__Impl(); + pushFollow(FOLLOW_47); + rule__ParameterIntegerType__Group_2__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterBooleanType__Group_2__1(); + rule__ParameterIntegerType__Group_2__1(); state._fsp--; @@ -36280,25 +27397,25 @@ public final void rule__ParameterBooleanType__Group_2__0() throws RecognitionExc } return ; } - // $ANTLR end "rule__ParameterBooleanType__Group_2__0" + // $ANTLR end "rule__ParameterIntegerType__Group_2__0" - // $ANTLR start "rule__ParameterBooleanType__Group_2__0__Impl" - // InternalRos.g:11970:1: rule__ParameterBooleanType__Group_2__0__Impl : ( 'default' ) ; - public final void rule__ParameterBooleanType__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterIntegerType__Group_2__0__Impl" + // InternalRosParser.g:9092:1: rule__ParameterIntegerType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterIntegerType__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11974:1: ( ( 'default' ) ) - // InternalRos.g:11975:1: ( 'default' ) + // InternalRosParser.g:9096:1: ( ( Default ) ) + // InternalRosParser.g:9097:1: ( Default ) { - // InternalRos.g:11975:1: ( 'default' ) - // InternalRos.g:11976:2: 'default' + // InternalRosParser.g:9097:1: ( Default ) + // InternalRosParser.g:9098:2: Default { - before(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); - match(input,80,FOLLOW_2); - after(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); + before(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); } @@ -36317,21 +27434,21 @@ public final void rule__ParameterBooleanType__Group_2__0__Impl() throws Recognit } return ; } - // $ANTLR end "rule__ParameterBooleanType__Group_2__0__Impl" + // $ANTLR end "rule__ParameterIntegerType__Group_2__0__Impl" - // $ANTLR start "rule__ParameterBooleanType__Group_2__1" - // InternalRos.g:11985:1: rule__ParameterBooleanType__Group_2__1 : rule__ParameterBooleanType__Group_2__1__Impl ; - public final void rule__ParameterBooleanType__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__ParameterIntegerType__Group_2__1" + // InternalRosParser.g:9107:1: rule__ParameterIntegerType__Group_2__1 : rule__ParameterIntegerType__Group_2__1__Impl ; + public final void rule__ParameterIntegerType__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:11989:1: ( rule__ParameterBooleanType__Group_2__1__Impl ) - // InternalRos.g:11990:2: rule__ParameterBooleanType__Group_2__1__Impl + // InternalRosParser.g:9111:1: ( rule__ParameterIntegerType__Group_2__1__Impl ) + // InternalRosParser.g:9112:2: rule__ParameterIntegerType__Group_2__1__Impl { pushFollow(FOLLOW_2); - rule__ParameterBooleanType__Group_2__1__Impl(); + rule__ParameterIntegerType__Group_2__1__Impl(); state._fsp--; @@ -36350,35 +27467,35 @@ public final void rule__ParameterBooleanType__Group_2__1() throws RecognitionExc } return ; } - // $ANTLR end "rule__ParameterBooleanType__Group_2__1" + // $ANTLR end "rule__ParameterIntegerType__Group_2__1" - // $ANTLR start "rule__ParameterBooleanType__Group_2__1__Impl" - // InternalRos.g:11996:1: rule__ParameterBooleanType__Group_2__1__Impl : ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) ; - public final void rule__ParameterBooleanType__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterIntegerType__Group_2__1__Impl" + // InternalRosParser.g:9118:1: rule__ParameterIntegerType__Group_2__1__Impl : ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterIntegerType__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12000:1: ( ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) ) - // InternalRos.g:12001:1: ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) + // InternalRosParser.g:9122:1: ( ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) ) + // InternalRosParser.g:9123:1: ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) { - // InternalRos.g:12001:1: ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) - // InternalRos.g:12002:2: ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) + // InternalRosParser.g:9123:1: ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) + // InternalRosParser.g:9124:2: ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) { - before(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); - // InternalRos.g:12003:2: ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) - // InternalRos.g:12003:3: rule__ParameterBooleanType__DefaultAssignment_2_1 + before(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); + // InternalRosParser.g:9125:2: ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) + // InternalRosParser.g:9125:3: rule__ParameterIntegerType__DefaultAssignment_2_1 { pushFollow(FOLLOW_2); - rule__ParameterBooleanType__DefaultAssignment_2_1(); + rule__ParameterIntegerType__DefaultAssignment_2_1(); state._fsp--; } - after(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); + after(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); } @@ -36397,26 +27514,26 @@ public final void rule__ParameterBooleanType__Group_2__1__Impl() throws Recognit } return ; } - // $ANTLR end "rule__ParameterBooleanType__Group_2__1__Impl" + // $ANTLR end "rule__ParameterIntegerType__Group_2__1__Impl" - // $ANTLR start "rule__ParameterBase64Type__Group__0" - // InternalRos.g:12012:1: rule__ParameterBase64Type__Group__0 : rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 ; - public final void rule__ParameterBase64Type__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterStringType__Group__0" + // InternalRosParser.g:9134:1: rule__ParameterStringType__Group__0 : rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 ; + public final void rule__ParameterStringType__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12016:1: ( rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 ) - // InternalRos.g:12017:2: rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 + // InternalRosParser.g:9138:1: ( rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 ) + // InternalRosParser.g:9139:2: rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 { - pushFollow(FOLLOW_60); - rule__ParameterBase64Type__Group__0__Impl(); + pushFollow(FOLLOW_48); + rule__ParameterStringType__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterBase64Type__Group__1(); + rule__ParameterStringType__Group__1(); state._fsp--; @@ -36435,29 +27552,29 @@ public final void rule__ParameterBase64Type__Group__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterBase64Type__Group__0" + // $ANTLR end "rule__ParameterStringType__Group__0" - // $ANTLR start "rule__ParameterBase64Type__Group__0__Impl" - // InternalRos.g:12024:1: rule__ParameterBase64Type__Group__0__Impl : ( () ) ; - public final void rule__ParameterBase64Type__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStringType__Group__0__Impl" + // InternalRosParser.g:9146:1: rule__ParameterStringType__Group__0__Impl : ( () ) ; + public final void rule__ParameterStringType__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12028:1: ( ( () ) ) - // InternalRos.g:12029:1: ( () ) + // InternalRosParser.g:9150:1: ( ( () ) ) + // InternalRosParser.g:9151:1: ( () ) { - // InternalRos.g:12029:1: ( () ) - // InternalRos.g:12030:2: () + // InternalRosParser.g:9151:1: ( () ) + // InternalRosParser.g:9152:2: () { - before(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); - // InternalRos.g:12031:2: () - // InternalRos.g:12031:3: + before(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); + // InternalRosParser.g:9153:2: () + // InternalRosParser.g:9153:3: { } - after(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); + after(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); } @@ -36472,26 +27589,26 @@ public final void rule__ParameterBase64Type__Group__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ParameterBase64Type__Group__0__Impl" + // $ANTLR end "rule__ParameterStringType__Group__0__Impl" - // $ANTLR start "rule__ParameterBase64Type__Group__1" - // InternalRos.g:12039:1: rule__ParameterBase64Type__Group__1 : rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 ; - public final void rule__ParameterBase64Type__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStringType__Group__1" + // InternalRosParser.g:9161:1: rule__ParameterStringType__Group__1 : rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 ; + public final void rule__ParameterStringType__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12043:1: ( rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 ) - // InternalRos.g:12044:2: rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 + // InternalRosParser.g:9165:1: ( rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 ) + // InternalRosParser.g:9166:2: rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 { - pushFollow(FOLLOW_53); - rule__ParameterBase64Type__Group__1__Impl(); + pushFollow(FOLLOW_46); + rule__ParameterStringType__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterBase64Type__Group__2(); + rule__ParameterStringType__Group__2(); state._fsp--; @@ -36510,25 +27627,25 @@ public final void rule__ParameterBase64Type__Group__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterBase64Type__Group__1" + // $ANTLR end "rule__ParameterStringType__Group__1" - // $ANTLR start "rule__ParameterBase64Type__Group__1__Impl" - // InternalRos.g:12051:1: rule__ParameterBase64Type__Group__1__Impl : ( 'Base64' ) ; - public final void rule__ParameterBase64Type__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStringType__Group__1__Impl" + // InternalRosParser.g:9173:1: rule__ParameterStringType__Group__1__Impl : ( String ) ; + public final void rule__ParameterStringType__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12055:1: ( ( 'Base64' ) ) - // InternalRos.g:12056:1: ( 'Base64' ) + // InternalRosParser.g:9177:1: ( ( String ) ) + // InternalRosParser.g:9178:1: ( String ) { - // InternalRos.g:12056:1: ( 'Base64' ) - // InternalRos.g:12057:2: 'Base64' + // InternalRosParser.g:9178:1: ( String ) + // InternalRosParser.g:9179:2: String { - before(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); - match(input,83,FOLLOW_2); - after(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); + before(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); + match(input,String,FOLLOW_2); + after(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); } @@ -36547,21 +27664,21 @@ public final void rule__ParameterBase64Type__Group__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ParameterBase64Type__Group__1__Impl" + // $ANTLR end "rule__ParameterStringType__Group__1__Impl" - // $ANTLR start "rule__ParameterBase64Type__Group__2" - // InternalRos.g:12066:1: rule__ParameterBase64Type__Group__2 : rule__ParameterBase64Type__Group__2__Impl ; - public final void rule__ParameterBase64Type__Group__2() throws RecognitionException { + // $ANTLR start "rule__ParameterStringType__Group__2" + // InternalRosParser.g:9188:1: rule__ParameterStringType__Group__2 : rule__ParameterStringType__Group__2__Impl ; + public final void rule__ParameterStringType__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12070:1: ( rule__ParameterBase64Type__Group__2__Impl ) - // InternalRos.g:12071:2: rule__ParameterBase64Type__Group__2__Impl + // InternalRosParser.g:9192:1: ( rule__ParameterStringType__Group__2__Impl ) + // InternalRosParser.g:9193:2: rule__ParameterStringType__Group__2__Impl { pushFollow(FOLLOW_2); - rule__ParameterBase64Type__Group__2__Impl(); + rule__ParameterStringType__Group__2__Impl(); state._fsp--; @@ -36580,40 +27697,40 @@ public final void rule__ParameterBase64Type__Group__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterBase64Type__Group__2" + // $ANTLR end "rule__ParameterStringType__Group__2" - // $ANTLR start "rule__ParameterBase64Type__Group__2__Impl" - // InternalRos.g:12077:1: rule__ParameterBase64Type__Group__2__Impl : ( ( rule__ParameterBase64Type__Group_2__0 )? ) ; - public final void rule__ParameterBase64Type__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStringType__Group__2__Impl" + // InternalRosParser.g:9199:1: rule__ParameterStringType__Group__2__Impl : ( ( rule__ParameterStringType__Group_2__0 )? ) ; + public final void rule__ParameterStringType__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12081:1: ( ( ( rule__ParameterBase64Type__Group_2__0 )? ) ) - // InternalRos.g:12082:1: ( ( rule__ParameterBase64Type__Group_2__0 )? ) + // InternalRosParser.g:9203:1: ( ( ( rule__ParameterStringType__Group_2__0 )? ) ) + // InternalRosParser.g:9204:1: ( ( rule__ParameterStringType__Group_2__0 )? ) { - // InternalRos.g:12082:1: ( ( rule__ParameterBase64Type__Group_2__0 )? ) - // InternalRos.g:12083:2: ( rule__ParameterBase64Type__Group_2__0 )? + // InternalRosParser.g:9204:1: ( ( rule__ParameterStringType__Group_2__0 )? ) + // InternalRosParser.g:9205:2: ( rule__ParameterStringType__Group_2__0 )? { - before(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); - // InternalRos.g:12084:2: ( rule__ParameterBase64Type__Group_2__0 )? - int alt76=2; - int LA76_0 = input.LA(1); + before(grammarAccess.getParameterStringTypeAccess().getGroup_2()); + // InternalRosParser.g:9206:2: ( rule__ParameterStringType__Group_2__0 )? + int alt51=2; + int LA51_0 = input.LA(1); - if ( (LA76_0==80) ) { - int LA76_1 = input.LA(2); + if ( (LA51_0==Default) ) { + int LA51_1 = input.LA(2); - if ( (LA76_1==RULE_BINARY) ) { - alt76=1; + if ( (LA51_1==RULE_ID||LA51_1==RULE_STRING) ) { + alt51=1; } } - switch (alt76) { + switch (alt51) { case 1 : - // InternalRos.g:12084:3: rule__ParameterBase64Type__Group_2__0 + // InternalRosParser.g:9206:3: rule__ParameterStringType__Group_2__0 { pushFollow(FOLLOW_2); - rule__ParameterBase64Type__Group_2__0(); + rule__ParameterStringType__Group_2__0(); state._fsp--; @@ -36623,7 +27740,7 @@ public final void rule__ParameterBase64Type__Group__2__Impl() throws Recognition } - after(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); + after(grammarAccess.getParameterStringTypeAccess().getGroup_2()); } @@ -36642,26 +27759,26 @@ public final void rule__ParameterBase64Type__Group__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ParameterBase64Type__Group__2__Impl" + // $ANTLR end "rule__ParameterStringType__Group__2__Impl" - // $ANTLR start "rule__ParameterBase64Type__Group_2__0" - // InternalRos.g:12093:1: rule__ParameterBase64Type__Group_2__0 : rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 ; - public final void rule__ParameterBase64Type__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__ParameterStringType__Group_2__0" + // InternalRosParser.g:9215:1: rule__ParameterStringType__Group_2__0 : rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 ; + public final void rule__ParameterStringType__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12097:1: ( rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 ) - // InternalRos.g:12098:2: rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 + // InternalRosParser.g:9219:1: ( rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 ) + // InternalRosParser.g:9220:2: rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 { - pushFollow(FOLLOW_61); - rule__ParameterBase64Type__Group_2__0__Impl(); + pushFollow(FOLLOW_8); + rule__ParameterStringType__Group_2__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterBase64Type__Group_2__1(); + rule__ParameterStringType__Group_2__1(); state._fsp--; @@ -36680,25 +27797,25 @@ public final void rule__ParameterBase64Type__Group_2__0() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterBase64Type__Group_2__0" + // $ANTLR end "rule__ParameterStringType__Group_2__0" - // $ANTLR start "rule__ParameterBase64Type__Group_2__0__Impl" - // InternalRos.g:12105:1: rule__ParameterBase64Type__Group_2__0__Impl : ( 'default' ) ; - public final void rule__ParameterBase64Type__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStringType__Group_2__0__Impl" + // InternalRosParser.g:9227:1: rule__ParameterStringType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterStringType__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12109:1: ( ( 'default' ) ) - // InternalRos.g:12110:1: ( 'default' ) + // InternalRosParser.g:9231:1: ( ( Default ) ) + // InternalRosParser.g:9232:1: ( Default ) { - // InternalRos.g:12110:1: ( 'default' ) - // InternalRos.g:12111:2: 'default' + // InternalRosParser.g:9232:1: ( Default ) + // InternalRosParser.g:9233:2: Default { - before(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); - match(input,80,FOLLOW_2); - after(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); + before(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); } @@ -36717,21 +27834,21 @@ public final void rule__ParameterBase64Type__Group_2__0__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__ParameterBase64Type__Group_2__0__Impl" + // $ANTLR end "rule__ParameterStringType__Group_2__0__Impl" - // $ANTLR start "rule__ParameterBase64Type__Group_2__1" - // InternalRos.g:12120:1: rule__ParameterBase64Type__Group_2__1 : rule__ParameterBase64Type__Group_2__1__Impl ; - public final void rule__ParameterBase64Type__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStringType__Group_2__1" + // InternalRosParser.g:9242:1: rule__ParameterStringType__Group_2__1 : rule__ParameterStringType__Group_2__1__Impl ; + public final void rule__ParameterStringType__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12124:1: ( rule__ParameterBase64Type__Group_2__1__Impl ) - // InternalRos.g:12125:2: rule__ParameterBase64Type__Group_2__1__Impl + // InternalRosParser.g:9246:1: ( rule__ParameterStringType__Group_2__1__Impl ) + // InternalRosParser.g:9247:2: rule__ParameterStringType__Group_2__1__Impl { pushFollow(FOLLOW_2); - rule__ParameterBase64Type__Group_2__1__Impl(); + rule__ParameterStringType__Group_2__1__Impl(); state._fsp--; @@ -36750,35 +27867,35 @@ public final void rule__ParameterBase64Type__Group_2__1() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterBase64Type__Group_2__1" + // $ANTLR end "rule__ParameterStringType__Group_2__1" - // $ANTLR start "rule__ParameterBase64Type__Group_2__1__Impl" - // InternalRos.g:12131:1: rule__ParameterBase64Type__Group_2__1__Impl : ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) ; - public final void rule__ParameterBase64Type__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStringType__Group_2__1__Impl" + // InternalRosParser.g:9253:1: rule__ParameterStringType__Group_2__1__Impl : ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterStringType__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12135:1: ( ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) ) - // InternalRos.g:12136:1: ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) + // InternalRosParser.g:9257:1: ( ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) ) + // InternalRosParser.g:9258:1: ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) { - // InternalRos.g:12136:1: ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) - // InternalRos.g:12137:2: ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) + // InternalRosParser.g:9258:1: ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) + // InternalRosParser.g:9259:2: ( rule__ParameterStringType__DefaultAssignment_2_1 ) { - before(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); - // InternalRos.g:12138:2: ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) - // InternalRos.g:12138:3: rule__ParameterBase64Type__DefaultAssignment_2_1 + before(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); + // InternalRosParser.g:9260:2: ( rule__ParameterStringType__DefaultAssignment_2_1 ) + // InternalRosParser.g:9260:3: rule__ParameterStringType__DefaultAssignment_2_1 { pushFollow(FOLLOW_2); - rule__ParameterBase64Type__DefaultAssignment_2_1(); + rule__ParameterStringType__DefaultAssignment_2_1(); state._fsp--; } - after(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); + after(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); } @@ -36797,26 +27914,26 @@ public final void rule__ParameterBase64Type__Group_2__1__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__ParameterBase64Type__Group_2__1__Impl" + // $ANTLR end "rule__ParameterStringType__Group_2__1__Impl" - // $ANTLR start "rule__ParameterArrayType__Group__0" - // InternalRos.g:12147:1: rule__ParameterArrayType__Group__0 : rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 ; - public final void rule__ParameterArrayType__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterDoubleType__Group__0" + // InternalRosParser.g:9269:1: rule__ParameterDoubleType__Group__0 : rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 ; + public final void rule__ParameterDoubleType__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12151:1: ( rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 ) - // InternalRos.g:12152:2: rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 + // InternalRosParser.g:9273:1: ( rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 ) + // InternalRosParser.g:9274:2: rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 { - pushFollow(FOLLOW_4); - rule__ParameterArrayType__Group__0__Impl(); + pushFollow(FOLLOW_49); + rule__ParameterDoubleType__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterArrayType__Group__1(); + rule__ParameterDoubleType__Group__1(); state._fsp--; @@ -36835,28 +27952,66 @@ public final void rule__ParameterArrayType__Group__0() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__0" + // $ANTLR end "rule__ParameterDoubleType__Group__0" - // $ANTLR start "rule__ParameterArrayType__Group__0__Impl" - // InternalRos.g:12159:1: rule__ParameterArrayType__Group__0__Impl : ( 'Array' ) ; - public final void rule__ParameterArrayType__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterDoubleType__Group__0__Impl" + // InternalRosParser.g:9281:1: rule__ParameterDoubleType__Group__0__Impl : ( () ) ; + public final void rule__ParameterDoubleType__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12163:1: ( ( 'Array' ) ) - // InternalRos.g:12164:1: ( 'Array' ) + // InternalRosParser.g:9285:1: ( ( () ) ) + // InternalRosParser.g:9286:1: ( () ) { - // InternalRos.g:12164:1: ( 'Array' ) - // InternalRos.g:12165:2: 'Array' + // InternalRosParser.g:9286:1: ( () ) + // InternalRosParser.g:9287:2: () { - before(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); - match(input,84,FOLLOW_2); - after(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); + before(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); + // InternalRosParser.g:9288:2: () + // InternalRosParser.g:9288:3: + { + } + + after(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); + + } + } + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterDoubleType__Group__1" + // InternalRosParser.g:9296:1: rule__ParameterDoubleType__Group__1 : rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 ; + public final void rule__ParameterDoubleType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:9300:1: ( rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 ) + // InternalRosParser.g:9301:2: rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 + { + pushFollow(FOLLOW_46); + rule__ParameterDoubleType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group__2(); + + state._fsp--; + } @@ -36872,26 +28027,58 @@ public final void rule__ParameterArrayType__Group__0__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__0__Impl" + // $ANTLR end "rule__ParameterDoubleType__Group__1" - // $ANTLR start "rule__ParameterArrayType__Group__1" - // InternalRos.g:12174:1: rule__ParameterArrayType__Group__1 : rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 ; - public final void rule__ParameterArrayType__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterDoubleType__Group__1__Impl" + // InternalRosParser.g:9308:1: rule__ParameterDoubleType__Group__1__Impl : ( Double ) ; + public final void rule__ParameterDoubleType__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12178:1: ( rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 ) - // InternalRos.g:12179:2: rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 + // InternalRosParser.g:9312:1: ( ( Double ) ) + // InternalRosParser.g:9313:1: ( Double ) { - pushFollow(FOLLOW_62); - rule__ParameterArrayType__Group__1__Impl(); + // InternalRosParser.g:9313:1: ( Double ) + // InternalRosParser.g:9314:2: Double + { + before(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); + match(input,Double,FOLLOW_2); + after(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); - state._fsp--; + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__1__Impl" + + // $ANTLR start "rule__ParameterDoubleType__Group__2" + // InternalRosParser.g:9323:1: rule__ParameterDoubleType__Group__2 : rule__ParameterDoubleType__Group__2__Impl ; + public final void rule__ParameterDoubleType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:9327:1: ( rule__ParameterDoubleType__Group__2__Impl ) + // InternalRosParser.g:9328:2: rule__ParameterDoubleType__Group__2__Impl + { pushFollow(FOLLOW_2); - rule__ParameterArrayType__Group__2(); + rule__ParameterDoubleType__Group__2__Impl(); state._fsp--; @@ -36910,25 +28097,50 @@ public final void rule__ParameterArrayType__Group__1() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__1" + // $ANTLR end "rule__ParameterDoubleType__Group__2" + + + // $ANTLR start "rule__ParameterDoubleType__Group__2__Impl" + // InternalRosParser.g:9334:1: rule__ParameterDoubleType__Group__2__Impl : ( ( rule__ParameterDoubleType__Group_2__0 )? ) ; + public final void rule__ParameterDoubleType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:9338:1: ( ( ( rule__ParameterDoubleType__Group_2__0 )? ) ) + // InternalRosParser.g:9339:1: ( ( rule__ParameterDoubleType__Group_2__0 )? ) + { + // InternalRosParser.g:9339:1: ( ( rule__ParameterDoubleType__Group_2__0 )? ) + // InternalRosParser.g:9340:2: ( rule__ParameterDoubleType__Group_2__0 )? + { + before(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); + // InternalRosParser.g:9341:2: ( rule__ParameterDoubleType__Group_2__0 )? + int alt52=2; + int LA52_0 = input.LA(1); + + if ( (LA52_0==Default) ) { + int LA52_1 = input.LA(2); + + if ( (LA52_1==RULE_DOUBLE) ) { + alt52=1; + } + } + switch (alt52) { + case 1 : + // InternalRosParser.g:9341:3: rule__ParameterDoubleType__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group_2__0(); + state._fsp--; - // $ANTLR start "rule__ParameterArrayType__Group__1__Impl" - // InternalRos.g:12186:1: rule__ParameterArrayType__Group__1__Impl : ( '{' ) ; - public final void rule__ParameterArrayType__Group__1__Impl() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalRos.g:12190:1: ( ( '{' ) ) - // InternalRos.g:12191:1: ( '{' ) - { - // InternalRos.g:12191:1: ( '{' ) - // InternalRos.g:12192:2: '{' - { - before(grammarAccess.getParameterArrayTypeAccess().getLeftCurlyBracketKeyword_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getParameterArrayTypeAccess().getLeftCurlyBracketKeyword_1()); + } + break; + + } + + after(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); } @@ -36947,26 +28159,26 @@ public final void rule__ParameterArrayType__Group__1__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__1__Impl" + // $ANTLR end "rule__ParameterDoubleType__Group__2__Impl" - // $ANTLR start "rule__ParameterArrayType__Group__2" - // InternalRos.g:12201:1: rule__ParameterArrayType__Group__2 : rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 ; - public final void rule__ParameterArrayType__Group__2() throws RecognitionException { + // $ANTLR start "rule__ParameterDoubleType__Group_2__0" + // InternalRosParser.g:9350:1: rule__ParameterDoubleType__Group_2__0 : rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 ; + public final void rule__ParameterDoubleType__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12205:1: ( rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 ) - // InternalRos.g:12206:2: rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 + // InternalRosParser.g:9354:1: ( rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 ) + // InternalRosParser.g:9355:2: rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 { - pushFollow(FOLLOW_48); - rule__ParameterArrayType__Group__2__Impl(); + pushFollow(FOLLOW_50); + rule__ParameterDoubleType__Group_2__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterArrayType__Group__3(); + rule__ParameterDoubleType__Group_2__1(); state._fsp--; @@ -36985,25 +28197,25 @@ public final void rule__ParameterArrayType__Group__2() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__2" + // $ANTLR end "rule__ParameterDoubleType__Group_2__0" - // $ANTLR start "rule__ParameterArrayType__Group__2__Impl" - // InternalRos.g:12213:1: rule__ParameterArrayType__Group__2__Impl : ( 'type' ) ; - public final void rule__ParameterArrayType__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterDoubleType__Group_2__0__Impl" + // InternalRosParser.g:9362:1: rule__ParameterDoubleType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterDoubleType__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12217:1: ( ( 'type' ) ) - // InternalRos.g:12218:1: ( 'type' ) + // InternalRosParser.g:9366:1: ( ( Default ) ) + // InternalRosParser.g:9367:1: ( Default ) { - // InternalRos.g:12218:1: ( 'type' ) - // InternalRos.g:12219:2: 'type' + // InternalRosParser.g:9367:1: ( Default ) + // InternalRosParser.g:9368:2: Default { - before(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); - match(input,36,FOLLOW_2); - after(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); + before(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); } @@ -37022,26 +28234,21 @@ public final void rule__ParameterArrayType__Group__2__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__2__Impl" + // $ANTLR end "rule__ParameterDoubleType__Group_2__0__Impl" - // $ANTLR start "rule__ParameterArrayType__Group__3" - // InternalRos.g:12228:1: rule__ParameterArrayType__Group__3 : rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 ; - public final void rule__ParameterArrayType__Group__3() throws RecognitionException { + // $ANTLR start "rule__ParameterDoubleType__Group_2__1" + // InternalRosParser.g:9377:1: rule__ParameterDoubleType__Group_2__1 : rule__ParameterDoubleType__Group_2__1__Impl ; + public final void rule__ParameterDoubleType__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12232:1: ( rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 ) - // InternalRos.g:12233:2: rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 + // InternalRosParser.g:9381:1: ( rule__ParameterDoubleType__Group_2__1__Impl ) + // InternalRosParser.g:9382:2: rule__ParameterDoubleType__Group_2__1__Impl { - pushFollow(FOLLOW_63); - rule__ParameterArrayType__Group__3__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ParameterArrayType__Group__4(); + rule__ParameterDoubleType__Group_2__1__Impl(); state._fsp--; @@ -37060,35 +28267,35 @@ public final void rule__ParameterArrayType__Group__3() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__3" + // $ANTLR end "rule__ParameterDoubleType__Group_2__1" - // $ANTLR start "rule__ParameterArrayType__Group__3__Impl" - // InternalRos.g:12240:1: rule__ParameterArrayType__Group__3__Impl : ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) ; - public final void rule__ParameterArrayType__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterDoubleType__Group_2__1__Impl" + // InternalRosParser.g:9388:1: rule__ParameterDoubleType__Group_2__1__Impl : ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterDoubleType__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12244:1: ( ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) ) - // InternalRos.g:12245:1: ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) + // InternalRosParser.g:9392:1: ( ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) ) + // InternalRosParser.g:9393:1: ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) { - // InternalRos.g:12245:1: ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) - // InternalRos.g:12246:2: ( rule__ParameterArrayType__TypeAssignment_3 ) + // InternalRosParser.g:9393:1: ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) + // InternalRosParser.g:9394:2: ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) { - before(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); - // InternalRos.g:12247:2: ( rule__ParameterArrayType__TypeAssignment_3 ) - // InternalRos.g:12247:3: rule__ParameterArrayType__TypeAssignment_3 + before(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); + // InternalRosParser.g:9395:2: ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) + // InternalRosParser.g:9395:3: rule__ParameterDoubleType__DefaultAssignment_2_1 { pushFollow(FOLLOW_2); - rule__ParameterArrayType__TypeAssignment_3(); + rule__ParameterDoubleType__DefaultAssignment_2_1(); state._fsp--; } - after(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); + after(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); } @@ -37107,26 +28314,26 @@ public final void rule__ParameterArrayType__Group__3__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__3__Impl" + // $ANTLR end "rule__ParameterDoubleType__Group_2__1__Impl" - // $ANTLR start "rule__ParameterArrayType__Group__4" - // InternalRos.g:12255:1: rule__ParameterArrayType__Group__4 : rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 ; - public final void rule__ParameterArrayType__Group__4() throws RecognitionException { + // $ANTLR start "rule__ParameterBooleanType__Group__0" + // InternalRosParser.g:9404:1: rule__ParameterBooleanType__Group__0 : rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 ; + public final void rule__ParameterBooleanType__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12259:1: ( rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 ) - // InternalRos.g:12260:2: rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 + // InternalRosParser.g:9408:1: ( rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 ) + // InternalRosParser.g:9409:2: rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 { - pushFollow(FOLLOW_63); - rule__ParameterArrayType__Group__4__Impl(); + pushFollow(FOLLOW_51); + rule__ParameterBooleanType__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterArrayType__Group__5(); + rule__ParameterBooleanType__Group__1(); state._fsp--; @@ -37145,46 +28352,29 @@ public final void rule__ParameterArrayType__Group__4() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__4" + // $ANTLR end "rule__ParameterBooleanType__Group__0" - // $ANTLR start "rule__ParameterArrayType__Group__4__Impl" - // InternalRos.g:12267:1: rule__ParameterArrayType__Group__4__Impl : ( ( rule__ParameterArrayType__Group_4__0 )? ) ; - public final void rule__ParameterArrayType__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterBooleanType__Group__0__Impl" + // InternalRosParser.g:9416:1: rule__ParameterBooleanType__Group__0__Impl : ( () ) ; + public final void rule__ParameterBooleanType__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12271:1: ( ( ( rule__ParameterArrayType__Group_4__0 )? ) ) - // InternalRos.g:12272:1: ( ( rule__ParameterArrayType__Group_4__0 )? ) + // InternalRosParser.g:9420:1: ( ( () ) ) + // InternalRosParser.g:9421:1: ( () ) { - // InternalRos.g:12272:1: ( ( rule__ParameterArrayType__Group_4__0 )? ) - // InternalRos.g:12273:2: ( rule__ParameterArrayType__Group_4__0 )? + // InternalRosParser.g:9421:1: ( () ) + // InternalRosParser.g:9422:2: () + { + before(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); + // InternalRosParser.g:9423:2: () + // InternalRosParser.g:9423:3: { - before(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); - // InternalRos.g:12274:2: ( rule__ParameterArrayType__Group_4__0 )? - int alt77=2; - int LA77_0 = input.LA(1); - - if ( (LA77_0==80) ) { - alt77=1; - } - switch (alt77) { - case 1 : - // InternalRos.g:12274:3: rule__ParameterArrayType__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__ParameterArrayType__Group_4__0(); - - state._fsp--; - - - } - break; - } - after(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); + after(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); } @@ -37192,10 +28382,6 @@ public final void rule__ParameterArrayType__Group__4__Impl() throws RecognitionE } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -37203,21 +28389,26 @@ public final void rule__ParameterArrayType__Group__4__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__4__Impl" + // $ANTLR end "rule__ParameterBooleanType__Group__0__Impl" - // $ANTLR start "rule__ParameterArrayType__Group__5" - // InternalRos.g:12282:1: rule__ParameterArrayType__Group__5 : rule__ParameterArrayType__Group__5__Impl ; - public final void rule__ParameterArrayType__Group__5() throws RecognitionException { + // $ANTLR start "rule__ParameterBooleanType__Group__1" + // InternalRosParser.g:9431:1: rule__ParameterBooleanType__Group__1 : rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 ; + public final void rule__ParameterBooleanType__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12286:1: ( rule__ParameterArrayType__Group__5__Impl ) - // InternalRos.g:12287:2: rule__ParameterArrayType__Group__5__Impl + // InternalRosParser.g:9435:1: ( rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 ) + // InternalRosParser.g:9436:2: rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 { + pushFollow(FOLLOW_46); + rule__ParameterBooleanType__Group__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__ParameterArrayType__Group__5__Impl(); + rule__ParameterBooleanType__Group__2(); state._fsp--; @@ -37236,25 +28427,25 @@ public final void rule__ParameterArrayType__Group__5() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__5" + // $ANTLR end "rule__ParameterBooleanType__Group__1" - // $ANTLR start "rule__ParameterArrayType__Group__5__Impl" - // InternalRos.g:12293:1: rule__ParameterArrayType__Group__5__Impl : ( '}' ) ; - public final void rule__ParameterArrayType__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterBooleanType__Group__1__Impl" + // InternalRosParser.g:9443:1: rule__ParameterBooleanType__Group__1__Impl : ( Boolean ) ; + public final void rule__ParameterBooleanType__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12297:1: ( ( '}' ) ) - // InternalRos.g:12298:1: ( '}' ) + // InternalRosParser.g:9447:1: ( ( Boolean ) ) + // InternalRosParser.g:9448:1: ( Boolean ) { - // InternalRos.g:12298:1: ( '}' ) - // InternalRos.g:12299:2: '}' + // InternalRosParser.g:9448:1: ( Boolean ) + // InternalRosParser.g:9449:2: Boolean { - before(grammarAccess.getParameterArrayTypeAccess().getRightCurlyBracketKeyword_5()); - match(input,42,FOLLOW_2); - after(grammarAccess.getParameterArrayTypeAccess().getRightCurlyBracketKeyword_5()); + before(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); + match(input,Boolean,FOLLOW_2); + after(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); } @@ -37273,26 +28464,21 @@ public final void rule__ParameterArrayType__Group__5__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__ParameterArrayType__Group__5__Impl" + // $ANTLR end "rule__ParameterBooleanType__Group__1__Impl" - // $ANTLR start "rule__ParameterArrayType__Group_4__0" - // InternalRos.g:12309:1: rule__ParameterArrayType__Group_4__0 : rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 ; - public final void rule__ParameterArrayType__Group_4__0() throws RecognitionException { + // $ANTLR start "rule__ParameterBooleanType__Group__2" + // InternalRosParser.g:9458:1: rule__ParameterBooleanType__Group__2 : rule__ParameterBooleanType__Group__2__Impl ; + public final void rule__ParameterBooleanType__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12313:1: ( rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 ) - // InternalRos.g:12314:2: rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 + // InternalRosParser.g:9462:1: ( rule__ParameterBooleanType__Group__2__Impl ) + // InternalRosParser.g:9463:2: rule__ParameterBooleanType__Group__2__Impl { - pushFollow(FOLLOW_4); - rule__ParameterArrayType__Group_4__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ParameterArrayType__Group_4__1(); + rule__ParameterBooleanType__Group__2__Impl(); state._fsp--; @@ -37311,25 +28497,50 @@ public final void rule__ParameterArrayType__Group_4__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ParameterArrayType__Group_4__0" + // $ANTLR end "rule__ParameterBooleanType__Group__2" - // $ANTLR start "rule__ParameterArrayType__Group_4__0__Impl" - // InternalRos.g:12321:1: rule__ParameterArrayType__Group_4__0__Impl : ( 'default' ) ; - public final void rule__ParameterArrayType__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterBooleanType__Group__2__Impl" + // InternalRosParser.g:9469:1: rule__ParameterBooleanType__Group__2__Impl : ( ( rule__ParameterBooleanType__Group_2__0 )? ) ; + public final void rule__ParameterBooleanType__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12325:1: ( ( 'default' ) ) - // InternalRos.g:12326:1: ( 'default' ) + // InternalRosParser.g:9473:1: ( ( ( rule__ParameterBooleanType__Group_2__0 )? ) ) + // InternalRosParser.g:9474:1: ( ( rule__ParameterBooleanType__Group_2__0 )? ) { - // InternalRos.g:12326:1: ( 'default' ) - // InternalRos.g:12327:2: 'default' + // InternalRosParser.g:9474:1: ( ( rule__ParameterBooleanType__Group_2__0 )? ) + // InternalRosParser.g:9475:2: ( rule__ParameterBooleanType__Group_2__0 )? { - before(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); - match(input,80,FOLLOW_2); - after(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); + before(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); + // InternalRosParser.g:9476:2: ( rule__ParameterBooleanType__Group_2__0 )? + int alt53=2; + int LA53_0 = input.LA(1); + + if ( (LA53_0==Default) ) { + int LA53_1 = input.LA(2); + + if ( (LA53_1==RULE_BOOLEAN) ) { + alt53=1; + } + } + switch (alt53) { + case 1 : + // InternalRosParser.g:9476:3: rule__ParameterBooleanType__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); } @@ -37348,21 +28559,26 @@ public final void rule__ParameterArrayType__Group_4__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__ParameterArrayType__Group_4__0__Impl" + // $ANTLR end "rule__ParameterBooleanType__Group__2__Impl" - // $ANTLR start "rule__ParameterArrayType__Group_4__1" - // InternalRos.g:12336:1: rule__ParameterArrayType__Group_4__1 : rule__ParameterArrayType__Group_4__1__Impl ; - public final void rule__ParameterArrayType__Group_4__1() throws RecognitionException { + // $ANTLR start "rule__ParameterBooleanType__Group_2__0" + // InternalRosParser.g:9485:1: rule__ParameterBooleanType__Group_2__0 : rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 ; + public final void rule__ParameterBooleanType__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12340:1: ( rule__ParameterArrayType__Group_4__1__Impl ) - // InternalRos.g:12341:2: rule__ParameterArrayType__Group_4__1__Impl + // InternalRosParser.g:9489:1: ( rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 ) + // InternalRosParser.g:9490:2: rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 { + pushFollow(FOLLOW_52); + rule__ParameterBooleanType__Group_2__0__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__ParameterArrayType__Group_4__1__Impl(); + rule__ParameterBooleanType__Group_2__1(); state._fsp--; @@ -37381,35 +28597,25 @@ public final void rule__ParameterArrayType__Group_4__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ParameterArrayType__Group_4__1" + // $ANTLR end "rule__ParameterBooleanType__Group_2__0" - // $ANTLR start "rule__ParameterArrayType__Group_4__1__Impl" - // InternalRos.g:12347:1: rule__ParameterArrayType__Group_4__1__Impl : ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) ; - public final void rule__ParameterArrayType__Group_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterBooleanType__Group_2__0__Impl" + // InternalRosParser.g:9497:1: rule__ParameterBooleanType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterBooleanType__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12351:1: ( ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) ) - // InternalRos.g:12352:1: ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) - { - // InternalRos.g:12352:1: ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) - // InternalRos.g:12353:2: ( rule__ParameterArrayType__DefaultAssignment_4_1 ) + // InternalRosParser.g:9501:1: ( ( Default ) ) + // InternalRosParser.g:9502:1: ( Default ) { - before(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); - // InternalRos.g:12354:2: ( rule__ParameterArrayType__DefaultAssignment_4_1 ) - // InternalRos.g:12354:3: rule__ParameterArrayType__DefaultAssignment_4_1 + // InternalRosParser.g:9502:1: ( Default ) + // InternalRosParser.g:9503:2: Default { - pushFollow(FOLLOW_2); - rule__ParameterArrayType__DefaultAssignment_4_1(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); + before(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); } @@ -37428,26 +28634,21 @@ public final void rule__ParameterArrayType__Group_4__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__ParameterArrayType__Group_4__1__Impl" + // $ANTLR end "rule__ParameterBooleanType__Group_2__0__Impl" - // $ANTLR start "rule__ParameterList__Group__0" - // InternalRos.g:12363:1: rule__ParameterList__Group__0 : rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 ; - public final void rule__ParameterList__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterBooleanType__Group_2__1" + // InternalRosParser.g:9512:1: rule__ParameterBooleanType__Group_2__1 : rule__ParameterBooleanType__Group_2__1__Impl ; + public final void rule__ParameterBooleanType__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12367:1: ( rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 ) - // InternalRos.g:12368:2: rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 + // InternalRosParser.g:9516:1: ( rule__ParameterBooleanType__Group_2__1__Impl ) + // InternalRosParser.g:9517:2: rule__ParameterBooleanType__Group_2__1__Impl { - pushFollow(FOLLOW_4); - rule__ParameterList__Group__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ParameterList__Group__1(); + rule__ParameterBooleanType__Group_2__1__Impl(); state._fsp--; @@ -37466,29 +28667,35 @@ public final void rule__ParameterList__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterList__Group__0" + // $ANTLR end "rule__ParameterBooleanType__Group_2__1" - // $ANTLR start "rule__ParameterList__Group__0__Impl" - // InternalRos.g:12375:1: rule__ParameterList__Group__0__Impl : ( () ) ; - public final void rule__ParameterList__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterBooleanType__Group_2__1__Impl" + // InternalRosParser.g:9523:1: rule__ParameterBooleanType__Group_2__1__Impl : ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterBooleanType__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12379:1: ( ( () ) ) - // InternalRos.g:12380:1: ( () ) + // InternalRosParser.g:9527:1: ( ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) ) + // InternalRosParser.g:9528:1: ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) { - // InternalRos.g:12380:1: ( () ) - // InternalRos.g:12381:2: () + // InternalRosParser.g:9528:1: ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) + // InternalRosParser.g:9529:2: ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) { - before(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); - // InternalRos.g:12382:2: () - // InternalRos.g:12382:3: + before(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); + // InternalRosParser.g:9530:2: ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) + // InternalRosParser.g:9530:3: rule__ParameterBooleanType__DefaultAssignment_2_1 { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__DefaultAssignment_2_1(); + + state._fsp--; + + } - after(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); + after(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); } @@ -37496,6 +28703,10 @@ public final void rule__ParameterList__Group__0__Impl() throws RecognitionExcept } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -37503,26 +28714,26 @@ public final void rule__ParameterList__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterList__Group__0__Impl" + // $ANTLR end "rule__ParameterBooleanType__Group_2__1__Impl" - // $ANTLR start "rule__ParameterList__Group__1" - // InternalRos.g:12390:1: rule__ParameterList__Group__1 : rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 ; - public final void rule__ParameterList__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterBase64Type__Group__0" + // InternalRosParser.g:9539:1: rule__ParameterBase64Type__Group__0 : rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 ; + public final void rule__ParameterBase64Type__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12394:1: ( rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 ) - // InternalRos.g:12395:2: rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 + // InternalRosParser.g:9543:1: ( rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 ) + // InternalRosParser.g:9544:2: rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 { - pushFollow(FOLLOW_64); - rule__ParameterList__Group__1__Impl(); + pushFollow(FOLLOW_53); + rule__ParameterBase64Type__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterList__Group__2(); + rule__ParameterBase64Type__Group__1(); state._fsp--; @@ -37541,25 +28752,29 @@ public final void rule__ParameterList__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterList__Group__1" + // $ANTLR end "rule__ParameterBase64Type__Group__0" - // $ANTLR start "rule__ParameterList__Group__1__Impl" - // InternalRos.g:12402:1: rule__ParameterList__Group__1__Impl : ( '{' ) ; - public final void rule__ParameterList__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterBase64Type__Group__0__Impl" + // InternalRosParser.g:9551:1: rule__ParameterBase64Type__Group__0__Impl : ( () ) ; + public final void rule__ParameterBase64Type__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12406:1: ( ( '{' ) ) - // InternalRos.g:12407:1: ( '{' ) + // InternalRosParser.g:9555:1: ( ( () ) ) + // InternalRosParser.g:9556:1: ( () ) { - // InternalRos.g:12407:1: ( '{' ) - // InternalRos.g:12408:2: '{' + // InternalRosParser.g:9556:1: ( () ) + // InternalRosParser.g:9557:2: () { - before(grammarAccess.getParameterListAccess().getLeftCurlyBracketKeyword_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getParameterListAccess().getLeftCurlyBracketKeyword_1()); + before(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); + // InternalRosParser.g:9558:2: () + // InternalRosParser.g:9558:3: + { + } + + after(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); } @@ -37567,10 +28782,6 @@ public final void rule__ParameterList__Group__1__Impl() throws RecognitionExcept } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -37578,26 +28789,26 @@ public final void rule__ParameterList__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterList__Group__1__Impl" + // $ANTLR end "rule__ParameterBase64Type__Group__0__Impl" - // $ANTLR start "rule__ParameterList__Group__2" - // InternalRos.g:12417:1: rule__ParameterList__Group__2 : rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 ; - public final void rule__ParameterList__Group__2() throws RecognitionException { + // $ANTLR start "rule__ParameterBase64Type__Group__1" + // InternalRosParser.g:9566:1: rule__ParameterBase64Type__Group__1 : rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 ; + public final void rule__ParameterBase64Type__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12421:1: ( rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 ) - // InternalRos.g:12422:2: rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 + // InternalRosParser.g:9570:1: ( rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 ) + // InternalRosParser.g:9571:2: rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 { - pushFollow(FOLLOW_13); - rule__ParameterList__Group__2__Impl(); + pushFollow(FOLLOW_46); + rule__ParameterBase64Type__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterList__Group__3(); + rule__ParameterBase64Type__Group__2(); state._fsp--; @@ -37616,35 +28827,25 @@ public final void rule__ParameterList__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterList__Group__2" + // $ANTLR end "rule__ParameterBase64Type__Group__1" - // $ANTLR start "rule__ParameterList__Group__2__Impl" - // InternalRos.g:12429:1: rule__ParameterList__Group__2__Impl : ( ( rule__ParameterList__ValueAssignment_2 ) ) ; - public final void rule__ParameterList__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterBase64Type__Group__1__Impl" + // InternalRosParser.g:9578:1: rule__ParameterBase64Type__Group__1__Impl : ( Base64 ) ; + public final void rule__ParameterBase64Type__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12433:1: ( ( ( rule__ParameterList__ValueAssignment_2 ) ) ) - // InternalRos.g:12434:1: ( ( rule__ParameterList__ValueAssignment_2 ) ) - { - // InternalRos.g:12434:1: ( ( rule__ParameterList__ValueAssignment_2 ) ) - // InternalRos.g:12435:2: ( rule__ParameterList__ValueAssignment_2 ) + // InternalRosParser.g:9582:1: ( ( Base64 ) ) + // InternalRosParser.g:9583:1: ( Base64 ) { - before(grammarAccess.getParameterListAccess().getValueAssignment_2()); - // InternalRos.g:12436:2: ( rule__ParameterList__ValueAssignment_2 ) - // InternalRos.g:12436:3: rule__ParameterList__ValueAssignment_2 + // InternalRosParser.g:9583:1: ( Base64 ) + // InternalRosParser.g:9584:2: Base64 { - pushFollow(FOLLOW_2); - rule__ParameterList__ValueAssignment_2(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterListAccess().getValueAssignment_2()); + before(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); + match(input,Base64,FOLLOW_2); + after(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); } @@ -37663,26 +28864,21 @@ public final void rule__ParameterList__Group__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterList__Group__2__Impl" + // $ANTLR end "rule__ParameterBase64Type__Group__1__Impl" - // $ANTLR start "rule__ParameterList__Group__3" - // InternalRos.g:12444:1: rule__ParameterList__Group__3 : rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 ; - public final void rule__ParameterList__Group__3() throws RecognitionException { + // $ANTLR start "rule__ParameterBase64Type__Group__2" + // InternalRosParser.g:9593:1: rule__ParameterBase64Type__Group__2 : rule__ParameterBase64Type__Group__2__Impl ; + public final void rule__ParameterBase64Type__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12448:1: ( rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 ) - // InternalRos.g:12449:2: rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 + // InternalRosParser.g:9597:1: ( rule__ParameterBase64Type__Group__2__Impl ) + // InternalRosParser.g:9598:2: rule__ParameterBase64Type__Group__2__Impl { - pushFollow(FOLLOW_13); - rule__ParameterList__Group__3__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ParameterList__Group__4(); + rule__ParameterBase64Type__Group__2__Impl(); state._fsp--; @@ -37701,53 +28897,50 @@ public final void rule__ParameterList__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterList__Group__3" + // $ANTLR end "rule__ParameterBase64Type__Group__2" - // $ANTLR start "rule__ParameterList__Group__3__Impl" - // InternalRos.g:12456:1: rule__ParameterList__Group__3__Impl : ( ( rule__ParameterList__Group_3__0 )* ) ; - public final void rule__ParameterList__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterBase64Type__Group__2__Impl" + // InternalRosParser.g:9604:1: rule__ParameterBase64Type__Group__2__Impl : ( ( rule__ParameterBase64Type__Group_2__0 )? ) ; + public final void rule__ParameterBase64Type__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12460:1: ( ( ( rule__ParameterList__Group_3__0 )* ) ) - // InternalRos.g:12461:1: ( ( rule__ParameterList__Group_3__0 )* ) + // InternalRosParser.g:9608:1: ( ( ( rule__ParameterBase64Type__Group_2__0 )? ) ) + // InternalRosParser.g:9609:1: ( ( rule__ParameterBase64Type__Group_2__0 )? ) { - // InternalRos.g:12461:1: ( ( rule__ParameterList__Group_3__0 )* ) - // InternalRos.g:12462:2: ( rule__ParameterList__Group_3__0 )* + // InternalRosParser.g:9609:1: ( ( rule__ParameterBase64Type__Group_2__0 )? ) + // InternalRosParser.g:9610:2: ( rule__ParameterBase64Type__Group_2__0 )? { - before(grammarAccess.getParameterListAccess().getGroup_3()); - // InternalRos.g:12463:2: ( rule__ParameterList__Group_3__0 )* - loop78: - do { - int alt78=2; - int LA78_0 = input.LA(1); - - if ( (LA78_0==43) ) { - alt78=1; - } + before(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); + // InternalRosParser.g:9611:2: ( rule__ParameterBase64Type__Group_2__0 )? + int alt54=2; + int LA54_0 = input.LA(1); + if ( (LA54_0==Default) ) { + int LA54_1 = input.LA(2); - switch (alt78) { - case 1 : - // InternalRos.g:12463:3: rule__ParameterList__Group_3__0 - { - pushFollow(FOLLOW_7); - rule__ParameterList__Group_3__0(); + if ( (LA54_1==RULE_BINARY) ) { + alt54=1; + } + } + switch (alt54) { + case 1 : + // InternalRosParser.g:9611:3: rule__ParameterBase64Type__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group_2__0(); - state._fsp--; + state._fsp--; - } - break; + } + break; - default : - break loop78; - } - } while (true); + } - after(grammarAccess.getParameterListAccess().getGroup_3()); + after(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); } @@ -37766,21 +28959,26 @@ public final void rule__ParameterList__Group__3__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterList__Group__3__Impl" + // $ANTLR end "rule__ParameterBase64Type__Group__2__Impl" - // $ANTLR start "rule__ParameterList__Group__4" - // InternalRos.g:12471:1: rule__ParameterList__Group__4 : rule__ParameterList__Group__4__Impl ; - public final void rule__ParameterList__Group__4() throws RecognitionException { + // $ANTLR start "rule__ParameterBase64Type__Group_2__0" + // InternalRosParser.g:9620:1: rule__ParameterBase64Type__Group_2__0 : rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 ; + public final void rule__ParameterBase64Type__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12475:1: ( rule__ParameterList__Group__4__Impl ) - // InternalRos.g:12476:2: rule__ParameterList__Group__4__Impl + // InternalRosParser.g:9624:1: ( rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 ) + // InternalRosParser.g:9625:2: rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 { + pushFollow(FOLLOW_54); + rule__ParameterBase64Type__Group_2__0__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__ParameterList__Group__4__Impl(); + rule__ParameterBase64Type__Group_2__1(); state._fsp--; @@ -37799,25 +28997,25 @@ public final void rule__ParameterList__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterList__Group__4" + // $ANTLR end "rule__ParameterBase64Type__Group_2__0" - // $ANTLR start "rule__ParameterList__Group__4__Impl" - // InternalRos.g:12482:1: rule__ParameterList__Group__4__Impl : ( '}' ) ; - public final void rule__ParameterList__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterBase64Type__Group_2__0__Impl" + // InternalRosParser.g:9632:1: rule__ParameterBase64Type__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterBase64Type__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12486:1: ( ( '}' ) ) - // InternalRos.g:12487:1: ( '}' ) + // InternalRosParser.g:9636:1: ( ( Default ) ) + // InternalRosParser.g:9637:1: ( Default ) { - // InternalRos.g:12487:1: ( '}' ) - // InternalRos.g:12488:2: '}' + // InternalRosParser.g:9637:1: ( Default ) + // InternalRosParser.g:9638:2: Default { - before(grammarAccess.getParameterListAccess().getRightCurlyBracketKeyword_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getParameterListAccess().getRightCurlyBracketKeyword_4()); + before(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); } @@ -37836,26 +29034,21 @@ public final void rule__ParameterList__Group__4__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterList__Group__4__Impl" + // $ANTLR end "rule__ParameterBase64Type__Group_2__0__Impl" - // $ANTLR start "rule__ParameterList__Group_3__0" - // InternalRos.g:12498:1: rule__ParameterList__Group_3__0 : rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 ; - public final void rule__ParameterList__Group_3__0() throws RecognitionException { + // $ANTLR start "rule__ParameterBase64Type__Group_2__1" + // InternalRosParser.g:9647:1: rule__ParameterBase64Type__Group_2__1 : rule__ParameterBase64Type__Group_2__1__Impl ; + public final void rule__ParameterBase64Type__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12502:1: ( rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 ) - // InternalRos.g:12503:2: rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 + // InternalRosParser.g:9651:1: ( rule__ParameterBase64Type__Group_2__1__Impl ) + // InternalRosParser.g:9652:2: rule__ParameterBase64Type__Group_2__1__Impl { - pushFollow(FOLLOW_64); - rule__ParameterList__Group_3__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ParameterList__Group_3__1(); + rule__ParameterBase64Type__Group_2__1__Impl(); state._fsp--; @@ -37874,25 +29067,35 @@ public final void rule__ParameterList__Group_3__0() throws RecognitionException } return ; } - // $ANTLR end "rule__ParameterList__Group_3__0" + // $ANTLR end "rule__ParameterBase64Type__Group_2__1" - // $ANTLR start "rule__ParameterList__Group_3__0__Impl" - // InternalRos.g:12510:1: rule__ParameterList__Group_3__0__Impl : ( ',' ) ; - public final void rule__ParameterList__Group_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterBase64Type__Group_2__1__Impl" + // InternalRosParser.g:9658:1: rule__ParameterBase64Type__Group_2__1__Impl : ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterBase64Type__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12514:1: ( ( ',' ) ) - // InternalRos.g:12515:1: ( ',' ) + // InternalRosParser.g:9662:1: ( ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) ) + // InternalRosParser.g:9663:1: ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) { - // InternalRos.g:12515:1: ( ',' ) - // InternalRos.g:12516:2: ',' + // InternalRosParser.g:9663:1: ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) + // InternalRosParser.g:9664:2: ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) { - before(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); + before(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); + // InternalRosParser.g:9665:2: ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) + // InternalRosParser.g:9665:3: rule__ParameterBase64Type__DefaultAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__DefaultAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); } @@ -37911,21 +29114,26 @@ public final void rule__ParameterList__Group_3__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterList__Group_3__0__Impl" + // $ANTLR end "rule__ParameterBase64Type__Group_2__1__Impl" - // $ANTLR start "rule__ParameterList__Group_3__1" - // InternalRos.g:12525:1: rule__ParameterList__Group_3__1 : rule__ParameterList__Group_3__1__Impl ; - public final void rule__ParameterList__Group_3__1() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__0" + // InternalRosParser.g:9674:1: rule__ParameterArrayType__Group__0 : rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 ; + public final void rule__ParameterArrayType__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12529:1: ( rule__ParameterList__Group_3__1__Impl ) - // InternalRos.g:12530:2: rule__ParameterList__Group_3__1__Impl + // InternalRosParser.g:9678:1: ( rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 ) + // InternalRosParser.g:9679:2: rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 { + pushFollow(FOLLOW_6); + rule__ParameterArrayType__Group__0__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__ParameterList__Group_3__1__Impl(); + rule__ParameterArrayType__Group__1(); state._fsp--; @@ -37944,35 +29152,25 @@ public final void rule__ParameterList__Group_3__1() throws RecognitionException } return ; } - // $ANTLR end "rule__ParameterList__Group_3__1" + // $ANTLR end "rule__ParameterArrayType__Group__0" - // $ANTLR start "rule__ParameterList__Group_3__1__Impl" - // InternalRos.g:12536:1: rule__ParameterList__Group_3__1__Impl : ( ( rule__ParameterList__ValueAssignment_3_1 ) ) ; - public final void rule__ParameterList__Group_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__0__Impl" + // InternalRosParser.g:9686:1: rule__ParameterArrayType__Group__0__Impl : ( Array ) ; + public final void rule__ParameterArrayType__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12540:1: ( ( ( rule__ParameterList__ValueAssignment_3_1 ) ) ) - // InternalRos.g:12541:1: ( ( rule__ParameterList__ValueAssignment_3_1 ) ) + // InternalRosParser.g:9690:1: ( ( Array ) ) + // InternalRosParser.g:9691:1: ( Array ) { - // InternalRos.g:12541:1: ( ( rule__ParameterList__ValueAssignment_3_1 ) ) - // InternalRos.g:12542:2: ( rule__ParameterList__ValueAssignment_3_1 ) - { - before(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); - // InternalRos.g:12543:2: ( rule__ParameterList__ValueAssignment_3_1 ) - // InternalRos.g:12543:3: rule__ParameterList__ValueAssignment_3_1 + // InternalRosParser.g:9691:1: ( Array ) + // InternalRosParser.g:9692:2: Array { - pushFollow(FOLLOW_2); - rule__ParameterList__ValueAssignment_3_1(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); + before(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); + match(input,Array,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); } @@ -37991,26 +29189,26 @@ public final void rule__ParameterList__Group_3__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterList__Group_3__1__Impl" + // $ANTLR end "rule__ParameterArrayType__Group__0__Impl" - // $ANTLR start "rule__ParameterAny__Group__0" - // InternalRos.g:12552:1: rule__ParameterAny__Group__0 : rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 ; - public final void rule__ParameterAny__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__1" + // InternalRosParser.g:9701:1: rule__ParameterArrayType__Group__1 : rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 ; + public final void rule__ParameterArrayType__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12556:1: ( rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 ) - // InternalRos.g:12557:2: rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 + // InternalRosParser.g:9705:1: ( rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 ) + // InternalRosParser.g:9706:2: rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 { - pushFollow(FOLLOW_65); - rule__ParameterAny__Group__0__Impl(); + pushFollow(FOLLOW_40); + rule__ParameterArrayType__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterAny__Group__1(); + rule__ParameterArrayType__Group__2(); state._fsp--; @@ -38029,29 +29227,25 @@ public final void rule__ParameterAny__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterAny__Group__0" + // $ANTLR end "rule__ParameterArrayType__Group__1" - // $ANTLR start "rule__ParameterAny__Group__0__Impl" - // InternalRos.g:12564:1: rule__ParameterAny__Group__0__Impl : ( () ) ; - public final void rule__ParameterAny__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__1__Impl" + // InternalRosParser.g:9713:1: rule__ParameterArrayType__Group__1__Impl : ( RULE_BEGIN ) ; + public final void rule__ParameterArrayType__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12568:1: ( ( () ) ) - // InternalRos.g:12569:1: ( () ) - { - // InternalRos.g:12569:1: ( () ) - // InternalRos.g:12570:2: () + // InternalRosParser.g:9717:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:9718:1: ( RULE_BEGIN ) { - before(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); - // InternalRos.g:12571:2: () - // InternalRos.g:12571:3: + // InternalRosParser.g:9718:1: ( RULE_BEGIN ) + // InternalRosParser.g:9719:2: RULE_BEGIN { - } - - after(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); + before(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); } @@ -38059,6 +29253,10 @@ public final void rule__ParameterAny__Group__0__Impl() throws RecognitionExcepti } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -38066,26 +29264,26 @@ public final void rule__ParameterAny__Group__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ParameterAny__Group__0__Impl" + // $ANTLR end "rule__ParameterArrayType__Group__1__Impl" - // $ANTLR start "rule__ParameterAny__Group__1" - // InternalRos.g:12579:1: rule__ParameterAny__Group__1 : rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 ; - public final void rule__ParameterAny__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__2" + // InternalRosParser.g:9728:1: rule__ParameterArrayType__Group__2 : rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 ; + public final void rule__ParameterArrayType__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12583:1: ( rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 ) - // InternalRos.g:12584:2: rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 + // InternalRosParser.g:9732:1: ( rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 ) + // InternalRosParser.g:9733:2: rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 { - pushFollow(FOLLOW_4); - rule__ParameterAny__Group__1__Impl(); + pushFollow(FOLLOW_41); + rule__ParameterArrayType__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterAny__Group__2(); + rule__ParameterArrayType__Group__3(); state._fsp--; @@ -38104,25 +29302,25 @@ public final void rule__ParameterAny__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterAny__Group__1" + // $ANTLR end "rule__ParameterArrayType__Group__2" - // $ANTLR start "rule__ParameterAny__Group__1__Impl" - // InternalRos.g:12591:1: rule__ParameterAny__Group__1__Impl : ( 'ParameterAny' ) ; - public final void rule__ParameterAny__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__2__Impl" + // InternalRosParser.g:9740:1: rule__ParameterArrayType__Group__2__Impl : ( Type ) ; + public final void rule__ParameterArrayType__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12595:1: ( ( 'ParameterAny' ) ) - // InternalRos.g:12596:1: ( 'ParameterAny' ) + // InternalRosParser.g:9744:1: ( ( Type ) ) + // InternalRosParser.g:9745:1: ( Type ) { - // InternalRos.g:12596:1: ( 'ParameterAny' ) - // InternalRos.g:12597:2: 'ParameterAny' + // InternalRosParser.g:9745:1: ( Type ) + // InternalRosParser.g:9746:2: Type { - before(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); - match(input,85,FOLLOW_2); - after(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); + before(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); + match(input,Type,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); } @@ -38141,26 +29339,26 @@ public final void rule__ParameterAny__Group__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ParameterAny__Group__1__Impl" + // $ANTLR end "rule__ParameterArrayType__Group__2__Impl" - // $ANTLR start "rule__ParameterAny__Group__2" - // InternalRos.g:12606:1: rule__ParameterAny__Group__2 : rule__ParameterAny__Group__2__Impl rule__ParameterAny__Group__3 ; - public final void rule__ParameterAny__Group__2() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__3" + // InternalRosParser.g:9755:1: rule__ParameterArrayType__Group__3 : rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 ; + public final void rule__ParameterArrayType__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12610:1: ( rule__ParameterAny__Group__2__Impl rule__ParameterAny__Group__3 ) - // InternalRos.g:12611:2: rule__ParameterAny__Group__2__Impl rule__ParameterAny__Group__3 + // InternalRosParser.g:9759:1: ( rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 ) + // InternalRosParser.g:9760:2: rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 { - pushFollow(FOLLOW_66); - rule__ParameterAny__Group__2__Impl(); + pushFollow(FOLLOW_55); + rule__ParameterArrayType__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterAny__Group__3(); + rule__ParameterArrayType__Group__4(); state._fsp--; @@ -38179,25 +29377,35 @@ public final void rule__ParameterAny__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterAny__Group__2" + // $ANTLR end "rule__ParameterArrayType__Group__3" - // $ANTLR start "rule__ParameterAny__Group__2__Impl" - // InternalRos.g:12618:1: rule__ParameterAny__Group__2__Impl : ( '{' ) ; - public final void rule__ParameterAny__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__3__Impl" + // InternalRosParser.g:9767:1: rule__ParameterArrayType__Group__3__Impl : ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) ; + public final void rule__ParameterArrayType__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12622:1: ( ( '{' ) ) - // InternalRos.g:12623:1: ( '{' ) + // InternalRosParser.g:9771:1: ( ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) ) + // InternalRosParser.g:9772:1: ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) { - // InternalRos.g:12623:1: ( '{' ) - // InternalRos.g:12624:2: '{' + // InternalRosParser.g:9772:1: ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) + // InternalRosParser.g:9773:2: ( rule__ParameterArrayType__TypeAssignment_3 ) { - before(grammarAccess.getParameterAnyAccess().getLeftCurlyBracketKeyword_2()); - match(input,41,FOLLOW_2); - after(grammarAccess.getParameterAnyAccess().getLeftCurlyBracketKeyword_2()); + before(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); + // InternalRosParser.g:9774:2: ( rule__ParameterArrayType__TypeAssignment_3 ) + // InternalRosParser.g:9774:3: rule__ParameterArrayType__TypeAssignment_3 + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__TypeAssignment_3(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); } @@ -38216,26 +29424,26 @@ public final void rule__ParameterAny__Group__2__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ParameterAny__Group__2__Impl" + // $ANTLR end "rule__ParameterArrayType__Group__3__Impl" - // $ANTLR start "rule__ParameterAny__Group__3" - // InternalRos.g:12633:1: rule__ParameterAny__Group__3 : rule__ParameterAny__Group__3__Impl rule__ParameterAny__Group__4 ; - public final void rule__ParameterAny__Group__3() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__4" + // InternalRosParser.g:9782:1: rule__ParameterArrayType__Group__4 : rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 ; + public final void rule__ParameterArrayType__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12637:1: ( rule__ParameterAny__Group__3__Impl rule__ParameterAny__Group__4 ) - // InternalRos.g:12638:2: rule__ParameterAny__Group__3__Impl rule__ParameterAny__Group__4 + // InternalRosParser.g:9786:1: ( rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 ) + // InternalRosParser.g:9787:2: rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 { - pushFollow(FOLLOW_66); - rule__ParameterAny__Group__3__Impl(); + pushFollow(FOLLOW_55); + rule__ParameterArrayType__Group__4__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterAny__Group__4(); + rule__ParameterArrayType__Group__5(); state._fsp--; @@ -38254,36 +29462,36 @@ public final void rule__ParameterAny__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterAny__Group__3" + // $ANTLR end "rule__ParameterArrayType__Group__4" - // $ANTLR start "rule__ParameterAny__Group__3__Impl" - // InternalRos.g:12645:1: rule__ParameterAny__Group__3__Impl : ( ( rule__ParameterAny__Group_3__0 )? ) ; - public final void rule__ParameterAny__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__4__Impl" + // InternalRosParser.g:9794:1: rule__ParameterArrayType__Group__4__Impl : ( ( rule__ParameterArrayType__Group_4__0 )? ) ; + public final void rule__ParameterArrayType__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12649:1: ( ( ( rule__ParameterAny__Group_3__0 )? ) ) - // InternalRos.g:12650:1: ( ( rule__ParameterAny__Group_3__0 )? ) + // InternalRosParser.g:9798:1: ( ( ( rule__ParameterArrayType__Group_4__0 )? ) ) + // InternalRosParser.g:9799:1: ( ( rule__ParameterArrayType__Group_4__0 )? ) { - // InternalRos.g:12650:1: ( ( rule__ParameterAny__Group_3__0 )? ) - // InternalRos.g:12651:2: ( rule__ParameterAny__Group_3__0 )? + // InternalRosParser.g:9799:1: ( ( rule__ParameterArrayType__Group_4__0 )? ) + // InternalRosParser.g:9800:2: ( rule__ParameterArrayType__Group_4__0 )? { - before(grammarAccess.getParameterAnyAccess().getGroup_3()); - // InternalRos.g:12652:2: ( rule__ParameterAny__Group_3__0 )? - int alt79=2; - int LA79_0 = input.LA(1); + before(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); + // InternalRosParser.g:9801:2: ( rule__ParameterArrayType__Group_4__0 )? + int alt55=2; + int LA55_0 = input.LA(1); - if ( (LA79_0==34) ) { - alt79=1; + if ( (LA55_0==Default) ) { + alt55=1; } - switch (alt79) { + switch (alt55) { case 1 : - // InternalRos.g:12652:3: rule__ParameterAny__Group_3__0 + // InternalRosParser.g:9801:3: rule__ParameterArrayType__Group_4__0 { pushFollow(FOLLOW_2); - rule__ParameterAny__Group_3__0(); + rule__ParameterArrayType__Group_4__0(); state._fsp--; @@ -38293,7 +29501,7 @@ public final void rule__ParameterAny__Group__3__Impl() throws RecognitionExcepti } - after(grammarAccess.getParameterAnyAccess().getGroup_3()); + after(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); } @@ -38312,21 +29520,21 @@ public final void rule__ParameterAny__Group__3__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ParameterAny__Group__3__Impl" + // $ANTLR end "rule__ParameterArrayType__Group__4__Impl" - // $ANTLR start "rule__ParameterAny__Group__4" - // InternalRos.g:12660:1: rule__ParameterAny__Group__4 : rule__ParameterAny__Group__4__Impl ; - public final void rule__ParameterAny__Group__4() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__5" + // InternalRosParser.g:9809:1: rule__ParameterArrayType__Group__5 : rule__ParameterArrayType__Group__5__Impl ; + public final void rule__ParameterArrayType__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12664:1: ( rule__ParameterAny__Group__4__Impl ) - // InternalRos.g:12665:2: rule__ParameterAny__Group__4__Impl + // InternalRosParser.g:9813:1: ( rule__ParameterArrayType__Group__5__Impl ) + // InternalRosParser.g:9814:2: rule__ParameterArrayType__Group__5__Impl { pushFollow(FOLLOW_2); - rule__ParameterAny__Group__4__Impl(); + rule__ParameterArrayType__Group__5__Impl(); state._fsp--; @@ -38345,25 +29553,25 @@ public final void rule__ParameterAny__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterAny__Group__4" + // $ANTLR end "rule__ParameterArrayType__Group__5" - // $ANTLR start "rule__ParameterAny__Group__4__Impl" - // InternalRos.g:12671:1: rule__ParameterAny__Group__4__Impl : ( '}' ) ; - public final void rule__ParameterAny__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group__5__Impl" + // InternalRosParser.g:9820:1: rule__ParameterArrayType__Group__5__Impl : ( RULE_END ) ; + public final void rule__ParameterArrayType__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12675:1: ( ( '}' ) ) - // InternalRos.g:12676:1: ( '}' ) + // InternalRosParser.g:9824:1: ( ( RULE_END ) ) + // InternalRosParser.g:9825:1: ( RULE_END ) { - // InternalRos.g:12676:1: ( '}' ) - // InternalRos.g:12677:2: '}' + // InternalRosParser.g:9825:1: ( RULE_END ) + // InternalRosParser.g:9826:2: RULE_END { - before(grammarAccess.getParameterAnyAccess().getRightCurlyBracketKeyword_4()); - match(input,42,FOLLOW_2); - after(grammarAccess.getParameterAnyAccess().getRightCurlyBracketKeyword_4()); + before(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); } @@ -38382,26 +29590,26 @@ public final void rule__ParameterAny__Group__4__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ParameterAny__Group__4__Impl" + // $ANTLR end "rule__ParameterArrayType__Group__5__Impl" - // $ANTLR start "rule__ParameterAny__Group_3__0" - // InternalRos.g:12687:1: rule__ParameterAny__Group_3__0 : rule__ParameterAny__Group_3__0__Impl rule__ParameterAny__Group_3__1 ; - public final void rule__ParameterAny__Group_3__0() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group_4__0" + // InternalRosParser.g:9836:1: rule__ParameterArrayType__Group_4__0 : rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 ; + public final void rule__ParameterArrayType__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12691:1: ( rule__ParameterAny__Group_3__0__Impl rule__ParameterAny__Group_3__1 ) - // InternalRos.g:12692:2: rule__ParameterAny__Group_3__0__Impl rule__ParameterAny__Group_3__1 + // InternalRosParser.g:9840:1: ( rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 ) + // InternalRosParser.g:9841:2: rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 { - pushFollow(FOLLOW_10); - rule__ParameterAny__Group_3__0__Impl(); + pushFollow(FOLLOW_11); + rule__ParameterArrayType__Group_4__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterAny__Group_3__1(); + rule__ParameterArrayType__Group_4__1(); state._fsp--; @@ -38420,25 +29628,25 @@ public final void rule__ParameterAny__Group_3__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterAny__Group_3__0" + // $ANTLR end "rule__ParameterArrayType__Group_4__0" - // $ANTLR start "rule__ParameterAny__Group_3__0__Impl" - // InternalRos.g:12699:1: rule__ParameterAny__Group_3__0__Impl : ( 'value' ) ; - public final void rule__ParameterAny__Group_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group_4__0__Impl" + // InternalRosParser.g:9848:1: rule__ParameterArrayType__Group_4__0__Impl : ( Default ) ; + public final void rule__ParameterArrayType__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12703:1: ( ( 'value' ) ) - // InternalRos.g:12704:1: ( 'value' ) + // InternalRosParser.g:9852:1: ( ( Default ) ) + // InternalRosParser.g:9853:1: ( Default ) { - // InternalRos.g:12704:1: ( 'value' ) - // InternalRos.g:12705:2: 'value' + // InternalRosParser.g:9853:1: ( Default ) + // InternalRosParser.g:9854:2: Default { - before(grammarAccess.getParameterAnyAccess().getValueKeyword_3_0()); - match(input,34,FOLLOW_2); - after(grammarAccess.getParameterAnyAccess().getValueKeyword_3_0()); + before(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); } @@ -38457,21 +29665,21 @@ public final void rule__ParameterAny__Group_3__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ParameterAny__Group_3__0__Impl" + // $ANTLR end "rule__ParameterArrayType__Group_4__0__Impl" - // $ANTLR start "rule__ParameterAny__Group_3__1" - // InternalRos.g:12714:1: rule__ParameterAny__Group_3__1 : rule__ParameterAny__Group_3__1__Impl ; - public final void rule__ParameterAny__Group_3__1() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group_4__1" + // InternalRosParser.g:9863:1: rule__ParameterArrayType__Group_4__1 : rule__ParameterArrayType__Group_4__1__Impl ; + public final void rule__ParameterArrayType__Group_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12718:1: ( rule__ParameterAny__Group_3__1__Impl ) - // InternalRos.g:12719:2: rule__ParameterAny__Group_3__1__Impl + // InternalRosParser.g:9867:1: ( rule__ParameterArrayType__Group_4__1__Impl ) + // InternalRosParser.g:9868:2: rule__ParameterArrayType__Group_4__1__Impl { pushFollow(FOLLOW_2); - rule__ParameterAny__Group_3__1__Impl(); + rule__ParameterArrayType__Group_4__1__Impl(); state._fsp--; @@ -38490,35 +29698,35 @@ public final void rule__ParameterAny__Group_3__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ParameterAny__Group_3__1" + // $ANTLR end "rule__ParameterArrayType__Group_4__1" - // $ANTLR start "rule__ParameterAny__Group_3__1__Impl" - // InternalRos.g:12725:1: rule__ParameterAny__Group_3__1__Impl : ( ( rule__ParameterAny__ValueAssignment_3_1 ) ) ; - public final void rule__ParameterAny__Group_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterArrayType__Group_4__1__Impl" + // InternalRosParser.g:9874:1: rule__ParameterArrayType__Group_4__1__Impl : ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) ; + public final void rule__ParameterArrayType__Group_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12729:1: ( ( ( rule__ParameterAny__ValueAssignment_3_1 ) ) ) - // InternalRos.g:12730:1: ( ( rule__ParameterAny__ValueAssignment_3_1 ) ) + // InternalRosParser.g:9878:1: ( ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) ) + // InternalRosParser.g:9879:1: ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) { - // InternalRos.g:12730:1: ( ( rule__ParameterAny__ValueAssignment_3_1 ) ) - // InternalRos.g:12731:2: ( rule__ParameterAny__ValueAssignment_3_1 ) + // InternalRosParser.g:9879:1: ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) + // InternalRosParser.g:9880:2: ( rule__ParameterArrayType__DefaultAssignment_4_1 ) { - before(grammarAccess.getParameterAnyAccess().getValueAssignment_3_1()); - // InternalRos.g:12732:2: ( rule__ParameterAny__ValueAssignment_3_1 ) - // InternalRos.g:12732:3: rule__ParameterAny__ValueAssignment_3_1 + before(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); + // InternalRosParser.g:9881:2: ( rule__ParameterArrayType__DefaultAssignment_4_1 ) + // InternalRosParser.g:9881:3: rule__ParameterArrayType__DefaultAssignment_4_1 { pushFollow(FOLLOW_2); - rule__ParameterAny__ValueAssignment_3_1(); + rule__ParameterArrayType__DefaultAssignment_4_1(); state._fsp--; } - after(grammarAccess.getParameterAnyAccess().getValueAssignment_3_1()); + after(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); } @@ -38537,26 +29745,26 @@ public final void rule__ParameterAny__Group_3__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ParameterAny__Group_3__1__Impl" + // $ANTLR end "rule__ParameterArrayType__Group_4__1__Impl" - // $ANTLR start "rule__ParameterStruct__Group__0" - // InternalRos.g:12741:1: rule__ParameterStruct__Group__0 : rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 ; - public final void rule__ParameterStruct__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group__0" + // InternalRosParser.g:9890:1: rule__ParameterList__Group__0 : rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 ; + public final void rule__ParameterList__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12745:1: ( rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 ) - // InternalRos.g:12746:2: rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 + // InternalRosParser.g:9894:1: ( rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 ) + // InternalRosParser.g:9895:2: rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 { - pushFollow(FOLLOW_64); - rule__ParameterStruct__Group__0__Impl(); + pushFollow(FOLLOW_11); + rule__ParameterList__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterStruct__Group__1(); + rule__ParameterList__Group__1(); state._fsp--; @@ -38575,29 +29783,29 @@ public final void rule__ParameterStruct__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__ParameterStruct__Group__0" + // $ANTLR end "rule__ParameterList__Group__0" - // $ANTLR start "rule__ParameterStruct__Group__0__Impl" - // InternalRos.g:12753:1: rule__ParameterStruct__Group__0__Impl : ( () ) ; - public final void rule__ParameterStruct__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group__0__Impl" + // InternalRosParser.g:9902:1: rule__ParameterList__Group__0__Impl : ( () ) ; + public final void rule__ParameterList__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12757:1: ( ( () ) ) - // InternalRos.g:12758:1: ( () ) + // InternalRosParser.g:9906:1: ( ( () ) ) + // InternalRosParser.g:9907:1: ( () ) { - // InternalRos.g:12758:1: ( () ) - // InternalRos.g:12759:2: () + // InternalRosParser.g:9907:1: ( () ) + // InternalRosParser.g:9908:2: () { - before(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); - // InternalRos.g:12760:2: () - // InternalRos.g:12760:3: + before(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); + // InternalRosParser.g:9909:2: () + // InternalRosParser.g:9909:3: { } - after(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); + after(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); } @@ -38612,21 +29820,26 @@ public final void rule__ParameterStruct__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterStruct__Group__0__Impl" + // $ANTLR end "rule__ParameterList__Group__0__Impl" - // $ANTLR start "rule__ParameterStruct__Group__1" - // InternalRos.g:12768:1: rule__ParameterStruct__Group__1 : rule__ParameterStruct__Group__1__Impl ; - public final void rule__ParameterStruct__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group__1" + // InternalRosParser.g:9917:1: rule__ParameterList__Group__1 : rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 ; + public final void rule__ParameterList__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12772:1: ( rule__ParameterStruct__Group__1__Impl ) - // InternalRos.g:12773:2: rule__ParameterStruct__Group__1__Impl + // InternalRosParser.g:9921:1: ( rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 ) + // InternalRosParser.g:9922:2: rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 { + pushFollow(FOLLOW_56); + rule__ParameterList__Group__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__ParameterStruct__Group__1__Impl(); + rule__ParameterList__Group__2(); state._fsp--; @@ -38645,46 +29858,25 @@ public final void rule__ParameterStruct__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__ParameterStruct__Group__1" + // $ANTLR end "rule__ParameterList__Group__1" - // $ANTLR start "rule__ParameterStruct__Group__1__Impl" - // InternalRos.g:12779:1: rule__ParameterStruct__Group__1__Impl : ( ( rule__ParameterStruct__Group_1__0 )? ) ; - public final void rule__ParameterStruct__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group__1__Impl" + // InternalRosParser.g:9929:1: rule__ParameterList__Group__1__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterList__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12783:1: ( ( ( rule__ParameterStruct__Group_1__0 )? ) ) - // InternalRos.g:12784:1: ( ( rule__ParameterStruct__Group_1__0 )? ) + // InternalRosParser.g:9933:1: ( ( LeftSquareBracket ) ) + // InternalRosParser.g:9934:1: ( LeftSquareBracket ) { - // InternalRos.g:12784:1: ( ( rule__ParameterStruct__Group_1__0 )? ) - // InternalRos.g:12785:2: ( rule__ParameterStruct__Group_1__0 )? + // InternalRosParser.g:9934:1: ( LeftSquareBracket ) + // InternalRosParser.g:9935:2: LeftSquareBracket { - before(grammarAccess.getParameterStructAccess().getGroup_1()); - // InternalRos.g:12786:2: ( rule__ParameterStruct__Group_1__0 )? - int alt80=2; - int LA80_0 = input.LA(1); - - if ( (LA80_0==41) ) { - alt80=1; - } - switch (alt80) { - case 1 : - // InternalRos.g:12786:3: rule__ParameterStruct__Group_1__0 - { - pushFollow(FOLLOW_2); - rule__ParameterStruct__Group_1__0(); - - state._fsp--; - - - } - break; - - } - - after(grammarAccess.getParameterStructAccess().getGroup_1()); + before(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); } @@ -38703,26 +29895,26 @@ public final void rule__ParameterStruct__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterStruct__Group__1__Impl" + // $ANTLR end "rule__ParameterList__Group__1__Impl" - // $ANTLR start "rule__ParameterStruct__Group_1__0" - // InternalRos.g:12795:1: rule__ParameterStruct__Group_1__0 : rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 ; - public final void rule__ParameterStruct__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group__2" + // InternalRosParser.g:9944:1: rule__ParameterList__Group__2 : rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 ; + public final void rule__ParameterList__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12799:1: ( rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 ) - // InternalRos.g:12800:2: rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 + // InternalRosParser.g:9948:1: ( rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 ) + // InternalRosParser.g:9949:2: rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 { - pushFollow(FOLLOW_67); - rule__ParameterStruct__Group_1__0__Impl(); + pushFollow(FOLLOW_13); + rule__ParameterList__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterStruct__Group_1__1(); + rule__ParameterList__Group__3(); state._fsp--; @@ -38741,25 +29933,35 @@ public final void rule__ParameterStruct__Group_1__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1__0" + // $ANTLR end "rule__ParameterList__Group__2" - // $ANTLR start "rule__ParameterStruct__Group_1__0__Impl" - // InternalRos.g:12807:1: rule__ParameterStruct__Group_1__0__Impl : ( '{' ) ; - public final void rule__ParameterStruct__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group__2__Impl" + // InternalRosParser.g:9956:1: rule__ParameterList__Group__2__Impl : ( ( rule__ParameterList__ValueAssignment_2 ) ) ; + public final void rule__ParameterList__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12811:1: ( ( '{' ) ) - // InternalRos.g:12812:1: ( '{' ) + // InternalRosParser.g:9960:1: ( ( ( rule__ParameterList__ValueAssignment_2 ) ) ) + // InternalRosParser.g:9961:1: ( ( rule__ParameterList__ValueAssignment_2 ) ) + { + // InternalRosParser.g:9961:1: ( ( rule__ParameterList__ValueAssignment_2 ) ) + // InternalRosParser.g:9962:2: ( rule__ParameterList__ValueAssignment_2 ) { - // InternalRos.g:12812:1: ( '{' ) - // InternalRos.g:12813:2: '{' + before(grammarAccess.getParameterListAccess().getValueAssignment_2()); + // InternalRosParser.g:9963:2: ( rule__ParameterList__ValueAssignment_2 ) + // InternalRosParser.g:9963:3: rule__ParameterList__ValueAssignment_2 { - before(grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_0()); - match(input,41,FOLLOW_2); - after(grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_0()); + pushFollow(FOLLOW_2); + rule__ParameterList__ValueAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListAccess().getValueAssignment_2()); } @@ -38778,26 +29980,26 @@ public final void rule__ParameterStruct__Group_1__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1__0__Impl" + // $ANTLR end "rule__ParameterList__Group__2__Impl" - // $ANTLR start "rule__ParameterStruct__Group_1__1" - // InternalRos.g:12822:1: rule__ParameterStruct__Group_1__1 : rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 ; - public final void rule__ParameterStruct__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group__3" + // InternalRosParser.g:9971:1: rule__ParameterList__Group__3 : rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 ; + public final void rule__ParameterList__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12826:1: ( rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 ) - // InternalRos.g:12827:2: rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 + // InternalRosParser.g:9975:1: ( rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 ) + // InternalRosParser.g:9976:2: rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 { pushFollow(FOLLOW_13); - rule__ParameterStruct__Group_1__1__Impl(); + rule__ParameterList__Group__3__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterStruct__Group_1__2(); + rule__ParameterList__Group__4(); state._fsp--; @@ -38816,35 +30018,53 @@ public final void rule__ParameterStruct__Group_1__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1__1" + // $ANTLR end "rule__ParameterList__Group__3" - // $ANTLR start "rule__ParameterStruct__Group_1__1__Impl" - // InternalRos.g:12834:1: rule__ParameterStruct__Group_1__1__Impl : ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) ; - public final void rule__ParameterStruct__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group__3__Impl" + // InternalRosParser.g:9983:1: rule__ParameterList__Group__3__Impl : ( ( rule__ParameterList__Group_3__0 )* ) ; + public final void rule__ParameterList__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12838:1: ( ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) ) - // InternalRos.g:12839:1: ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) - { - // InternalRos.g:12839:1: ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) - // InternalRos.g:12840:2: ( rule__ParameterStruct__ValueAssignment_1_1 ) + // InternalRosParser.g:9987:1: ( ( ( rule__ParameterList__Group_3__0 )* ) ) + // InternalRosParser.g:9988:1: ( ( rule__ParameterList__Group_3__0 )* ) { - before(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); - // InternalRos.g:12841:2: ( rule__ParameterStruct__ValueAssignment_1_1 ) - // InternalRos.g:12841:3: rule__ParameterStruct__ValueAssignment_1_1 + // InternalRosParser.g:9988:1: ( ( rule__ParameterList__Group_3__0 )* ) + // InternalRosParser.g:9989:2: ( rule__ParameterList__Group_3__0 )* { - pushFollow(FOLLOW_2); - rule__ParameterStruct__ValueAssignment_1_1(); + before(grammarAccess.getParameterListAccess().getGroup_3()); + // InternalRosParser.g:9990:2: ( rule__ParameterList__Group_3__0 )* + loop56: + do { + int alt56=2; + int LA56_0 = input.LA(1); - state._fsp--; + if ( (LA56_0==Comma) ) { + alt56=1; + } - } + switch (alt56) { + case 1 : + // InternalRosParser.g:9990:3: rule__ParameterList__Group_3__0 + { + pushFollow(FOLLOW_14); + rule__ParameterList__Group_3__0(); - after(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); + state._fsp--; + + + } + break; + + default : + break loop56; + } + } while (true); + + after(grammarAccess.getParameterListAccess().getGroup_3()); } @@ -38863,26 +30083,21 @@ public final void rule__ParameterStruct__Group_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1__1__Impl" + // $ANTLR end "rule__ParameterList__Group__3__Impl" - // $ANTLR start "rule__ParameterStruct__Group_1__2" - // InternalRos.g:12849:1: rule__ParameterStruct__Group_1__2 : rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 ; - public final void rule__ParameterStruct__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group__4" + // InternalRosParser.g:9998:1: rule__ParameterList__Group__4 : rule__ParameterList__Group__4__Impl ; + public final void rule__ParameterList__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12853:1: ( rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 ) - // InternalRos.g:12854:2: rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 + // InternalRosParser.g:10002:1: ( rule__ParameterList__Group__4__Impl ) + // InternalRosParser.g:10003:2: rule__ParameterList__Group__4__Impl { - pushFollow(FOLLOW_13); - rule__ParameterStruct__Group_1__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ParameterStruct__Group_1__3(); + rule__ParameterList__Group__4__Impl(); state._fsp--; @@ -38901,53 +30116,100 @@ public final void rule__ParameterStruct__Group_1__2() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1__2" + // $ANTLR end "rule__ParameterList__Group__4" - // $ANTLR start "rule__ParameterStruct__Group_1__2__Impl" - // InternalRos.g:12861:1: rule__ParameterStruct__Group_1__2__Impl : ( ( rule__ParameterStruct__Group_1_2__0 )* ) ; - public final void rule__ParameterStruct__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group__4__Impl" + // InternalRosParser.g:10009:1: rule__ParameterList__Group__4__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterList__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12865:1: ( ( ( rule__ParameterStruct__Group_1_2__0 )* ) ) - // InternalRos.g:12866:1: ( ( rule__ParameterStruct__Group_1_2__0 )* ) + // InternalRosParser.g:10013:1: ( ( RightSquareBracket ) ) + // InternalRosParser.g:10014:1: ( RightSquareBracket ) { - // InternalRos.g:12866:1: ( ( rule__ParameterStruct__Group_1_2__0 )* ) - // InternalRos.g:12867:2: ( rule__ParameterStruct__Group_1_2__0 )* + // InternalRosParser.g:10014:1: ( RightSquareBracket ) + // InternalRosParser.g:10015:2: RightSquareBracket { - before(grammarAccess.getParameterStructAccess().getGroup_1_2()); - // InternalRos.g:12868:2: ( rule__ParameterStruct__Group_1_2__0 )* - loop81: - do { - int alt81=2; - int LA81_0 = input.LA(1); + before(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); - if ( (LA81_0==43) ) { - alt81=1; - } + } - switch (alt81) { - case 1 : - // InternalRos.g:12868:3: rule__ParameterStruct__Group_1_2__0 - { - pushFollow(FOLLOW_7); - rule__ParameterStruct__Group_1_2__0(); + } - state._fsp--; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + restoreStackSize(stackSize); - } - break; + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__4__Impl" - default : - break loop81; - } - } while (true); - after(grammarAccess.getParameterStructAccess().getGroup_1_2()); + // $ANTLR start "rule__ParameterList__Group_3__0" + // InternalRosParser.g:10025:1: rule__ParameterList__Group_3__0 : rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 ; + public final void rule__ParameterList__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:10029:1: ( rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 ) + // InternalRosParser.g:10030:2: rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 + { + pushFollow(FOLLOW_56); + rule__ParameterList__Group_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterList__Group_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group_3__0" + + + // $ANTLR start "rule__ParameterList__Group_3__0__Impl" + // InternalRosParser.g:10037:1: rule__ParameterList__Group_3__0__Impl : ( Comma ) ; + public final void rule__ParameterList__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:10041:1: ( ( Comma ) ) + // InternalRosParser.g:10042:1: ( Comma ) + { + // InternalRosParser.g:10042:1: ( Comma ) + // InternalRosParser.g:10043:2: Comma + { + before(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); } @@ -38966,21 +30228,21 @@ public final void rule__ParameterStruct__Group_1__2__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1__2__Impl" + // $ANTLR end "rule__ParameterList__Group_3__0__Impl" - // $ANTLR start "rule__ParameterStruct__Group_1__3" - // InternalRos.g:12876:1: rule__ParameterStruct__Group_1__3 : rule__ParameterStruct__Group_1__3__Impl ; - public final void rule__ParameterStruct__Group_1__3() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group_3__1" + // InternalRosParser.g:10052:1: rule__ParameterList__Group_3__1 : rule__ParameterList__Group_3__1__Impl ; + public final void rule__ParameterList__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12880:1: ( rule__ParameterStruct__Group_1__3__Impl ) - // InternalRos.g:12881:2: rule__ParameterStruct__Group_1__3__Impl + // InternalRosParser.g:10056:1: ( rule__ParameterList__Group_3__1__Impl ) + // InternalRosParser.g:10057:2: rule__ParameterList__Group_3__1__Impl { pushFollow(FOLLOW_2); - rule__ParameterStruct__Group_1__3__Impl(); + rule__ParameterList__Group_3__1__Impl(); state._fsp--; @@ -38999,25 +30261,35 @@ public final void rule__ParameterStruct__Group_1__3() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1__3" + // $ANTLR end "rule__ParameterList__Group_3__1" - // $ANTLR start "rule__ParameterStruct__Group_1__3__Impl" - // InternalRos.g:12887:1: rule__ParameterStruct__Group_1__3__Impl : ( '}' ) ; - public final void rule__ParameterStruct__Group_1__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterList__Group_3__1__Impl" + // InternalRosParser.g:10063:1: rule__ParameterList__Group_3__1__Impl : ( ( rule__ParameterList__ValueAssignment_3_1 ) ) ; + public final void rule__ParameterList__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12891:1: ( ( '}' ) ) - // InternalRos.g:12892:1: ( '}' ) + // InternalRosParser.g:10067:1: ( ( ( rule__ParameterList__ValueAssignment_3_1 ) ) ) + // InternalRosParser.g:10068:1: ( ( rule__ParameterList__ValueAssignment_3_1 ) ) + { + // InternalRosParser.g:10068:1: ( ( rule__ParameterList__ValueAssignment_3_1 ) ) + // InternalRosParser.g:10069:2: ( rule__ParameterList__ValueAssignment_3_1 ) { - // InternalRos.g:12892:1: ( '}' ) - // InternalRos.g:12893:2: '}' + before(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); + // InternalRosParser.g:10070:2: ( rule__ParameterList__ValueAssignment_3_1 ) + // InternalRosParser.g:10070:3: rule__ParameterList__ValueAssignment_3_1 { - before(grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_3()); - match(input,42,FOLLOW_2); - after(grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_3()); + pushFollow(FOLLOW_2); + rule__ParameterList__ValueAssignment_3_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); } @@ -39036,26 +30308,26 @@ public final void rule__ParameterStruct__Group_1__3__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1__3__Impl" + // $ANTLR end "rule__ParameterList__Group_3__1__Impl" - // $ANTLR start "rule__ParameterStruct__Group_1_2__0" - // InternalRos.g:12903:1: rule__ParameterStruct__Group_1_2__0 : rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 ; - public final void rule__ParameterStruct__Group_1_2__0() throws RecognitionException { + // $ANTLR start "rule__ParameterAny__Group__0" + // InternalRosParser.g:10079:1: rule__ParameterAny__Group__0 : rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 ; + public final void rule__ParameterAny__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12907:1: ( rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 ) - // InternalRos.g:12908:2: rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 + // InternalRosParser.g:10083:1: ( rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 ) + // InternalRosParser.g:10084:2: rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 { - pushFollow(FOLLOW_4); - rule__ParameterStruct__Group_1_2__0__Impl(); + pushFollow(FOLLOW_57); + rule__ParameterAny__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterStruct__Group_1_2__1(); + rule__ParameterAny__Group__1(); state._fsp--; @@ -39074,25 +30346,29 @@ public final void rule__ParameterStruct__Group_1_2__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1_2__0" + // $ANTLR end "rule__ParameterAny__Group__0" - // $ANTLR start "rule__ParameterStruct__Group_1_2__0__Impl" - // InternalRos.g:12915:1: rule__ParameterStruct__Group_1_2__0__Impl : ( ',' ) ; - public final void rule__ParameterStruct__Group_1_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterAny__Group__0__Impl" + // InternalRosParser.g:10091:1: rule__ParameterAny__Group__0__Impl : ( () ) ; + public final void rule__ParameterAny__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12919:1: ( ( ',' ) ) - // InternalRos.g:12920:1: ( ',' ) + // InternalRosParser.g:10095:1: ( ( () ) ) + // InternalRosParser.g:10096:1: ( () ) { - // InternalRos.g:12920:1: ( ',' ) - // InternalRos.g:12921:2: ',' + // InternalRosParser.g:10096:1: ( () ) + // InternalRosParser.g:10097:2: () { - before(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); - match(input,43,FOLLOW_2); - after(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); + before(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); + // InternalRosParser.g:10098:2: () + // InternalRosParser.g:10098:3: + { + } + + after(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); } @@ -39100,10 +30376,6 @@ public final void rule__ParameterStruct__Group_1_2__0__Impl() throws Recognition } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -39111,26 +30383,26 @@ public final void rule__ParameterStruct__Group_1_2__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1_2__0__Impl" + // $ANTLR end "rule__ParameterAny__Group__0__Impl" - // $ANTLR start "rule__ParameterStruct__Group_1_2__1" - // InternalRos.g:12930:1: rule__ParameterStruct__Group_1_2__1 : rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 ; - public final void rule__ParameterStruct__Group_1_2__1() throws RecognitionException { + // $ANTLR start "rule__ParameterAny__Group__1" + // InternalRosParser.g:10106:1: rule__ParameterAny__Group__1 : rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 ; + public final void rule__ParameterAny__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12934:1: ( rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 ) - // InternalRos.g:12935:2: rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 + // InternalRosParser.g:10110:1: ( rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 ) + // InternalRosParser.g:10111:2: rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 { - pushFollow(FOLLOW_67); - rule__ParameterStruct__Group_1_2__1__Impl(); + pushFollow(FOLLOW_58); + rule__ParameterAny__Group__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterStruct__Group_1_2__2(); + rule__ParameterAny__Group__2(); state._fsp--; @@ -39149,25 +30421,25 @@ public final void rule__ParameterStruct__Group_1_2__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1_2__1" + // $ANTLR end "rule__ParameterAny__Group__1" - // $ANTLR start "rule__ParameterStruct__Group_1_2__1__Impl" - // InternalRos.g:12942:1: rule__ParameterStruct__Group_1_2__1__Impl : ( '{' ) ; - public final void rule__ParameterStruct__Group_1_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterAny__Group__1__Impl" + // InternalRosParser.g:10118:1: rule__ParameterAny__Group__1__Impl : ( ParameterAny ) ; + public final void rule__ParameterAny__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12946:1: ( ( '{' ) ) - // InternalRos.g:12947:1: ( '{' ) + // InternalRosParser.g:10122:1: ( ( ParameterAny ) ) + // InternalRosParser.g:10123:1: ( ParameterAny ) { - // InternalRos.g:12947:1: ( '{' ) - // InternalRos.g:12948:2: '{' + // InternalRosParser.g:10123:1: ( ParameterAny ) + // InternalRosParser.g:10124:2: ParameterAny { - before(grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_2_1()); - match(input,41,FOLLOW_2); - after(grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_2_1()); + before(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); + match(input,ParameterAny,FOLLOW_2); + after(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); } @@ -39186,26 +30458,21 @@ public final void rule__ParameterStruct__Group_1_2__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1_2__1__Impl" + // $ANTLR end "rule__ParameterAny__Group__1__Impl" - // $ANTLR start "rule__ParameterStruct__Group_1_2__2" - // InternalRos.g:12957:1: rule__ParameterStruct__Group_1_2__2 : rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 ; - public final void rule__ParameterStruct__Group_1_2__2() throws RecognitionException { + // $ANTLR start "rule__ParameterAny__Group__2" + // InternalRosParser.g:10133:1: rule__ParameterAny__Group__2 : rule__ParameterAny__Group__2__Impl ; + public final void rule__ParameterAny__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12961:1: ( rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 ) - // InternalRos.g:12962:2: rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 + // InternalRosParser.g:10137:1: ( rule__ParameterAny__Group__2__Impl ) + // InternalRosParser.g:10138:2: rule__ParameterAny__Group__2__Impl { - pushFollow(FOLLOW_49); - rule__ParameterStruct__Group_1_2__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ParameterStruct__Group_1_2__3(); + rule__ParameterAny__Group__2__Impl(); state._fsp--; @@ -39224,35 +30491,46 @@ public final void rule__ParameterStruct__Group_1_2__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1_2__2" + // $ANTLR end "rule__ParameterAny__Group__2" - // $ANTLR start "rule__ParameterStruct__Group_1_2__2__Impl" - // InternalRos.g:12969:1: rule__ParameterStruct__Group_1_2__2__Impl : ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) ; - public final void rule__ParameterStruct__Group_1_2__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterAny__Group__2__Impl" + // InternalRosParser.g:10144:1: rule__ParameterAny__Group__2__Impl : ( ( rule__ParameterAny__Group_2__0 )? ) ; + public final void rule__ParameterAny__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12973:1: ( ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) ) - // InternalRos.g:12974:1: ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) - { - // InternalRos.g:12974:1: ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) - // InternalRos.g:12975:2: ( rule__ParameterStruct__ValueAssignment_1_2_2 ) + // InternalRosParser.g:10148:1: ( ( ( rule__ParameterAny__Group_2__0 )? ) ) + // InternalRosParser.g:10149:1: ( ( rule__ParameterAny__Group_2__0 )? ) { - before(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); - // InternalRos.g:12976:2: ( rule__ParameterStruct__ValueAssignment_1_2_2 ) - // InternalRos.g:12976:3: rule__ParameterStruct__ValueAssignment_1_2_2 + // InternalRosParser.g:10149:1: ( ( rule__ParameterAny__Group_2__0 )? ) + // InternalRosParser.g:10150:2: ( rule__ParameterAny__Group_2__0 )? { - pushFollow(FOLLOW_2); - rule__ParameterStruct__ValueAssignment_1_2_2(); + before(grammarAccess.getParameterAnyAccess().getGroup_2()); + // InternalRosParser.g:10151:2: ( rule__ParameterAny__Group_2__0 )? + int alt57=2; + int LA57_0 = input.LA(1); - state._fsp--; + if ( (LA57_0==Value) ) { + alt57=1; + } + switch (alt57) { + case 1 : + // InternalRosParser.g:10151:3: rule__ParameterAny__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterAny__Group_2__0(); + + state._fsp--; + } + break; + } - after(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); + after(grammarAccess.getParameterAnyAccess().getGroup_2()); } @@ -39271,21 +30549,26 @@ public final void rule__ParameterStruct__Group_1_2__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1_2__2__Impl" + // $ANTLR end "rule__ParameterAny__Group__2__Impl" - // $ANTLR start "rule__ParameterStruct__Group_1_2__3" - // InternalRos.g:12984:1: rule__ParameterStruct__Group_1_2__3 : rule__ParameterStruct__Group_1_2__3__Impl ; - public final void rule__ParameterStruct__Group_1_2__3() throws RecognitionException { + // $ANTLR start "rule__ParameterAny__Group_2__0" + // InternalRosParser.g:10160:1: rule__ParameterAny__Group_2__0 : rule__ParameterAny__Group_2__0__Impl rule__ParameterAny__Group_2__1 ; + public final void rule__ParameterAny__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12988:1: ( rule__ParameterStruct__Group_1_2__3__Impl ) - // InternalRos.g:12989:2: rule__ParameterStruct__Group_1_2__3__Impl + // InternalRosParser.g:10164:1: ( rule__ParameterAny__Group_2__0__Impl rule__ParameterAny__Group_2__1 ) + // InternalRosParser.g:10165:2: rule__ParameterAny__Group_2__0__Impl rule__ParameterAny__Group_2__1 { + pushFollow(FOLLOW_8); + rule__ParameterAny__Group_2__0__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__ParameterStruct__Group_1_2__3__Impl(); + rule__ParameterAny__Group_2__1(); state._fsp--; @@ -39304,25 +30587,25 @@ public final void rule__ParameterStruct__Group_1_2__3() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1_2__3" + // $ANTLR end "rule__ParameterAny__Group_2__0" - // $ANTLR start "rule__ParameterStruct__Group_1_2__3__Impl" - // InternalRos.g:12995:1: rule__ParameterStruct__Group_1_2__3__Impl : ( '}' ) ; - public final void rule__ParameterStruct__Group_1_2__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterAny__Group_2__0__Impl" + // InternalRosParser.g:10172:1: rule__ParameterAny__Group_2__0__Impl : ( Value ) ; + public final void rule__ParameterAny__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:12999:1: ( ( '}' ) ) - // InternalRos.g:13000:1: ( '}' ) + // InternalRosParser.g:10176:1: ( ( Value ) ) + // InternalRosParser.g:10177:1: ( Value ) { - // InternalRos.g:13000:1: ( '}' ) - // InternalRos.g:13001:2: '}' + // InternalRosParser.g:10177:1: ( Value ) + // InternalRosParser.g:10178:2: Value { - before(grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_2_3()); - match(input,42,FOLLOW_2); - after(grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_2_3()); + before(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); + match(input,Value,FOLLOW_2); + after(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); } @@ -39341,26 +30624,21 @@ public final void rule__ParameterStruct__Group_1_2__3__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ParameterStruct__Group_1_2__3__Impl" + // $ANTLR end "rule__ParameterAny__Group_2__0__Impl" - // $ANTLR start "rule__ParameterStructMember__Group__0" - // InternalRos.g:13011:1: rule__ParameterStructMember__Group__0 : rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 ; - public final void rule__ParameterStructMember__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterAny__Group_2__1" + // InternalRosParser.g:10187:1: rule__ParameterAny__Group_2__1 : rule__ParameterAny__Group_2__1__Impl ; + public final void rule__ParameterAny__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13015:1: ( rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 ) - // InternalRos.g:13016:2: rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 + // InternalRosParser.g:10191:1: ( rule__ParameterAny__Group_2__1__Impl ) + // InternalRosParser.g:10192:2: rule__ParameterAny__Group_2__1__Impl { - pushFollow(FOLLOW_10); - rule__ParameterStructMember__Group__0__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ParameterStructMember__Group__1(); + rule__ParameterAny__Group_2__1__Impl(); state._fsp--; @@ -39379,25 +30657,35 @@ public final void rule__ParameterStructMember__Group__0() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterStructMember__Group__0" + // $ANTLR end "rule__ParameterAny__Group_2__1" - // $ANTLR start "rule__ParameterStructMember__Group__0__Impl" - // InternalRos.g:13023:1: rule__ParameterStructMember__Group__0__Impl : ( 'ParameterStructMember' ) ; - public final void rule__ParameterStructMember__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterAny__Group_2__1__Impl" + // InternalRosParser.g:10198:1: rule__ParameterAny__Group_2__1__Impl : ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) ; + public final void rule__ParameterAny__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13027:1: ( ( 'ParameterStructMember' ) ) - // InternalRos.g:13028:1: ( 'ParameterStructMember' ) + // InternalRosParser.g:10202:1: ( ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) ) + // InternalRosParser.g:10203:1: ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) { - // InternalRos.g:13028:1: ( 'ParameterStructMember' ) - // InternalRos.g:13029:2: 'ParameterStructMember' + // InternalRosParser.g:10203:1: ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) + // InternalRosParser.g:10204:2: ( rule__ParameterAny__ValueAssignment_2_1 ) { - before(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); - match(input,86,FOLLOW_2); - after(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); + before(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); + // InternalRosParser.g:10205:2: ( rule__ParameterAny__ValueAssignment_2_1 ) + // InternalRosParser.g:10205:3: rule__ParameterAny__ValueAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterAny__ValueAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); } @@ -39416,26 +30704,26 @@ public final void rule__ParameterStructMember__Group__0__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__ParameterStructMember__Group__0__Impl" + // $ANTLR end "rule__ParameterAny__Group_2__1__Impl" - // $ANTLR start "rule__ParameterStructMember__Group__1" - // InternalRos.g:13038:1: rule__ParameterStructMember__Group__1 : rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 ; - public final void rule__ParameterStructMember__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group__0" + // InternalRosParser.g:10214:1: rule__ParameterStruct__Group__0 : rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 ; + public final void rule__ParameterStruct__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13042:1: ( rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 ) - // InternalRos.g:13043:2: rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 + // InternalRosParser.g:10218:1: ( rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 ) + // InternalRosParser.g:10219:2: rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 { - pushFollow(FOLLOW_4); - rule__ParameterStructMember__Group__1__Impl(); + pushFollow(FOLLOW_56); + rule__ParameterStruct__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterStructMember__Group__2(); + rule__ParameterStruct__Group__1(); state._fsp--; @@ -39454,35 +30742,29 @@ public final void rule__ParameterStructMember__Group__1() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterStructMember__Group__1" + // $ANTLR end "rule__ParameterStruct__Group__0" - // $ANTLR start "rule__ParameterStructMember__Group__1__Impl" - // InternalRos.g:13050:1: rule__ParameterStructMember__Group__1__Impl : ( ( rule__ParameterStructMember__NameAssignment_1 ) ) ; - public final void rule__ParameterStructMember__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group__0__Impl" + // InternalRosParser.g:10226:1: rule__ParameterStruct__Group__0__Impl : ( () ) ; + public final void rule__ParameterStruct__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13054:1: ( ( ( rule__ParameterStructMember__NameAssignment_1 ) ) ) - // InternalRos.g:13055:1: ( ( rule__ParameterStructMember__NameAssignment_1 ) ) + // InternalRosParser.g:10230:1: ( ( () ) ) + // InternalRosParser.g:10231:1: ( () ) { - // InternalRos.g:13055:1: ( ( rule__ParameterStructMember__NameAssignment_1 ) ) - // InternalRos.g:13056:2: ( rule__ParameterStructMember__NameAssignment_1 ) + // InternalRosParser.g:10231:1: ( () ) + // InternalRosParser.g:10232:2: () { - before(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); - // InternalRos.g:13057:2: ( rule__ParameterStructMember__NameAssignment_1 ) - // InternalRos.g:13057:3: rule__ParameterStructMember__NameAssignment_1 + before(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); + // InternalRosParser.g:10233:2: () + // InternalRosParser.g:10233:3: { - pushFollow(FOLLOW_2); - rule__ParameterStructMember__NameAssignment_1(); - - state._fsp--; - - } - after(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); + after(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); } @@ -39490,10 +30772,6 @@ public final void rule__ParameterStructMember__Group__1__Impl() throws Recogniti } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -39501,26 +30779,21 @@ public final void rule__ParameterStructMember__Group__1__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__ParameterStructMember__Group__1__Impl" + // $ANTLR end "rule__ParameterStruct__Group__0__Impl" - // $ANTLR start "rule__ParameterStructMember__Group__2" - // InternalRos.g:13065:1: rule__ParameterStructMember__Group__2 : rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 ; - public final void rule__ParameterStructMember__Group__2() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group__1" + // InternalRosParser.g:10241:1: rule__ParameterStruct__Group__1 : rule__ParameterStruct__Group__1__Impl ; + public final void rule__ParameterStruct__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13069:1: ( rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 ) - // InternalRos.g:13070:2: rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 + // InternalRosParser.g:10245:1: ( rule__ParameterStruct__Group__1__Impl ) + // InternalRosParser.g:10246:2: rule__ParameterStruct__Group__1__Impl { - pushFollow(FOLLOW_68); - rule__ParameterStructMember__Group__2__Impl(); - - state._fsp--; - pushFollow(FOLLOW_2); - rule__ParameterStructMember__Group__3(); + rule__ParameterStruct__Group__1__Impl(); state._fsp--; @@ -39539,25 +30812,46 @@ public final void rule__ParameterStructMember__Group__2() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterStructMember__Group__2" + // $ANTLR end "rule__ParameterStruct__Group__1" - // $ANTLR start "rule__ParameterStructMember__Group__2__Impl" - // InternalRos.g:13077:1: rule__ParameterStructMember__Group__2__Impl : ( '{' ) ; - public final void rule__ParameterStructMember__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group__1__Impl" + // InternalRosParser.g:10252:1: rule__ParameterStruct__Group__1__Impl : ( ( rule__ParameterStruct__Group_1__0 )? ) ; + public final void rule__ParameterStruct__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13081:1: ( ( '{' ) ) - // InternalRos.g:13082:1: ( '{' ) + // InternalRosParser.g:10256:1: ( ( ( rule__ParameterStruct__Group_1__0 )? ) ) + // InternalRosParser.g:10257:1: ( ( rule__ParameterStruct__Group_1__0 )? ) { - // InternalRos.g:13082:1: ( '{' ) - // InternalRos.g:13083:2: '{' + // InternalRosParser.g:10257:1: ( ( rule__ParameterStruct__Group_1__0 )? ) + // InternalRosParser.g:10258:2: ( rule__ParameterStruct__Group_1__0 )? { - before(grammarAccess.getParameterStructMemberAccess().getLeftCurlyBracketKeyword_2()); - match(input,41,FOLLOW_2); - after(grammarAccess.getParameterStructMemberAccess().getLeftCurlyBracketKeyword_2()); + before(grammarAccess.getParameterStructAccess().getGroup_1()); + // InternalRosParser.g:10259:2: ( rule__ParameterStruct__Group_1__0 )? + int alt58=2; + int LA58_0 = input.LA(1); + + if ( (LA58_0==LeftSquareBracket) ) { + alt58=1; + } + switch (alt58) { + case 1 : + // InternalRosParser.g:10259:3: rule__ParameterStruct__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterStructAccess().getGroup_1()); } @@ -39576,26 +30870,26 @@ public final void rule__ParameterStructMember__Group__2__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__ParameterStructMember__Group__2__Impl" + // $ANTLR end "rule__ParameterStruct__Group__1__Impl" - // $ANTLR start "rule__ParameterStructMember__Group__3" - // InternalRos.g:13092:1: rule__ParameterStructMember__Group__3 : rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 ; - public final void rule__ParameterStructMember__Group__3() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1__0" + // InternalRosParser.g:10268:1: rule__ParameterStruct__Group_1__0 : rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 ; + public final void rule__ParameterStruct__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13096:1: ( rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 ) - // InternalRos.g:13097:2: rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 + // InternalRosParser.g:10272:1: ( rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 ) + // InternalRosParser.g:10273:2: rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 { - pushFollow(FOLLOW_64); - rule__ParameterStructMember__Group__3__Impl(); + pushFollow(FOLLOW_59); + rule__ParameterStruct__Group_1__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterStructMember__Group__4(); + rule__ParameterStruct__Group_1__1(); state._fsp--; @@ -39614,25 +30908,25 @@ public final void rule__ParameterStructMember__Group__3() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterStructMember__Group__3" + // $ANTLR end "rule__ParameterStruct__Group_1__0" - // $ANTLR start "rule__ParameterStructMember__Group__3__Impl" - // InternalRos.g:13104:1: rule__ParameterStructMember__Group__3__Impl : ( 'value' ) ; - public final void rule__ParameterStructMember__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1__0__Impl" + // InternalRosParser.g:10280:1: rule__ParameterStruct__Group_1__0__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterStruct__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13108:1: ( ( 'value' ) ) - // InternalRos.g:13109:1: ( 'value' ) + // InternalRosParser.g:10284:1: ( ( LeftSquareBracket ) ) + // InternalRosParser.g:10285:1: ( LeftSquareBracket ) { - // InternalRos.g:13109:1: ( 'value' ) - // InternalRos.g:13110:2: 'value' + // InternalRosParser.g:10285:1: ( LeftSquareBracket ) + // InternalRosParser.g:10286:2: LeftSquareBracket { - before(grammarAccess.getParameterStructMemberAccess().getValueKeyword_3()); - match(input,34,FOLLOW_2); - after(grammarAccess.getParameterStructMemberAccess().getValueKeyword_3()); + before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); } @@ -39651,26 +30945,26 @@ public final void rule__ParameterStructMember__Group__3__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__ParameterStructMember__Group__3__Impl" + // $ANTLR end "rule__ParameterStruct__Group_1__0__Impl" - // $ANTLR start "rule__ParameterStructMember__Group__4" - // InternalRos.g:13119:1: rule__ParameterStructMember__Group__4 : rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 ; - public final void rule__ParameterStructMember__Group__4() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1__1" + // InternalRosParser.g:10295:1: rule__ParameterStruct__Group_1__1 : rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 ; + public final void rule__ParameterStruct__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13123:1: ( rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 ) - // InternalRos.g:13124:2: rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 + // InternalRosParser.g:10299:1: ( rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 ) + // InternalRosParser.g:10300:2: rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 { - pushFollow(FOLLOW_49); - rule__ParameterStructMember__Group__4__Impl(); + pushFollow(FOLLOW_13); + rule__ParameterStruct__Group_1__1__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ParameterStructMember__Group__5(); + rule__ParameterStruct__Group_1__2(); state._fsp--; @@ -39689,35 +30983,35 @@ public final void rule__ParameterStructMember__Group__4() throws RecognitionExce } return ; } - // $ANTLR end "rule__ParameterStructMember__Group__4" + // $ANTLR end "rule__ParameterStruct__Group_1__1" - // $ANTLR start "rule__ParameterStructMember__Group__4__Impl" - // InternalRos.g:13131:1: rule__ParameterStructMember__Group__4__Impl : ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) ; - public final void rule__ParameterStructMember__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1__1__Impl" + // InternalRosParser.g:10307:1: rule__ParameterStruct__Group_1__1__Impl : ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) ; + public final void rule__ParameterStruct__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13135:1: ( ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) ) - // InternalRos.g:13136:1: ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) + // InternalRosParser.g:10311:1: ( ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) ) + // InternalRosParser.g:10312:1: ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) { - // InternalRos.g:13136:1: ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) - // InternalRos.g:13137:2: ( rule__ParameterStructMember__ValueAssignment_4 ) + // InternalRosParser.g:10312:1: ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) + // InternalRosParser.g:10313:2: ( rule__ParameterStruct__ValueAssignment_1_1 ) { - before(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); - // InternalRos.g:13138:2: ( rule__ParameterStructMember__ValueAssignment_4 ) - // InternalRos.g:13138:3: rule__ParameterStructMember__ValueAssignment_4 + before(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); + // InternalRosParser.g:10314:2: ( rule__ParameterStruct__ValueAssignment_1_1 ) + // InternalRosParser.g:10314:3: rule__ParameterStruct__ValueAssignment_1_1 { pushFollow(FOLLOW_2); - rule__ParameterStructMember__ValueAssignment_4(); + rule__ParameterStruct__ValueAssignment_1_1(); state._fsp--; } - after(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); + after(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); } @@ -39736,60 +31030,28 @@ public final void rule__ParameterStructMember__Group__4__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__ParameterStructMember__Group__4__Impl" + // $ANTLR end "rule__ParameterStruct__Group_1__1__Impl" - // $ANTLR start "rule__ParameterStructMember__Group__5" - // InternalRos.g:13146:1: rule__ParameterStructMember__Group__5 : rule__ParameterStructMember__Group__5__Impl ; - public final void rule__ParameterStructMember__Group__5() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1__2" + // InternalRosParser.g:10322:1: rule__ParameterStruct__Group_1__2 : rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 ; + public final void rule__ParameterStruct__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13150:1: ( rule__ParameterStructMember__Group__5__Impl ) - // InternalRos.g:13151:2: rule__ParameterStructMember__Group__5__Impl + // InternalRosParser.g:10326:1: ( rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 ) + // InternalRosParser.g:10327:2: rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 { - pushFollow(FOLLOW_2); - rule__ParameterStructMember__Group__5__Impl(); + pushFollow(FOLLOW_13); + rule__ParameterStruct__Group_1__2__Impl(); state._fsp--; + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__3(); - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ParameterStructMember__Group__5" - - - // $ANTLR start "rule__ParameterStructMember__Group__5__Impl" - // InternalRos.g:13157:1: rule__ParameterStructMember__Group__5__Impl : ( '}' ) ; - public final void rule__ParameterStructMember__Group__5__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:13161:1: ( ( '}' ) ) - // InternalRos.g:13162:1: ( '}' ) - { - // InternalRos.g:13162:1: ( '}' ) - // InternalRos.g:13163:2: '}' - { - before(grammarAccess.getParameterStructMemberAccess().getRightCurlyBracketKeyword_5()); - match(input,42,FOLLOW_2); - after(grammarAccess.getParameterStructMemberAccess().getRightCurlyBracketKeyword_5()); - - } + state._fsp--; } @@ -39806,73 +31068,53 @@ public final void rule__ParameterStructMember__Group__5__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__ParameterStructMember__Group__5__Impl" + // $ANTLR end "rule__ParameterStruct__Group_1__2" - // $ANTLR start "rule__ParameterStructTypeMember__Group__0" - // InternalRos.g:13173:1: rule__ParameterStructTypeMember__Group__0 : rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 ; - public final void rule__ParameterStructTypeMember__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1__2__Impl" + // InternalRosParser.g:10334:1: rule__ParameterStruct__Group_1__2__Impl : ( ( rule__ParameterStruct__Group_1_2__0 )* ) ; + public final void rule__ParameterStruct__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13177:1: ( rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 ) - // InternalRos.g:13178:2: rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 + // InternalRosParser.g:10338:1: ( ( ( rule__ParameterStruct__Group_1_2__0 )* ) ) + // InternalRosParser.g:10339:1: ( ( rule__ParameterStruct__Group_1_2__0 )* ) { - pushFollow(FOLLOW_48); - rule__ParameterStructTypeMember__Group__0__Impl(); - - state._fsp--; - - pushFollow(FOLLOW_2); - rule__ParameterStructTypeMember__Group__1(); - - state._fsp--; - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + // InternalRosParser.g:10339:1: ( ( rule__ParameterStruct__Group_1_2__0 )* ) + // InternalRosParser.g:10340:2: ( rule__ParameterStruct__Group_1_2__0 )* + { + before(grammarAccess.getParameterStructAccess().getGroup_1_2()); + // InternalRosParser.g:10341:2: ( rule__ParameterStruct__Group_1_2__0 )* + loop59: + do { + int alt59=2; + int LA59_0 = input.LA(1); - } - return ; - } - // $ANTLR end "rule__ParameterStructTypeMember__Group__0" + if ( (LA59_0==Comma) ) { + alt59=1; + } - // $ANTLR start "rule__ParameterStructTypeMember__Group__0__Impl" - // InternalRos.g:13185:1: rule__ParameterStructTypeMember__Group__0__Impl : ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) ; - public final void rule__ParameterStructTypeMember__Group__0__Impl() throws RecognitionException { + switch (alt59) { + case 1 : + // InternalRosParser.g:10341:3: rule__ParameterStruct__Group_1_2__0 + { + pushFollow(FOLLOW_14); + rule__ParameterStruct__Group_1_2__0(); - int stackSize = keepStackSize(); - - try { - // InternalRos.g:13189:1: ( ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) ) - // InternalRos.g:13190:1: ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) - { - // InternalRos.g:13190:1: ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) - // InternalRos.g:13191:2: ( rule__ParameterStructTypeMember__NameAssignment_0 ) - { - before(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); - // InternalRos.g:13192:2: ( rule__ParameterStructTypeMember__NameAssignment_0 ) - // InternalRos.g:13192:3: rule__ParameterStructTypeMember__NameAssignment_0 - { - pushFollow(FOLLOW_2); - rule__ParameterStructTypeMember__NameAssignment_0(); + state._fsp--; - state._fsp--; + } + break; - } + default : + break loop59; + } + } while (true); - after(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); + after(grammarAccess.getParameterStructAccess().getGroup_1_2()); } @@ -39891,21 +31133,21 @@ public final void rule__ParameterStructTypeMember__Group__0__Impl() throws Recog } return ; } - // $ANTLR end "rule__ParameterStructTypeMember__Group__0__Impl" + // $ANTLR end "rule__ParameterStruct__Group_1__2__Impl" - // $ANTLR start "rule__ParameterStructTypeMember__Group__1" - // InternalRos.g:13200:1: rule__ParameterStructTypeMember__Group__1 : rule__ParameterStructTypeMember__Group__1__Impl ; - public final void rule__ParameterStructTypeMember__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1__3" + // InternalRosParser.g:10349:1: rule__ParameterStruct__Group_1__3 : rule__ParameterStruct__Group_1__3__Impl ; + public final void rule__ParameterStruct__Group_1__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13204:1: ( rule__ParameterStructTypeMember__Group__1__Impl ) - // InternalRos.g:13205:2: rule__ParameterStructTypeMember__Group__1__Impl + // InternalRosParser.g:10353:1: ( rule__ParameterStruct__Group_1__3__Impl ) + // InternalRosParser.g:10354:2: rule__ParameterStruct__Group_1__3__Impl { pushFollow(FOLLOW_2); - rule__ParameterStructTypeMember__Group__1__Impl(); + rule__ParameterStruct__Group_1__3__Impl(); state._fsp--; @@ -39924,35 +31166,25 @@ public final void rule__ParameterStructTypeMember__Group__1() throws Recognition } return ; } - // $ANTLR end "rule__ParameterStructTypeMember__Group__1" + // $ANTLR end "rule__ParameterStruct__Group_1__3" - // $ANTLR start "rule__ParameterStructTypeMember__Group__1__Impl" - // InternalRos.g:13211:1: rule__ParameterStructTypeMember__Group__1__Impl : ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) ; - public final void rule__ParameterStructTypeMember__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1__3__Impl" + // InternalRosParser.g:10360:1: rule__ParameterStruct__Group_1__3__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterStruct__Group_1__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13215:1: ( ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) ) - // InternalRos.g:13216:1: ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) - { - // InternalRos.g:13216:1: ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) - // InternalRos.g:13217:2: ( rule__ParameterStructTypeMember__TypeAssignment_1 ) + // InternalRosParser.g:10364:1: ( ( RightSquareBracket ) ) + // InternalRosParser.g:10365:1: ( RightSquareBracket ) { - before(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); - // InternalRos.g:13218:2: ( rule__ParameterStructTypeMember__TypeAssignment_1 ) - // InternalRos.g:13218:3: rule__ParameterStructTypeMember__TypeAssignment_1 + // InternalRosParser.g:10365:1: ( RightSquareBracket ) + // InternalRosParser.g:10366:2: RightSquareBracket { - pushFollow(FOLLOW_2); - rule__ParameterStructTypeMember__TypeAssignment_1(); - - state._fsp--; - - - } - - after(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); + before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); } @@ -39971,26 +31203,26 @@ public final void rule__ParameterStructTypeMember__Group__1__Impl() throws Recog } return ; } - // $ANTLR end "rule__ParameterStructTypeMember__Group__1__Impl" + // $ANTLR end "rule__ParameterStruct__Group_1__3__Impl" - // $ANTLR start "rule__MessagePart__Group__0" - // InternalRos.g:13227:1: rule__MessagePart__Group__0 : rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 ; - public final void rule__MessagePart__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1_2__0" + // InternalRosParser.g:10376:1: rule__ParameterStruct__Group_1_2__0 : rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 ; + public final void rule__ParameterStruct__Group_1_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13231:1: ( rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 ) - // InternalRos.g:13232:2: rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 + // InternalRosParser.g:10380:1: ( rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 ) + // InternalRosParser.g:10381:2: rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 { - pushFollow(FOLLOW_69); - rule__MessagePart__Group__0__Impl(); + pushFollow(FOLLOW_11); + rule__ParameterStruct__Group_1_2__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__MessagePart__Group__1(); + rule__ParameterStruct__Group_1_2__1(); state._fsp--; @@ -40009,35 +31241,25 @@ public final void rule__MessagePart__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__MessagePart__Group__0" + // $ANTLR end "rule__ParameterStruct__Group_1_2__0" - // $ANTLR start "rule__MessagePart__Group__0__Impl" - // InternalRos.g:13239:1: rule__MessagePart__Group__0__Impl : ( ( rule__MessagePart__TypeAssignment_0 ) ) ; - public final void rule__MessagePart__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1_2__0__Impl" + // InternalRosParser.g:10388:1: rule__ParameterStruct__Group_1_2__0__Impl : ( Comma ) ; + public final void rule__ParameterStruct__Group_1_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13243:1: ( ( ( rule__MessagePart__TypeAssignment_0 ) ) ) - // InternalRos.g:13244:1: ( ( rule__MessagePart__TypeAssignment_0 ) ) - { - // InternalRos.g:13244:1: ( ( rule__MessagePart__TypeAssignment_0 ) ) - // InternalRos.g:13245:2: ( rule__MessagePart__TypeAssignment_0 ) + // InternalRosParser.g:10392:1: ( ( Comma ) ) + // InternalRosParser.g:10393:1: ( Comma ) { - before(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); - // InternalRos.g:13246:2: ( rule__MessagePart__TypeAssignment_0 ) - // InternalRos.g:13246:3: rule__MessagePart__TypeAssignment_0 + // InternalRosParser.g:10393:1: ( Comma ) + // InternalRosParser.g:10394:2: Comma { - pushFollow(FOLLOW_2); - rule__MessagePart__TypeAssignment_0(); - - state._fsp--; - - - } - - after(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); + before(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); } @@ -40056,21 +31278,26 @@ public final void rule__MessagePart__Group__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__MessagePart__Group__0__Impl" + // $ANTLR end "rule__ParameterStruct__Group_1_2__0__Impl" - // $ANTLR start "rule__MessagePart__Group__1" - // InternalRos.g:13254:1: rule__MessagePart__Group__1 : rule__MessagePart__Group__1__Impl ; - public final void rule__MessagePart__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1_2__1" + // InternalRosParser.g:10403:1: rule__ParameterStruct__Group_1_2__1 : rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 ; + public final void rule__ParameterStruct__Group_1_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13258:1: ( rule__MessagePart__Group__1__Impl ) - // InternalRos.g:13259:2: rule__MessagePart__Group__1__Impl + // InternalRosParser.g:10407:1: ( rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 ) + // InternalRosParser.g:10408:2: rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 { + pushFollow(FOLLOW_59); + rule__ParameterStruct__Group_1_2__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__MessagePart__Group__1__Impl(); + rule__ParameterStruct__Group_1_2__2(); state._fsp--; @@ -40089,35 +31316,25 @@ public final void rule__MessagePart__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__MessagePart__Group__1" + // $ANTLR end "rule__ParameterStruct__Group_1_2__1" - // $ANTLR start "rule__MessagePart__Group__1__Impl" - // InternalRos.g:13265:1: rule__MessagePart__Group__1__Impl : ( ( rule__MessagePart__DataAssignment_1 ) ) ; - public final void rule__MessagePart__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1_2__1__Impl" + // InternalRosParser.g:10415:1: rule__ParameterStruct__Group_1_2__1__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterStruct__Group_1_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13269:1: ( ( ( rule__MessagePart__DataAssignment_1 ) ) ) - // InternalRos.g:13270:1: ( ( rule__MessagePart__DataAssignment_1 ) ) - { - // InternalRos.g:13270:1: ( ( rule__MessagePart__DataAssignment_1 ) ) - // InternalRos.g:13271:2: ( rule__MessagePart__DataAssignment_1 ) + // InternalRosParser.g:10419:1: ( ( LeftSquareBracket ) ) + // InternalRosParser.g:10420:1: ( LeftSquareBracket ) { - before(grammarAccess.getMessagePartAccess().getDataAssignment_1()); - // InternalRos.g:13272:2: ( rule__MessagePart__DataAssignment_1 ) - // InternalRos.g:13272:3: rule__MessagePart__DataAssignment_1 + // InternalRosParser.g:10420:1: ( LeftSquareBracket ) + // InternalRosParser.g:10421:2: LeftSquareBracket { - pushFollow(FOLLOW_2); - rule__MessagePart__DataAssignment_1(); - - state._fsp--; - - - } - - after(grammarAccess.getMessagePartAccess().getDataAssignment_1()); + before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); } @@ -40136,26 +31353,26 @@ public final void rule__MessagePart__Group__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__MessagePart__Group__1__Impl" + // $ANTLR end "rule__ParameterStruct__Group_1_2__1__Impl" - // $ANTLR start "rule__Bool__Group__0" - // InternalRos.g:13281:1: rule__Bool__Group__0 : rule__Bool__Group__0__Impl rule__Bool__Group__1 ; - public final void rule__Bool__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1_2__2" + // InternalRosParser.g:10430:1: rule__ParameterStruct__Group_1_2__2 : rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 ; + public final void rule__ParameterStruct__Group_1_2__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13285:1: ( rule__Bool__Group__0__Impl rule__Bool__Group__1 ) - // InternalRos.g:13286:2: rule__Bool__Group__0__Impl rule__Bool__Group__1 + // InternalRosParser.g:10434:1: ( rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 ) + // InternalRosParser.g:10435:2: rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 { - pushFollow(FOLLOW_70); - rule__Bool__Group__0__Impl(); + pushFollow(FOLLOW_60); + rule__ParameterStruct__Group_1_2__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Bool__Group__1(); + rule__ParameterStruct__Group_1_2__3(); state._fsp--; @@ -40174,29 +31391,35 @@ public final void rule__Bool__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Bool__Group__0" + // $ANTLR end "rule__ParameterStruct__Group_1_2__2" - // $ANTLR start "rule__Bool__Group__0__Impl" - // InternalRos.g:13293:1: rule__Bool__Group__0__Impl : ( () ) ; - public final void rule__Bool__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1_2__2__Impl" + // InternalRosParser.g:10442:1: rule__ParameterStruct__Group_1_2__2__Impl : ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) ; + public final void rule__ParameterStruct__Group_1_2__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13297:1: ( ( () ) ) - // InternalRos.g:13298:1: ( () ) + // InternalRosParser.g:10446:1: ( ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) ) + // InternalRosParser.g:10447:1: ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) { - // InternalRos.g:13298:1: ( () ) - // InternalRos.g:13299:2: () + // InternalRosParser.g:10447:1: ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) + // InternalRosParser.g:10448:2: ( rule__ParameterStruct__ValueAssignment_1_2_2 ) { - before(grammarAccess.getBoolAccess().getBoolAction_0()); - // InternalRos.g:13300:2: () - // InternalRos.g:13300:3: + before(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); + // InternalRosParser.g:10449:2: ( rule__ParameterStruct__ValueAssignment_1_2_2 ) + // InternalRosParser.g:10449:3: rule__ParameterStruct__ValueAssignment_1_2_2 { + pushFollow(FOLLOW_2); + rule__ParameterStruct__ValueAssignment_1_2_2(); + + state._fsp--; + + } - after(grammarAccess.getBoolAccess().getBoolAction_0()); + after(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); } @@ -40204,6 +31427,10 @@ public final void rule__Bool__Group__0__Impl() throws RecognitionException { } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -40211,21 +31438,21 @@ public final void rule__Bool__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Bool__Group__0__Impl" + // $ANTLR end "rule__ParameterStruct__Group_1_2__2__Impl" - // $ANTLR start "rule__Bool__Group__1" - // InternalRos.g:13308:1: rule__Bool__Group__1 : rule__Bool__Group__1__Impl ; - public final void rule__Bool__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1_2__3" + // InternalRosParser.g:10457:1: rule__ParameterStruct__Group_1_2__3 : rule__ParameterStruct__Group_1_2__3__Impl ; + public final void rule__ParameterStruct__Group_1_2__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13312:1: ( rule__Bool__Group__1__Impl ) - // InternalRos.g:13313:2: rule__Bool__Group__1__Impl + // InternalRosParser.g:10461:1: ( rule__ParameterStruct__Group_1_2__3__Impl ) + // InternalRosParser.g:10462:2: rule__ParameterStruct__Group_1_2__3__Impl { pushFollow(FOLLOW_2); - rule__Bool__Group__1__Impl(); + rule__ParameterStruct__Group_1_2__3__Impl(); state._fsp--; @@ -40244,25 +31471,25 @@ public final void rule__Bool__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Bool__Group__1" + // $ANTLR end "rule__ParameterStruct__Group_1_2__3" - // $ANTLR start "rule__Bool__Group__1__Impl" - // InternalRos.g:13319:1: rule__Bool__Group__1__Impl : ( 'bool' ) ; - public final void rule__Bool__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStruct__Group_1_2__3__Impl" + // InternalRosParser.g:10468:1: rule__ParameterStruct__Group_1_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterStruct__Group_1_2__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13323:1: ( ( 'bool' ) ) - // InternalRos.g:13324:1: ( 'bool' ) + // InternalRosParser.g:10472:1: ( ( RightSquareBracket ) ) + // InternalRosParser.g:10473:1: ( RightSquareBracket ) { - // InternalRos.g:13324:1: ( 'bool' ) - // InternalRos.g:13325:2: 'bool' + // InternalRosParser.g:10473:1: ( RightSquareBracket ) + // InternalRosParser.g:10474:2: RightSquareBracket { - before(grammarAccess.getBoolAccess().getBoolKeyword_1()); - match(input,87,FOLLOW_2); - after(grammarAccess.getBoolAccess().getBoolKeyword_1()); + before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); } @@ -40281,26 +31508,26 @@ public final void rule__Bool__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Bool__Group__1__Impl" - + // $ANTLR end "rule__ParameterStruct__Group_1_2__3__Impl" - // $ANTLR start "rule__Int8__Group__0" - // InternalRos.g:13335:1: rule__Int8__Group__0 : rule__Int8__Group__0__Impl rule__Int8__Group__1 ; - public final void rule__Int8__Group__0() throws RecognitionException { + + // $ANTLR start "rule__ParameterStructMember__Group__0" + // InternalRosParser.g:10484:1: rule__ParameterStructMember__Group__0 : rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 ; + public final void rule__ParameterStructMember__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13339:1: ( rule__Int8__Group__0__Impl rule__Int8__Group__1 ) - // InternalRos.g:13340:2: rule__Int8__Group__0__Impl rule__Int8__Group__1 + // InternalRosParser.g:10488:1: ( rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 ) + // InternalRosParser.g:10489:2: rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 { - pushFollow(FOLLOW_71); - rule__Int8__Group__0__Impl(); + pushFollow(FOLLOW_8); + rule__ParameterStructMember__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Int8__Group__1(); + rule__ParameterStructMember__Group__1(); state._fsp--; @@ -40319,29 +31546,25 @@ public final void rule__Int8__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int8__Group__0" + // $ANTLR end "rule__ParameterStructMember__Group__0" - // $ANTLR start "rule__Int8__Group__0__Impl" - // InternalRos.g:13347:1: rule__Int8__Group__0__Impl : ( () ) ; - public final void rule__Int8__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructMember__Group__0__Impl" + // InternalRosParser.g:10496:1: rule__ParameterStructMember__Group__0__Impl : ( ParameterStructMember ) ; + public final void rule__ParameterStructMember__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13351:1: ( ( () ) ) - // InternalRos.g:13352:1: ( () ) - { - // InternalRos.g:13352:1: ( () ) - // InternalRos.g:13353:2: () + // InternalRosParser.g:10500:1: ( ( ParameterStructMember ) ) + // InternalRosParser.g:10501:1: ( ParameterStructMember ) { - before(grammarAccess.getInt8Access().getInt8Action_0()); - // InternalRos.g:13354:2: () - // InternalRos.g:13354:3: + // InternalRosParser.g:10501:1: ( ParameterStructMember ) + // InternalRosParser.g:10502:2: ParameterStructMember { - } - - after(grammarAccess.getInt8Access().getInt8Action_0()); + before(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); + match(input,ParameterStructMember,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); } @@ -40349,6 +31572,10 @@ public final void rule__Int8__Group__0__Impl() throws RecognitionException { } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -40356,21 +31583,26 @@ public final void rule__Int8__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int8__Group__0__Impl" + // $ANTLR end "rule__ParameterStructMember__Group__0__Impl" - // $ANTLR start "rule__Int8__Group__1" - // InternalRos.g:13362:1: rule__Int8__Group__1 : rule__Int8__Group__1__Impl ; - public final void rule__Int8__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStructMember__Group__1" + // InternalRosParser.g:10511:1: rule__ParameterStructMember__Group__1 : rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 ; + public final void rule__ParameterStructMember__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13366:1: ( rule__Int8__Group__1__Impl ) - // InternalRos.g:13367:2: rule__Int8__Group__1__Impl + // InternalRosParser.g:10515:1: ( rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 ) + // InternalRosParser.g:10516:2: rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 { + pushFollow(FOLLOW_5); + rule__ParameterStructMember__Group__1__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Int8__Group__1__Impl(); + rule__ParameterStructMember__Group__2(); state._fsp--; @@ -40389,25 +31621,35 @@ public final void rule__Int8__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int8__Group__1" + // $ANTLR end "rule__ParameterStructMember__Group__1" - // $ANTLR start "rule__Int8__Group__1__Impl" - // InternalRos.g:13373:1: rule__Int8__Group__1__Impl : ( 'int8' ) ; - public final void rule__Int8__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructMember__Group__1__Impl" + // InternalRosParser.g:10523:1: rule__ParameterStructMember__Group__1__Impl : ( ( rule__ParameterStructMember__NameAssignment_1 ) ) ; + public final void rule__ParameterStructMember__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13377:1: ( ( 'int8' ) ) - // InternalRos.g:13378:1: ( 'int8' ) + // InternalRosParser.g:10527:1: ( ( ( rule__ParameterStructMember__NameAssignment_1 ) ) ) + // InternalRosParser.g:10528:1: ( ( rule__ParameterStructMember__NameAssignment_1 ) ) { - // InternalRos.g:13378:1: ( 'int8' ) - // InternalRos.g:13379:2: 'int8' + // InternalRosParser.g:10528:1: ( ( rule__ParameterStructMember__NameAssignment_1 ) ) + // InternalRosParser.g:10529:2: ( rule__ParameterStructMember__NameAssignment_1 ) { - before(grammarAccess.getInt8Access().getInt8Keyword_1()); - match(input,88,FOLLOW_2); - after(grammarAccess.getInt8Access().getInt8Keyword_1()); + before(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); + // InternalRosParser.g:10530:2: ( rule__ParameterStructMember__NameAssignment_1 ) + // InternalRosParser.g:10530:3: rule__ParameterStructMember__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStructMember__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); } @@ -40426,26 +31668,26 @@ public final void rule__Int8__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int8__Group__1__Impl" + // $ANTLR end "rule__ParameterStructMember__Group__1__Impl" - // $ANTLR start "rule__Uint8__Group__0" - // InternalRos.g:13389:1: rule__Uint8__Group__0 : rule__Uint8__Group__0__Impl rule__Uint8__Group__1 ; - public final void rule__Uint8__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterStructMember__Group__2" + // InternalRosParser.g:10538:1: rule__ParameterStructMember__Group__2 : rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 ; + public final void rule__ParameterStructMember__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13393:1: ( rule__Uint8__Group__0__Impl rule__Uint8__Group__1 ) - // InternalRos.g:13394:2: rule__Uint8__Group__0__Impl rule__Uint8__Group__1 + // InternalRosParser.g:10542:1: ( rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 ) + // InternalRosParser.g:10543:2: rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 { - pushFollow(FOLLOW_72); - rule__Uint8__Group__0__Impl(); + pushFollow(FOLLOW_6); + rule__ParameterStructMember__Group__2__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Uint8__Group__1(); + rule__ParameterStructMember__Group__3(); state._fsp--; @@ -40464,29 +31706,25 @@ public final void rule__Uint8__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint8__Group__0" + // $ANTLR end "rule__ParameterStructMember__Group__2" - // $ANTLR start "rule__Uint8__Group__0__Impl" - // InternalRos.g:13401:1: rule__Uint8__Group__0__Impl : ( () ) ; - public final void rule__Uint8__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructMember__Group__2__Impl" + // InternalRosParser.g:10550:1: rule__ParameterStructMember__Group__2__Impl : ( Colon ) ; + public final void rule__ParameterStructMember__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13405:1: ( ( () ) ) - // InternalRos.g:13406:1: ( () ) + // InternalRosParser.g:10554:1: ( ( Colon ) ) + // InternalRosParser.g:10555:1: ( Colon ) { - // InternalRos.g:13406:1: ( () ) - // InternalRos.g:13407:2: () + // InternalRosParser.g:10555:1: ( Colon ) + // InternalRosParser.g:10556:2: Colon { - before(grammarAccess.getUint8Access().getUint8Action_0()); - // InternalRos.g:13408:2: () - // InternalRos.g:13408:3: - { - } - - after(grammarAccess.getUint8Access().getUint8Action_0()); + before(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); } @@ -40494,6 +31732,10 @@ public final void rule__Uint8__Group__0__Impl() throws RecognitionException { } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -40501,21 +31743,26 @@ public final void rule__Uint8__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint8__Group__0__Impl" + // $ANTLR end "rule__ParameterStructMember__Group__2__Impl" - // $ANTLR start "rule__Uint8__Group__1" - // InternalRos.g:13416:1: rule__Uint8__Group__1 : rule__Uint8__Group__1__Impl ; - public final void rule__Uint8__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStructMember__Group__3" + // InternalRosParser.g:10565:1: rule__ParameterStructMember__Group__3 : rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 ; + public final void rule__ParameterStructMember__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13420:1: ( rule__Uint8__Group__1__Impl ) - // InternalRos.g:13421:2: rule__Uint8__Group__1__Impl + // InternalRosParser.g:10569:1: ( rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 ) + // InternalRosParser.g:10570:2: rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 { + pushFollow(FOLLOW_56); + rule__ParameterStructMember__Group__3__Impl(); + + state._fsp--; + pushFollow(FOLLOW_2); - rule__Uint8__Group__1__Impl(); + rule__ParameterStructMember__Group__4(); state._fsp--; @@ -40534,25 +31781,25 @@ public final void rule__Uint8__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint8__Group__1" + // $ANTLR end "rule__ParameterStructMember__Group__3" - // $ANTLR start "rule__Uint8__Group__1__Impl" - // InternalRos.g:13427:1: rule__Uint8__Group__1__Impl : ( 'uint8' ) ; - public final void rule__Uint8__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructMember__Group__3__Impl" + // InternalRosParser.g:10577:1: rule__ParameterStructMember__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ParameterStructMember__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13431:1: ( ( 'uint8' ) ) - // InternalRos.g:13432:1: ( 'uint8' ) + // InternalRosParser.g:10581:1: ( ( RULE_BEGIN ) ) + // InternalRosParser.g:10582:1: ( RULE_BEGIN ) { - // InternalRos.g:13432:1: ( 'uint8' ) - // InternalRos.g:13433:2: 'uint8' + // InternalRosParser.g:10582:1: ( RULE_BEGIN ) + // InternalRosParser.g:10583:2: RULE_BEGIN { - before(grammarAccess.getUint8Access().getUint8Keyword_1()); - match(input,89,FOLLOW_2); - after(grammarAccess.getUint8Access().getUint8Keyword_1()); + before(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); } @@ -40571,26 +31818,26 @@ public final void rule__Uint8__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint8__Group__1__Impl" + // $ANTLR end "rule__ParameterStructMember__Group__3__Impl" - // $ANTLR start "rule__Int16__Group__0" - // InternalRos.g:13443:1: rule__Int16__Group__0 : rule__Int16__Group__0__Impl rule__Int16__Group__1 ; - public final void rule__Int16__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterStructMember__Group__4" + // InternalRosParser.g:10592:1: rule__ParameterStructMember__Group__4 : rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 ; + public final void rule__ParameterStructMember__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13447:1: ( rule__Int16__Group__0__Impl rule__Int16__Group__1 ) - // InternalRos.g:13448:2: rule__Int16__Group__0__Impl rule__Int16__Group__1 + // InternalRosParser.g:10596:1: ( rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 ) + // InternalRosParser.g:10597:2: rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 { - pushFollow(FOLLOW_73); - rule__Int16__Group__0__Impl(); + pushFollow(FOLLOW_25); + rule__ParameterStructMember__Group__4__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Int16__Group__1(); + rule__ParameterStructMember__Group__5(); state._fsp--; @@ -40609,29 +31856,35 @@ public final void rule__Int16__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int16__Group__0" + // $ANTLR end "rule__ParameterStructMember__Group__4" - // $ANTLR start "rule__Int16__Group__0__Impl" - // InternalRos.g:13455:1: rule__Int16__Group__0__Impl : ( () ) ; - public final void rule__Int16__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructMember__Group__4__Impl" + // InternalRosParser.g:10604:1: rule__ParameterStructMember__Group__4__Impl : ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) ; + public final void rule__ParameterStructMember__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13459:1: ( ( () ) ) - // InternalRos.g:13460:1: ( () ) + // InternalRosParser.g:10608:1: ( ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) ) + // InternalRosParser.g:10609:1: ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) { - // InternalRos.g:13460:1: ( () ) - // InternalRos.g:13461:2: () + // InternalRosParser.g:10609:1: ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) + // InternalRosParser.g:10610:2: ( rule__ParameterStructMember__ValueAssignment_4 ) { - before(grammarAccess.getInt16Access().getInt16Action_0()); - // InternalRos.g:13462:2: () - // InternalRos.g:13462:3: + before(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); + // InternalRosParser.g:10611:2: ( rule__ParameterStructMember__ValueAssignment_4 ) + // InternalRosParser.g:10611:3: rule__ParameterStructMember__ValueAssignment_4 { + pushFollow(FOLLOW_2); + rule__ParameterStructMember__ValueAssignment_4(); + + state._fsp--; + + } - after(grammarAccess.getInt16Access().getInt16Action_0()); + after(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); } @@ -40639,6 +31892,10 @@ public final void rule__Int16__Group__0__Impl() throws RecognitionException { } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -40646,21 +31903,21 @@ public final void rule__Int16__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int16__Group__0__Impl" + // $ANTLR end "rule__ParameterStructMember__Group__4__Impl" - // $ANTLR start "rule__Int16__Group__1" - // InternalRos.g:13470:1: rule__Int16__Group__1 : rule__Int16__Group__1__Impl ; - public final void rule__Int16__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStructMember__Group__5" + // InternalRosParser.g:10619:1: rule__ParameterStructMember__Group__5 : rule__ParameterStructMember__Group__5__Impl ; + public final void rule__ParameterStructMember__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13474:1: ( rule__Int16__Group__1__Impl ) - // InternalRos.g:13475:2: rule__Int16__Group__1__Impl + // InternalRosParser.g:10623:1: ( rule__ParameterStructMember__Group__5__Impl ) + // InternalRosParser.g:10624:2: rule__ParameterStructMember__Group__5__Impl { pushFollow(FOLLOW_2); - rule__Int16__Group__1__Impl(); + rule__ParameterStructMember__Group__5__Impl(); state._fsp--; @@ -40679,25 +31936,25 @@ public final void rule__Int16__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int16__Group__1" + // $ANTLR end "rule__ParameterStructMember__Group__5" - // $ANTLR start "rule__Int16__Group__1__Impl" - // InternalRos.g:13481:1: rule__Int16__Group__1__Impl : ( 'int16' ) ; - public final void rule__Int16__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructMember__Group__5__Impl" + // InternalRosParser.g:10630:1: rule__ParameterStructMember__Group__5__Impl : ( RULE_END ) ; + public final void rule__ParameterStructMember__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13485:1: ( ( 'int16' ) ) - // InternalRos.g:13486:1: ( 'int16' ) + // InternalRosParser.g:10634:1: ( ( RULE_END ) ) + // InternalRosParser.g:10635:1: ( RULE_END ) { - // InternalRos.g:13486:1: ( 'int16' ) - // InternalRos.g:13487:2: 'int16' + // InternalRosParser.g:10635:1: ( RULE_END ) + // InternalRosParser.g:10636:2: RULE_END { - before(grammarAccess.getInt16Access().getInt16Keyword_1()); - match(input,90,FOLLOW_2); - after(grammarAccess.getInt16Access().getInt16Keyword_1()); + before(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); } @@ -40716,26 +31973,26 @@ public final void rule__Int16__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int16__Group__1__Impl" + // $ANTLR end "rule__ParameterStructMember__Group__5__Impl" - // $ANTLR start "rule__Uint16__Group__0" - // InternalRos.g:13497:1: rule__Uint16__Group__0 : rule__Uint16__Group__0__Impl rule__Uint16__Group__1 ; - public final void rule__Uint16__Group__0() throws RecognitionException { + // $ANTLR start "rule__ParameterStructTypeMember__Group__0" + // InternalRosParser.g:10646:1: rule__ParameterStructTypeMember__Group__0 : rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 ; + public final void rule__ParameterStructTypeMember__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13501:1: ( rule__Uint16__Group__0__Impl rule__Uint16__Group__1 ) - // InternalRos.g:13502:2: rule__Uint16__Group__0__Impl rule__Uint16__Group__1 + // InternalRosParser.g:10650:1: ( rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 ) + // InternalRosParser.g:10651:2: rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 { - pushFollow(FOLLOW_74); - rule__Uint16__Group__0__Impl(); + pushFollow(FOLLOW_41); + rule__ParameterStructTypeMember__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Uint16__Group__1(); + rule__ParameterStructTypeMember__Group__1(); state._fsp--; @@ -40754,29 +32011,35 @@ public final void rule__Uint16__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint16__Group__0" + // $ANTLR end "rule__ParameterStructTypeMember__Group__0" - // $ANTLR start "rule__Uint16__Group__0__Impl" - // InternalRos.g:13509:1: rule__Uint16__Group__0__Impl : ( () ) ; - public final void rule__Uint16__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructTypeMember__Group__0__Impl" + // InternalRosParser.g:10658:1: rule__ParameterStructTypeMember__Group__0__Impl : ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) ; + public final void rule__ParameterStructTypeMember__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13513:1: ( ( () ) ) - // InternalRos.g:13514:1: ( () ) + // InternalRosParser.g:10662:1: ( ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) ) + // InternalRosParser.g:10663:1: ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) { - // InternalRos.g:13514:1: ( () ) - // InternalRos.g:13515:2: () + // InternalRosParser.g:10663:1: ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) + // InternalRosParser.g:10664:2: ( rule__ParameterStructTypeMember__NameAssignment_0 ) { - before(grammarAccess.getUint16Access().getUint16Action_0()); - // InternalRos.g:13516:2: () - // InternalRos.g:13516:3: + before(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); + // InternalRosParser.g:10665:2: ( rule__ParameterStructTypeMember__NameAssignment_0 ) + // InternalRosParser.g:10665:3: rule__ParameterStructTypeMember__NameAssignment_0 { + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__NameAssignment_0(); + + state._fsp--; + + } - after(grammarAccess.getUint16Access().getUint16Action_0()); + after(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); } @@ -40784,6 +32047,10 @@ public final void rule__Uint16__Group__0__Impl() throws RecognitionException { } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -40791,21 +32058,21 @@ public final void rule__Uint16__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint16__Group__0__Impl" + // $ANTLR end "rule__ParameterStructTypeMember__Group__0__Impl" - // $ANTLR start "rule__Uint16__Group__1" - // InternalRos.g:13524:1: rule__Uint16__Group__1 : rule__Uint16__Group__1__Impl ; - public final void rule__Uint16__Group__1() throws RecognitionException { + // $ANTLR start "rule__ParameterStructTypeMember__Group__1" + // InternalRosParser.g:10673:1: rule__ParameterStructTypeMember__Group__1 : rule__ParameterStructTypeMember__Group__1__Impl ; + public final void rule__ParameterStructTypeMember__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13528:1: ( rule__Uint16__Group__1__Impl ) - // InternalRos.g:13529:2: rule__Uint16__Group__1__Impl + // InternalRosParser.g:10677:1: ( rule__ParameterStructTypeMember__Group__1__Impl ) + // InternalRosParser.g:10678:2: rule__ParameterStructTypeMember__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Uint16__Group__1__Impl(); + rule__ParameterStructTypeMember__Group__1__Impl(); state._fsp--; @@ -40824,25 +32091,35 @@ public final void rule__Uint16__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint16__Group__1" + // $ANTLR end "rule__ParameterStructTypeMember__Group__1" - // $ANTLR start "rule__Uint16__Group__1__Impl" - // InternalRos.g:13535:1: rule__Uint16__Group__1__Impl : ( 'uint16' ) ; - public final void rule__Uint16__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParameterStructTypeMember__Group__1__Impl" + // InternalRosParser.g:10684:1: rule__ParameterStructTypeMember__Group__1__Impl : ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) ; + public final void rule__ParameterStructTypeMember__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13539:1: ( ( 'uint16' ) ) - // InternalRos.g:13540:1: ( 'uint16' ) + // InternalRosParser.g:10688:1: ( ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) ) + // InternalRosParser.g:10689:1: ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) { - // InternalRos.g:13540:1: ( 'uint16' ) - // InternalRos.g:13541:2: 'uint16' + // InternalRosParser.g:10689:1: ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) + // InternalRosParser.g:10690:2: ( rule__ParameterStructTypeMember__TypeAssignment_1 ) { - before(grammarAccess.getUint16Access().getUint16Keyword_1()); - match(input,91,FOLLOW_2); - after(grammarAccess.getUint16Access().getUint16Keyword_1()); + before(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); + // InternalRosParser.g:10691:2: ( rule__ParameterStructTypeMember__TypeAssignment_1 ) + // InternalRosParser.g:10691:3: rule__ParameterStructTypeMember__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__TypeAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); } @@ -40861,26 +32138,26 @@ public final void rule__Uint16__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint16__Group__1__Impl" + // $ANTLR end "rule__ParameterStructTypeMember__Group__1__Impl" - // $ANTLR start "rule__Int32__Group__0" - // InternalRos.g:13551:1: rule__Int32__Group__0 : rule__Int32__Group__0__Impl rule__Int32__Group__1 ; - public final void rule__Int32__Group__0() throws RecognitionException { + // $ANTLR start "rule__MessagePart__Group__0" + // InternalRosParser.g:10700:1: rule__MessagePart__Group__0 : rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 ; + public final void rule__MessagePart__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13555:1: ( rule__Int32__Group__0__Impl rule__Int32__Group__1 ) - // InternalRos.g:13556:2: rule__Int32__Group__0__Impl rule__Int32__Group__1 + // InternalRosParser.g:10704:1: ( rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 ) + // InternalRosParser.g:10705:2: rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 { - pushFollow(FOLLOW_75); - rule__Int32__Group__0__Impl(); + pushFollow(FOLLOW_61); + rule__MessagePart__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Int32__Group__1(); + rule__MessagePart__Group__1(); state._fsp--; @@ -40899,29 +32176,35 @@ public final void rule__Int32__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int32__Group__0" + // $ANTLR end "rule__MessagePart__Group__0" - // $ANTLR start "rule__Int32__Group__0__Impl" - // InternalRos.g:13563:1: rule__Int32__Group__0__Impl : ( () ) ; - public final void rule__Int32__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__MessagePart__Group__0__Impl" + // InternalRosParser.g:10712:1: rule__MessagePart__Group__0__Impl : ( ( rule__MessagePart__TypeAssignment_0 ) ) ; + public final void rule__MessagePart__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13567:1: ( ( () ) ) - // InternalRos.g:13568:1: ( () ) + // InternalRosParser.g:10716:1: ( ( ( rule__MessagePart__TypeAssignment_0 ) ) ) + // InternalRosParser.g:10717:1: ( ( rule__MessagePart__TypeAssignment_0 ) ) { - // InternalRos.g:13568:1: ( () ) - // InternalRos.g:13569:2: () + // InternalRosParser.g:10717:1: ( ( rule__MessagePart__TypeAssignment_0 ) ) + // InternalRosParser.g:10718:2: ( rule__MessagePart__TypeAssignment_0 ) { - before(grammarAccess.getInt32Access().getInt32Action_0()); - // InternalRos.g:13570:2: () - // InternalRos.g:13570:3: + before(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); + // InternalRosParser.g:10719:2: ( rule__MessagePart__TypeAssignment_0 ) + // InternalRosParser.g:10719:3: rule__MessagePart__TypeAssignment_0 { + pushFollow(FOLLOW_2); + rule__MessagePart__TypeAssignment_0(); + + state._fsp--; + + } - after(grammarAccess.getInt32Access().getInt32Action_0()); + after(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); } @@ -40929,6 +32212,10 @@ public final void rule__Int32__Group__0__Impl() throws RecognitionException { } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -40936,21 +32223,21 @@ public final void rule__Int32__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int32__Group__0__Impl" + // $ANTLR end "rule__MessagePart__Group__0__Impl" - // $ANTLR start "rule__Int32__Group__1" - // InternalRos.g:13578:1: rule__Int32__Group__1 : rule__Int32__Group__1__Impl ; - public final void rule__Int32__Group__1() throws RecognitionException { + // $ANTLR start "rule__MessagePart__Group__1" + // InternalRosParser.g:10727:1: rule__MessagePart__Group__1 : rule__MessagePart__Group__1__Impl ; + public final void rule__MessagePart__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13582:1: ( rule__Int32__Group__1__Impl ) - // InternalRos.g:13583:2: rule__Int32__Group__1__Impl + // InternalRosParser.g:10731:1: ( rule__MessagePart__Group__1__Impl ) + // InternalRosParser.g:10732:2: rule__MessagePart__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Int32__Group__1__Impl(); + rule__MessagePart__Group__1__Impl(); state._fsp--; @@ -40969,25 +32256,35 @@ public final void rule__Int32__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int32__Group__1" + // $ANTLR end "rule__MessagePart__Group__1" - // $ANTLR start "rule__Int32__Group__1__Impl" - // InternalRos.g:13589:1: rule__Int32__Group__1__Impl : ( 'int32' ) ; - public final void rule__Int32__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__MessagePart__Group__1__Impl" + // InternalRosParser.g:10738:1: rule__MessagePart__Group__1__Impl : ( ( rule__MessagePart__DataAssignment_1 ) ) ; + public final void rule__MessagePart__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13593:1: ( ( 'int32' ) ) - // InternalRos.g:13594:1: ( 'int32' ) + // InternalRosParser.g:10742:1: ( ( ( rule__MessagePart__DataAssignment_1 ) ) ) + // InternalRosParser.g:10743:1: ( ( rule__MessagePart__DataAssignment_1 ) ) { - // InternalRos.g:13594:1: ( 'int32' ) - // InternalRos.g:13595:2: 'int32' + // InternalRosParser.g:10743:1: ( ( rule__MessagePart__DataAssignment_1 ) ) + // InternalRosParser.g:10744:2: ( rule__MessagePart__DataAssignment_1 ) { - before(grammarAccess.getInt32Access().getInt32Keyword_1()); - match(input,92,FOLLOW_2); - after(grammarAccess.getInt32Access().getInt32Keyword_1()); + before(grammarAccess.getMessagePartAccess().getDataAssignment_1()); + // InternalRosParser.g:10745:2: ( rule__MessagePart__DataAssignment_1 ) + // InternalRosParser.g:10745:3: rule__MessagePart__DataAssignment_1 + { + pushFollow(FOLLOW_2); + rule__MessagePart__DataAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getMessagePartAccess().getDataAssignment_1()); } @@ -41006,26 +32303,26 @@ public final void rule__Int32__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int32__Group__1__Impl" + // $ANTLR end "rule__MessagePart__Group__1__Impl" - // $ANTLR start "rule__Uint32__Group__0" - // InternalRos.g:13605:1: rule__Uint32__Group__0 : rule__Uint32__Group__0__Impl rule__Uint32__Group__1 ; - public final void rule__Uint32__Group__0() throws RecognitionException { + // $ANTLR start "rule__Bool__Group__0" + // InternalRosParser.g:10754:1: rule__Bool__Group__0 : rule__Bool__Group__0__Impl rule__Bool__Group__1 ; + public final void rule__Bool__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13609:1: ( rule__Uint32__Group__0__Impl rule__Uint32__Group__1 ) - // InternalRos.g:13610:2: rule__Uint32__Group__0__Impl rule__Uint32__Group__1 + // InternalRosParser.g:10758:1: ( rule__Bool__Group__0__Impl rule__Bool__Group__1 ) + // InternalRosParser.g:10759:2: rule__Bool__Group__0__Impl rule__Bool__Group__1 { - pushFollow(FOLLOW_76); - rule__Uint32__Group__0__Impl(); + pushFollow(FOLLOW_62); + rule__Bool__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Uint32__Group__1(); + rule__Bool__Group__1(); state._fsp--; @@ -41044,29 +32341,29 @@ public final void rule__Uint32__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint32__Group__0" + // $ANTLR end "rule__Bool__Group__0" - // $ANTLR start "rule__Uint32__Group__0__Impl" - // InternalRos.g:13617:1: rule__Uint32__Group__0__Impl : ( () ) ; - public final void rule__Uint32__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Bool__Group__0__Impl" + // InternalRosParser.g:10766:1: rule__Bool__Group__0__Impl : ( () ) ; + public final void rule__Bool__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13621:1: ( ( () ) ) - // InternalRos.g:13622:1: ( () ) + // InternalRosParser.g:10770:1: ( ( () ) ) + // InternalRosParser.g:10771:1: ( () ) { - // InternalRos.g:13622:1: ( () ) - // InternalRos.g:13623:2: () + // InternalRosParser.g:10771:1: ( () ) + // InternalRosParser.g:10772:2: () { - before(grammarAccess.getUint32Access().getUint32Action_0()); - // InternalRos.g:13624:2: () - // InternalRos.g:13624:3: + before(grammarAccess.getBoolAccess().getBoolAction_0()); + // InternalRosParser.g:10773:2: () + // InternalRosParser.g:10773:3: { } - after(grammarAccess.getUint32Access().getUint32Action_0()); + after(grammarAccess.getBoolAccess().getBoolAction_0()); } @@ -41081,21 +32378,21 @@ public final void rule__Uint32__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint32__Group__0__Impl" + // $ANTLR end "rule__Bool__Group__0__Impl" - // $ANTLR start "rule__Uint32__Group__1" - // InternalRos.g:13632:1: rule__Uint32__Group__1 : rule__Uint32__Group__1__Impl ; - public final void rule__Uint32__Group__1() throws RecognitionException { + // $ANTLR start "rule__Bool__Group__1" + // InternalRosParser.g:10781:1: rule__Bool__Group__1 : rule__Bool__Group__1__Impl ; + public final void rule__Bool__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13636:1: ( rule__Uint32__Group__1__Impl ) - // InternalRos.g:13637:2: rule__Uint32__Group__1__Impl + // InternalRosParser.g:10785:1: ( rule__Bool__Group__1__Impl ) + // InternalRosParser.g:10786:2: rule__Bool__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Uint32__Group__1__Impl(); + rule__Bool__Group__1__Impl(); state._fsp--; @@ -41114,25 +32411,25 @@ public final void rule__Uint32__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint32__Group__1" + // $ANTLR end "rule__Bool__Group__1" - // $ANTLR start "rule__Uint32__Group__1__Impl" - // InternalRos.g:13643:1: rule__Uint32__Group__1__Impl : ( 'uint32' ) ; - public final void rule__Uint32__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Bool__Group__1__Impl" + // InternalRosParser.g:10792:1: rule__Bool__Group__1__Impl : ( Bool ) ; + public final void rule__Bool__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13647:1: ( ( 'uint32' ) ) - // InternalRos.g:13648:1: ( 'uint32' ) + // InternalRosParser.g:10796:1: ( ( Bool ) ) + // InternalRosParser.g:10797:1: ( Bool ) { - // InternalRos.g:13648:1: ( 'uint32' ) - // InternalRos.g:13649:2: 'uint32' + // InternalRosParser.g:10797:1: ( Bool ) + // InternalRosParser.g:10798:2: Bool { - before(grammarAccess.getUint32Access().getUint32Keyword_1()); - match(input,93,FOLLOW_2); - after(grammarAccess.getUint32Access().getUint32Keyword_1()); + before(grammarAccess.getBoolAccess().getBoolKeyword_1()); + match(input,Bool,FOLLOW_2); + after(grammarAccess.getBoolAccess().getBoolKeyword_1()); } @@ -41151,26 +32448,26 @@ public final void rule__Uint32__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint32__Group__1__Impl" + // $ANTLR end "rule__Bool__Group__1__Impl" - // $ANTLR start "rule__Int64__Group__0" - // InternalRos.g:13659:1: rule__Int64__Group__0 : rule__Int64__Group__0__Impl rule__Int64__Group__1 ; - public final void rule__Int64__Group__0() throws RecognitionException { + // $ANTLR start "rule__Int8__Group__0" + // InternalRosParser.g:10808:1: rule__Int8__Group__0 : rule__Int8__Group__0__Impl rule__Int8__Group__1 ; + public final void rule__Int8__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13663:1: ( rule__Int64__Group__0__Impl rule__Int64__Group__1 ) - // InternalRos.g:13664:2: rule__Int64__Group__0__Impl rule__Int64__Group__1 + // InternalRosParser.g:10812:1: ( rule__Int8__Group__0__Impl rule__Int8__Group__1 ) + // InternalRosParser.g:10813:2: rule__Int8__Group__0__Impl rule__Int8__Group__1 { - pushFollow(FOLLOW_77); - rule__Int64__Group__0__Impl(); + pushFollow(FOLLOW_63); + rule__Int8__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Int64__Group__1(); + rule__Int8__Group__1(); state._fsp--; @@ -41189,29 +32486,29 @@ public final void rule__Int64__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int64__Group__0" + // $ANTLR end "rule__Int8__Group__0" - // $ANTLR start "rule__Int64__Group__0__Impl" - // InternalRos.g:13671:1: rule__Int64__Group__0__Impl : ( () ) ; - public final void rule__Int64__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Int8__Group__0__Impl" + // InternalRosParser.g:10820:1: rule__Int8__Group__0__Impl : ( () ) ; + public final void rule__Int8__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13675:1: ( ( () ) ) - // InternalRos.g:13676:1: ( () ) + // InternalRosParser.g:10824:1: ( ( () ) ) + // InternalRosParser.g:10825:1: ( () ) { - // InternalRos.g:13676:1: ( () ) - // InternalRos.g:13677:2: () + // InternalRosParser.g:10825:1: ( () ) + // InternalRosParser.g:10826:2: () { - before(grammarAccess.getInt64Access().getInt64Action_0()); - // InternalRos.g:13678:2: () - // InternalRos.g:13678:3: + before(grammarAccess.getInt8Access().getInt8Action_0()); + // InternalRosParser.g:10827:2: () + // InternalRosParser.g:10827:3: { } - after(grammarAccess.getInt64Access().getInt64Action_0()); + after(grammarAccess.getInt8Access().getInt8Action_0()); } @@ -41226,21 +32523,21 @@ public final void rule__Int64__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int64__Group__0__Impl" + // $ANTLR end "rule__Int8__Group__0__Impl" - // $ANTLR start "rule__Int64__Group__1" - // InternalRos.g:13686:1: rule__Int64__Group__1 : rule__Int64__Group__1__Impl ; - public final void rule__Int64__Group__1() throws RecognitionException { + // $ANTLR start "rule__Int8__Group__1" + // InternalRosParser.g:10835:1: rule__Int8__Group__1 : rule__Int8__Group__1__Impl ; + public final void rule__Int8__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13690:1: ( rule__Int64__Group__1__Impl ) - // InternalRos.g:13691:2: rule__Int64__Group__1__Impl + // InternalRosParser.g:10839:1: ( rule__Int8__Group__1__Impl ) + // InternalRosParser.g:10840:2: rule__Int8__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Int64__Group__1__Impl(); + rule__Int8__Group__1__Impl(); state._fsp--; @@ -41259,25 +32556,25 @@ public final void rule__Int64__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int64__Group__1" + // $ANTLR end "rule__Int8__Group__1" - // $ANTLR start "rule__Int64__Group__1__Impl" - // InternalRos.g:13697:1: rule__Int64__Group__1__Impl : ( 'int64' ) ; - public final void rule__Int64__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Int8__Group__1__Impl" + // InternalRosParser.g:10846:1: rule__Int8__Group__1__Impl : ( Int8 ) ; + public final void rule__Int8__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13701:1: ( ( 'int64' ) ) - // InternalRos.g:13702:1: ( 'int64' ) + // InternalRosParser.g:10850:1: ( ( Int8 ) ) + // InternalRosParser.g:10851:1: ( Int8 ) { - // InternalRos.g:13702:1: ( 'int64' ) - // InternalRos.g:13703:2: 'int64' + // InternalRosParser.g:10851:1: ( Int8 ) + // InternalRosParser.g:10852:2: Int8 { - before(grammarAccess.getInt64Access().getInt64Keyword_1()); - match(input,94,FOLLOW_2); - after(grammarAccess.getInt64Access().getInt64Keyword_1()); + before(grammarAccess.getInt8Access().getInt8Keyword_1()); + match(input,Int8,FOLLOW_2); + after(grammarAccess.getInt8Access().getInt8Keyword_1()); } @@ -41296,26 +32593,26 @@ public final void rule__Int64__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int64__Group__1__Impl" + // $ANTLR end "rule__Int8__Group__1__Impl" - // $ANTLR start "rule__Uint64__Group__0" - // InternalRos.g:13713:1: rule__Uint64__Group__0 : rule__Uint64__Group__0__Impl rule__Uint64__Group__1 ; - public final void rule__Uint64__Group__0() throws RecognitionException { + // $ANTLR start "rule__Uint8__Group__0" + // InternalRosParser.g:10862:1: rule__Uint8__Group__0 : rule__Uint8__Group__0__Impl rule__Uint8__Group__1 ; + public final void rule__Uint8__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13717:1: ( rule__Uint64__Group__0__Impl rule__Uint64__Group__1 ) - // InternalRos.g:13718:2: rule__Uint64__Group__0__Impl rule__Uint64__Group__1 + // InternalRosParser.g:10866:1: ( rule__Uint8__Group__0__Impl rule__Uint8__Group__1 ) + // InternalRosParser.g:10867:2: rule__Uint8__Group__0__Impl rule__Uint8__Group__1 { - pushFollow(FOLLOW_78); - rule__Uint64__Group__0__Impl(); + pushFollow(FOLLOW_64); + rule__Uint8__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Uint64__Group__1(); + rule__Uint8__Group__1(); state._fsp--; @@ -41334,29 +32631,29 @@ public final void rule__Uint64__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint64__Group__0" + // $ANTLR end "rule__Uint8__Group__0" - // $ANTLR start "rule__Uint64__Group__0__Impl" - // InternalRos.g:13725:1: rule__Uint64__Group__0__Impl : ( () ) ; - public final void rule__Uint64__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint8__Group__0__Impl" + // InternalRosParser.g:10874:1: rule__Uint8__Group__0__Impl : ( () ) ; + public final void rule__Uint8__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13729:1: ( ( () ) ) - // InternalRos.g:13730:1: ( () ) + // InternalRosParser.g:10878:1: ( ( () ) ) + // InternalRosParser.g:10879:1: ( () ) { - // InternalRos.g:13730:1: ( () ) - // InternalRos.g:13731:2: () + // InternalRosParser.g:10879:1: ( () ) + // InternalRosParser.g:10880:2: () { - before(grammarAccess.getUint64Access().getUint64Action_0()); - // InternalRos.g:13732:2: () - // InternalRos.g:13732:3: + before(grammarAccess.getUint8Access().getUint8Action_0()); + // InternalRosParser.g:10881:2: () + // InternalRosParser.g:10881:3: { } - after(grammarAccess.getUint64Access().getUint64Action_0()); + after(grammarAccess.getUint8Access().getUint8Action_0()); } @@ -41371,21 +32668,21 @@ public final void rule__Uint64__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint64__Group__0__Impl" + // $ANTLR end "rule__Uint8__Group__0__Impl" - // $ANTLR start "rule__Uint64__Group__1" - // InternalRos.g:13740:1: rule__Uint64__Group__1 : rule__Uint64__Group__1__Impl ; - public final void rule__Uint64__Group__1() throws RecognitionException { + // $ANTLR start "rule__Uint8__Group__1" + // InternalRosParser.g:10889:1: rule__Uint8__Group__1 : rule__Uint8__Group__1__Impl ; + public final void rule__Uint8__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13744:1: ( rule__Uint64__Group__1__Impl ) - // InternalRos.g:13745:2: rule__Uint64__Group__1__Impl + // InternalRosParser.g:10893:1: ( rule__Uint8__Group__1__Impl ) + // InternalRosParser.g:10894:2: rule__Uint8__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Uint64__Group__1__Impl(); + rule__Uint8__Group__1__Impl(); state._fsp--; @@ -41404,25 +32701,25 @@ public final void rule__Uint64__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint64__Group__1" + // $ANTLR end "rule__Uint8__Group__1" - // $ANTLR start "rule__Uint64__Group__1__Impl" - // InternalRos.g:13751:1: rule__Uint64__Group__1__Impl : ( 'uint64' ) ; - public final void rule__Uint64__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint8__Group__1__Impl" + // InternalRosParser.g:10900:1: rule__Uint8__Group__1__Impl : ( Uint8 ) ; + public final void rule__Uint8__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13755:1: ( ( 'uint64' ) ) - // InternalRos.g:13756:1: ( 'uint64' ) + // InternalRosParser.g:10904:1: ( ( Uint8 ) ) + // InternalRosParser.g:10905:1: ( Uint8 ) { - // InternalRos.g:13756:1: ( 'uint64' ) - // InternalRos.g:13757:2: 'uint64' + // InternalRosParser.g:10905:1: ( Uint8 ) + // InternalRosParser.g:10906:2: Uint8 { - before(grammarAccess.getUint64Access().getUint64Keyword_1()); - match(input,95,FOLLOW_2); - after(grammarAccess.getUint64Access().getUint64Keyword_1()); + before(grammarAccess.getUint8Access().getUint8Keyword_1()); + match(input,Uint8,FOLLOW_2); + after(grammarAccess.getUint8Access().getUint8Keyword_1()); } @@ -41441,26 +32738,26 @@ public final void rule__Uint64__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint64__Group__1__Impl" + // $ANTLR end "rule__Uint8__Group__1__Impl" - // $ANTLR start "rule__Float32__Group__0" - // InternalRos.g:13767:1: rule__Float32__Group__0 : rule__Float32__Group__0__Impl rule__Float32__Group__1 ; - public final void rule__Float32__Group__0() throws RecognitionException { + // $ANTLR start "rule__Int16__Group__0" + // InternalRosParser.g:10916:1: rule__Int16__Group__0 : rule__Int16__Group__0__Impl rule__Int16__Group__1 ; + public final void rule__Int16__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13771:1: ( rule__Float32__Group__0__Impl rule__Float32__Group__1 ) - // InternalRos.g:13772:2: rule__Float32__Group__0__Impl rule__Float32__Group__1 + // InternalRosParser.g:10920:1: ( rule__Int16__Group__0__Impl rule__Int16__Group__1 ) + // InternalRosParser.g:10921:2: rule__Int16__Group__0__Impl rule__Int16__Group__1 { - pushFollow(FOLLOW_79); - rule__Float32__Group__0__Impl(); + pushFollow(FOLLOW_65); + rule__Int16__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Float32__Group__1(); + rule__Int16__Group__1(); state._fsp--; @@ -41479,29 +32776,29 @@ public final void rule__Float32__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float32__Group__0" + // $ANTLR end "rule__Int16__Group__0" - // $ANTLR start "rule__Float32__Group__0__Impl" - // InternalRos.g:13779:1: rule__Float32__Group__0__Impl : ( () ) ; - public final void rule__Float32__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Int16__Group__0__Impl" + // InternalRosParser.g:10928:1: rule__Int16__Group__0__Impl : ( () ) ; + public final void rule__Int16__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13783:1: ( ( () ) ) - // InternalRos.g:13784:1: ( () ) + // InternalRosParser.g:10932:1: ( ( () ) ) + // InternalRosParser.g:10933:1: ( () ) { - // InternalRos.g:13784:1: ( () ) - // InternalRos.g:13785:2: () + // InternalRosParser.g:10933:1: ( () ) + // InternalRosParser.g:10934:2: () { - before(grammarAccess.getFloat32Access().getFloat32Action_0()); - // InternalRos.g:13786:2: () - // InternalRos.g:13786:3: + before(grammarAccess.getInt16Access().getInt16Action_0()); + // InternalRosParser.g:10935:2: () + // InternalRosParser.g:10935:3: { } - after(grammarAccess.getFloat32Access().getFloat32Action_0()); + after(grammarAccess.getInt16Access().getInt16Action_0()); } @@ -41516,21 +32813,21 @@ public final void rule__Float32__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float32__Group__0__Impl" + // $ANTLR end "rule__Int16__Group__0__Impl" - // $ANTLR start "rule__Float32__Group__1" - // InternalRos.g:13794:1: rule__Float32__Group__1 : rule__Float32__Group__1__Impl ; - public final void rule__Float32__Group__1() throws RecognitionException { + // $ANTLR start "rule__Int16__Group__1" + // InternalRosParser.g:10943:1: rule__Int16__Group__1 : rule__Int16__Group__1__Impl ; + public final void rule__Int16__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13798:1: ( rule__Float32__Group__1__Impl ) - // InternalRos.g:13799:2: rule__Float32__Group__1__Impl + // InternalRosParser.g:10947:1: ( rule__Int16__Group__1__Impl ) + // InternalRosParser.g:10948:2: rule__Int16__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Float32__Group__1__Impl(); + rule__Int16__Group__1__Impl(); state._fsp--; @@ -41549,25 +32846,25 @@ public final void rule__Float32__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float32__Group__1" + // $ANTLR end "rule__Int16__Group__1" - // $ANTLR start "rule__Float32__Group__1__Impl" - // InternalRos.g:13805:1: rule__Float32__Group__1__Impl : ( 'float32' ) ; - public final void rule__Float32__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Int16__Group__1__Impl" + // InternalRosParser.g:10954:1: rule__Int16__Group__1__Impl : ( Int16 ) ; + public final void rule__Int16__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13809:1: ( ( 'float32' ) ) - // InternalRos.g:13810:1: ( 'float32' ) + // InternalRosParser.g:10958:1: ( ( Int16 ) ) + // InternalRosParser.g:10959:1: ( Int16 ) { - // InternalRos.g:13810:1: ( 'float32' ) - // InternalRos.g:13811:2: 'float32' + // InternalRosParser.g:10959:1: ( Int16 ) + // InternalRosParser.g:10960:2: Int16 { - before(grammarAccess.getFloat32Access().getFloat32Keyword_1()); - match(input,96,FOLLOW_2); - after(grammarAccess.getFloat32Access().getFloat32Keyword_1()); + before(grammarAccess.getInt16Access().getInt16Keyword_1()); + match(input,Int16,FOLLOW_2); + after(grammarAccess.getInt16Access().getInt16Keyword_1()); } @@ -41586,26 +32883,26 @@ public final void rule__Float32__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float32__Group__1__Impl" + // $ANTLR end "rule__Int16__Group__1__Impl" - // $ANTLR start "rule__Float64__Group__0" - // InternalRos.g:13821:1: rule__Float64__Group__0 : rule__Float64__Group__0__Impl rule__Float64__Group__1 ; - public final void rule__Float64__Group__0() throws RecognitionException { + // $ANTLR start "rule__Uint16__Group__0" + // InternalRosParser.g:10970:1: rule__Uint16__Group__0 : rule__Uint16__Group__0__Impl rule__Uint16__Group__1 ; + public final void rule__Uint16__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13825:1: ( rule__Float64__Group__0__Impl rule__Float64__Group__1 ) - // InternalRos.g:13826:2: rule__Float64__Group__0__Impl rule__Float64__Group__1 + // InternalRosParser.g:10974:1: ( rule__Uint16__Group__0__Impl rule__Uint16__Group__1 ) + // InternalRosParser.g:10975:2: rule__Uint16__Group__0__Impl rule__Uint16__Group__1 { - pushFollow(FOLLOW_80); - rule__Float64__Group__0__Impl(); + pushFollow(FOLLOW_66); + rule__Uint16__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Float64__Group__1(); + rule__Uint16__Group__1(); state._fsp--; @@ -41624,29 +32921,29 @@ public final void rule__Float64__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float64__Group__0" + // $ANTLR end "rule__Uint16__Group__0" - // $ANTLR start "rule__Float64__Group__0__Impl" - // InternalRos.g:13833:1: rule__Float64__Group__0__Impl : ( () ) ; - public final void rule__Float64__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint16__Group__0__Impl" + // InternalRosParser.g:10982:1: rule__Uint16__Group__0__Impl : ( () ) ; + public final void rule__Uint16__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13837:1: ( ( () ) ) - // InternalRos.g:13838:1: ( () ) + // InternalRosParser.g:10986:1: ( ( () ) ) + // InternalRosParser.g:10987:1: ( () ) { - // InternalRos.g:13838:1: ( () ) - // InternalRos.g:13839:2: () + // InternalRosParser.g:10987:1: ( () ) + // InternalRosParser.g:10988:2: () { - before(grammarAccess.getFloat64Access().getFloat64Action_0()); - // InternalRos.g:13840:2: () - // InternalRos.g:13840:3: + before(grammarAccess.getUint16Access().getUint16Action_0()); + // InternalRosParser.g:10989:2: () + // InternalRosParser.g:10989:3: { } - after(grammarAccess.getFloat64Access().getFloat64Action_0()); + after(grammarAccess.getUint16Access().getUint16Action_0()); } @@ -41661,21 +32958,21 @@ public final void rule__Float64__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float64__Group__0__Impl" + // $ANTLR end "rule__Uint16__Group__0__Impl" - // $ANTLR start "rule__Float64__Group__1" - // InternalRos.g:13848:1: rule__Float64__Group__1 : rule__Float64__Group__1__Impl ; - public final void rule__Float64__Group__1() throws RecognitionException { + // $ANTLR start "rule__Uint16__Group__1" + // InternalRosParser.g:10997:1: rule__Uint16__Group__1 : rule__Uint16__Group__1__Impl ; + public final void rule__Uint16__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13852:1: ( rule__Float64__Group__1__Impl ) - // InternalRos.g:13853:2: rule__Float64__Group__1__Impl + // InternalRosParser.g:11001:1: ( rule__Uint16__Group__1__Impl ) + // InternalRosParser.g:11002:2: rule__Uint16__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Float64__Group__1__Impl(); + rule__Uint16__Group__1__Impl(); state._fsp--; @@ -41694,25 +32991,25 @@ public final void rule__Float64__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float64__Group__1" + // $ANTLR end "rule__Uint16__Group__1" - // $ANTLR start "rule__Float64__Group__1__Impl" - // InternalRos.g:13859:1: rule__Float64__Group__1__Impl : ( 'float64' ) ; - public final void rule__Float64__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint16__Group__1__Impl" + // InternalRosParser.g:11008:1: rule__Uint16__Group__1__Impl : ( Uint16 ) ; + public final void rule__Uint16__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13863:1: ( ( 'float64' ) ) - // InternalRos.g:13864:1: ( 'float64' ) + // InternalRosParser.g:11012:1: ( ( Uint16 ) ) + // InternalRosParser.g:11013:1: ( Uint16 ) { - // InternalRos.g:13864:1: ( 'float64' ) - // InternalRos.g:13865:2: 'float64' + // InternalRosParser.g:11013:1: ( Uint16 ) + // InternalRosParser.g:11014:2: Uint16 { - before(grammarAccess.getFloat64Access().getFloat64Keyword_1()); - match(input,97,FOLLOW_2); - after(grammarAccess.getFloat64Access().getFloat64Keyword_1()); + before(grammarAccess.getUint16Access().getUint16Keyword_1()); + match(input,Uint16,FOLLOW_2); + after(grammarAccess.getUint16Access().getUint16Keyword_1()); } @@ -41731,26 +33028,26 @@ public final void rule__Float64__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float64__Group__1__Impl" + // $ANTLR end "rule__Uint16__Group__1__Impl" - // $ANTLR start "rule__String0__Group__0" - // InternalRos.g:13875:1: rule__String0__Group__0 : rule__String0__Group__0__Impl rule__String0__Group__1 ; - public final void rule__String0__Group__0() throws RecognitionException { + // $ANTLR start "rule__Int32__Group__0" + // InternalRosParser.g:11024:1: rule__Int32__Group__0 : rule__Int32__Group__0__Impl rule__Int32__Group__1 ; + public final void rule__Int32__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13879:1: ( rule__String0__Group__0__Impl rule__String0__Group__1 ) - // InternalRos.g:13880:2: rule__String0__Group__0__Impl rule__String0__Group__1 + // InternalRosParser.g:11028:1: ( rule__Int32__Group__0__Impl rule__Int32__Group__1 ) + // InternalRosParser.g:11029:2: rule__Int32__Group__0__Impl rule__Int32__Group__1 { - pushFollow(FOLLOW_81); - rule__String0__Group__0__Impl(); + pushFollow(FOLLOW_67); + rule__Int32__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__String0__Group__1(); + rule__Int32__Group__1(); state._fsp--; @@ -41769,29 +33066,29 @@ public final void rule__String0__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__String0__Group__0" + // $ANTLR end "rule__Int32__Group__0" - // $ANTLR start "rule__String0__Group__0__Impl" - // InternalRos.g:13887:1: rule__String0__Group__0__Impl : ( () ) ; - public final void rule__String0__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Int32__Group__0__Impl" + // InternalRosParser.g:11036:1: rule__Int32__Group__0__Impl : ( () ) ; + public final void rule__Int32__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13891:1: ( ( () ) ) - // InternalRos.g:13892:1: ( () ) + // InternalRosParser.g:11040:1: ( ( () ) ) + // InternalRosParser.g:11041:1: ( () ) { - // InternalRos.g:13892:1: ( () ) - // InternalRos.g:13893:2: () + // InternalRosParser.g:11041:1: ( () ) + // InternalRosParser.g:11042:2: () { - before(grammarAccess.getString0Access().getStringAction_0()); - // InternalRos.g:13894:2: () - // InternalRos.g:13894:3: + before(grammarAccess.getInt32Access().getInt32Action_0()); + // InternalRosParser.g:11043:2: () + // InternalRosParser.g:11043:3: { } - after(grammarAccess.getString0Access().getStringAction_0()); + after(grammarAccess.getInt32Access().getInt32Action_0()); } @@ -41806,21 +33103,21 @@ public final void rule__String0__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__String0__Group__0__Impl" + // $ANTLR end "rule__Int32__Group__0__Impl" - // $ANTLR start "rule__String0__Group__1" - // InternalRos.g:13902:1: rule__String0__Group__1 : rule__String0__Group__1__Impl ; - public final void rule__String0__Group__1() throws RecognitionException { + // $ANTLR start "rule__Int32__Group__1" + // InternalRosParser.g:11051:1: rule__Int32__Group__1 : rule__Int32__Group__1__Impl ; + public final void rule__Int32__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13906:1: ( rule__String0__Group__1__Impl ) - // InternalRos.g:13907:2: rule__String0__Group__1__Impl + // InternalRosParser.g:11055:1: ( rule__Int32__Group__1__Impl ) + // InternalRosParser.g:11056:2: rule__Int32__Group__1__Impl { pushFollow(FOLLOW_2); - rule__String0__Group__1__Impl(); + rule__Int32__Group__1__Impl(); state._fsp--; @@ -41839,25 +33136,25 @@ public final void rule__String0__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__String0__Group__1" + // $ANTLR end "rule__Int32__Group__1" - // $ANTLR start "rule__String0__Group__1__Impl" - // InternalRos.g:13913:1: rule__String0__Group__1__Impl : ( 'string' ) ; - public final void rule__String0__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Int32__Group__1__Impl" + // InternalRosParser.g:11062:1: rule__Int32__Group__1__Impl : ( Int32 ) ; + public final void rule__Int32__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13917:1: ( ( 'string' ) ) - // InternalRos.g:13918:1: ( 'string' ) + // InternalRosParser.g:11066:1: ( ( Int32 ) ) + // InternalRosParser.g:11067:1: ( Int32 ) { - // InternalRos.g:13918:1: ( 'string' ) - // InternalRos.g:13919:2: 'string' + // InternalRosParser.g:11067:1: ( Int32 ) + // InternalRosParser.g:11068:2: Int32 { - before(grammarAccess.getString0Access().getStringKeyword_1()); - match(input,98,FOLLOW_2); - after(grammarAccess.getString0Access().getStringKeyword_1()); + before(grammarAccess.getInt32Access().getInt32Keyword_1()); + match(input,Int32,FOLLOW_2); + after(grammarAccess.getInt32Access().getInt32Keyword_1()); } @@ -41876,26 +33173,26 @@ public final void rule__String0__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__String0__Group__1__Impl" + // $ANTLR end "rule__Int32__Group__1__Impl" - // $ANTLR start "rule__Byte__Group__0" - // InternalRos.g:13929:1: rule__Byte__Group__0 : rule__Byte__Group__0__Impl rule__Byte__Group__1 ; - public final void rule__Byte__Group__0() throws RecognitionException { + // $ANTLR start "rule__Uint32__Group__0" + // InternalRosParser.g:11078:1: rule__Uint32__Group__0 : rule__Uint32__Group__0__Impl rule__Uint32__Group__1 ; + public final void rule__Uint32__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13933:1: ( rule__Byte__Group__0__Impl rule__Byte__Group__1 ) - // InternalRos.g:13934:2: rule__Byte__Group__0__Impl rule__Byte__Group__1 + // InternalRosParser.g:11082:1: ( rule__Uint32__Group__0__Impl rule__Uint32__Group__1 ) + // InternalRosParser.g:11083:2: rule__Uint32__Group__0__Impl rule__Uint32__Group__1 { - pushFollow(FOLLOW_82); - rule__Byte__Group__0__Impl(); + pushFollow(FOLLOW_68); + rule__Uint32__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Byte__Group__1(); + rule__Uint32__Group__1(); state._fsp--; @@ -41914,29 +33211,29 @@ public final void rule__Byte__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Byte__Group__0" + // $ANTLR end "rule__Uint32__Group__0" - // $ANTLR start "rule__Byte__Group__0__Impl" - // InternalRos.g:13941:1: rule__Byte__Group__0__Impl : ( () ) ; - public final void rule__Byte__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint32__Group__0__Impl" + // InternalRosParser.g:11090:1: rule__Uint32__Group__0__Impl : ( () ) ; + public final void rule__Uint32__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13945:1: ( ( () ) ) - // InternalRos.g:13946:1: ( () ) + // InternalRosParser.g:11094:1: ( ( () ) ) + // InternalRosParser.g:11095:1: ( () ) { - // InternalRos.g:13946:1: ( () ) - // InternalRos.g:13947:2: () + // InternalRosParser.g:11095:1: ( () ) + // InternalRosParser.g:11096:2: () { - before(grammarAccess.getByteAccess().getByteAction_0()); - // InternalRos.g:13948:2: () - // InternalRos.g:13948:3: + before(grammarAccess.getUint32Access().getUint32Action_0()); + // InternalRosParser.g:11097:2: () + // InternalRosParser.g:11097:3: { } - after(grammarAccess.getByteAccess().getByteAction_0()); + after(grammarAccess.getUint32Access().getUint32Action_0()); } @@ -41951,21 +33248,21 @@ public final void rule__Byte__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Byte__Group__0__Impl" + // $ANTLR end "rule__Uint32__Group__0__Impl" - // $ANTLR start "rule__Byte__Group__1" - // InternalRos.g:13956:1: rule__Byte__Group__1 : rule__Byte__Group__1__Impl ; - public final void rule__Byte__Group__1() throws RecognitionException { + // $ANTLR start "rule__Uint32__Group__1" + // InternalRosParser.g:11105:1: rule__Uint32__Group__1 : rule__Uint32__Group__1__Impl ; + public final void rule__Uint32__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13960:1: ( rule__Byte__Group__1__Impl ) - // InternalRos.g:13961:2: rule__Byte__Group__1__Impl + // InternalRosParser.g:11109:1: ( rule__Uint32__Group__1__Impl ) + // InternalRosParser.g:11110:2: rule__Uint32__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Byte__Group__1__Impl(); + rule__Uint32__Group__1__Impl(); state._fsp--; @@ -41984,25 +33281,25 @@ public final void rule__Byte__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Byte__Group__1" + // $ANTLR end "rule__Uint32__Group__1" - // $ANTLR start "rule__Byte__Group__1__Impl" - // InternalRos.g:13967:1: rule__Byte__Group__1__Impl : ( 'byte' ) ; - public final void rule__Byte__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint32__Group__1__Impl" + // InternalRosParser.g:11116:1: rule__Uint32__Group__1__Impl : ( Uint32 ) ; + public final void rule__Uint32__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13971:1: ( ( 'byte' ) ) - // InternalRos.g:13972:1: ( 'byte' ) + // InternalRosParser.g:11120:1: ( ( Uint32 ) ) + // InternalRosParser.g:11121:1: ( Uint32 ) { - // InternalRos.g:13972:1: ( 'byte' ) - // InternalRos.g:13973:2: 'byte' + // InternalRosParser.g:11121:1: ( Uint32 ) + // InternalRosParser.g:11122:2: Uint32 { - before(grammarAccess.getByteAccess().getByteKeyword_1()); - match(input,99,FOLLOW_2); - after(grammarAccess.getByteAccess().getByteKeyword_1()); + before(grammarAccess.getUint32Access().getUint32Keyword_1()); + match(input,Uint32,FOLLOW_2); + after(grammarAccess.getUint32Access().getUint32Keyword_1()); } @@ -42021,26 +33318,26 @@ public final void rule__Byte__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Byte__Group__1__Impl" + // $ANTLR end "rule__Uint32__Group__1__Impl" - // $ANTLR start "rule__Time__Group__0" - // InternalRos.g:13983:1: rule__Time__Group__0 : rule__Time__Group__0__Impl rule__Time__Group__1 ; - public final void rule__Time__Group__0() throws RecognitionException { + // $ANTLR start "rule__Int64__Group__0" + // InternalRosParser.g:11132:1: rule__Int64__Group__0 : rule__Int64__Group__0__Impl rule__Int64__Group__1 ; + public final void rule__Int64__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13987:1: ( rule__Time__Group__0__Impl rule__Time__Group__1 ) - // InternalRos.g:13988:2: rule__Time__Group__0__Impl rule__Time__Group__1 + // InternalRosParser.g:11136:1: ( rule__Int64__Group__0__Impl rule__Int64__Group__1 ) + // InternalRosParser.g:11137:2: rule__Int64__Group__0__Impl rule__Int64__Group__1 { - pushFollow(FOLLOW_83); - rule__Time__Group__0__Impl(); + pushFollow(FOLLOW_69); + rule__Int64__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Time__Group__1(); + rule__Int64__Group__1(); state._fsp--; @@ -42059,29 +33356,29 @@ public final void rule__Time__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Time__Group__0" + // $ANTLR end "rule__Int64__Group__0" - // $ANTLR start "rule__Time__Group__0__Impl" - // InternalRos.g:13995:1: rule__Time__Group__0__Impl : ( () ) ; - public final void rule__Time__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Int64__Group__0__Impl" + // InternalRosParser.g:11144:1: rule__Int64__Group__0__Impl : ( () ) ; + public final void rule__Int64__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:13999:1: ( ( () ) ) - // InternalRos.g:14000:1: ( () ) + // InternalRosParser.g:11148:1: ( ( () ) ) + // InternalRosParser.g:11149:1: ( () ) { - // InternalRos.g:14000:1: ( () ) - // InternalRos.g:14001:2: () + // InternalRosParser.g:11149:1: ( () ) + // InternalRosParser.g:11150:2: () { - before(grammarAccess.getTimeAccess().getTimeAction_0()); - // InternalRos.g:14002:2: () - // InternalRos.g:14002:3: + before(grammarAccess.getInt64Access().getInt64Action_0()); + // InternalRosParser.g:11151:2: () + // InternalRosParser.g:11151:3: { } - after(grammarAccess.getTimeAccess().getTimeAction_0()); + after(grammarAccess.getInt64Access().getInt64Action_0()); } @@ -42096,21 +33393,21 @@ public final void rule__Time__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Time__Group__0__Impl" + // $ANTLR end "rule__Int64__Group__0__Impl" - // $ANTLR start "rule__Time__Group__1" - // InternalRos.g:14010:1: rule__Time__Group__1 : rule__Time__Group__1__Impl ; - public final void rule__Time__Group__1() throws RecognitionException { + // $ANTLR start "rule__Int64__Group__1" + // InternalRosParser.g:11159:1: rule__Int64__Group__1 : rule__Int64__Group__1__Impl ; + public final void rule__Int64__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14014:1: ( rule__Time__Group__1__Impl ) - // InternalRos.g:14015:2: rule__Time__Group__1__Impl + // InternalRosParser.g:11163:1: ( rule__Int64__Group__1__Impl ) + // InternalRosParser.g:11164:2: rule__Int64__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Time__Group__1__Impl(); + rule__Int64__Group__1__Impl(); state._fsp--; @@ -42129,25 +33426,25 @@ public final void rule__Time__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Time__Group__1" + // $ANTLR end "rule__Int64__Group__1" - // $ANTLR start "rule__Time__Group__1__Impl" - // InternalRos.g:14021:1: rule__Time__Group__1__Impl : ( 'time' ) ; - public final void rule__Time__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Int64__Group__1__Impl" + // InternalRosParser.g:11170:1: rule__Int64__Group__1__Impl : ( Int64 ) ; + public final void rule__Int64__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14025:1: ( ( 'time' ) ) - // InternalRos.g:14026:1: ( 'time' ) + // InternalRosParser.g:11174:1: ( ( Int64 ) ) + // InternalRosParser.g:11175:1: ( Int64 ) { - // InternalRos.g:14026:1: ( 'time' ) - // InternalRos.g:14027:2: 'time' + // InternalRosParser.g:11175:1: ( Int64 ) + // InternalRosParser.g:11176:2: Int64 { - before(grammarAccess.getTimeAccess().getTimeKeyword_1()); - match(input,39,FOLLOW_2); - after(grammarAccess.getTimeAccess().getTimeKeyword_1()); + before(grammarAccess.getInt64Access().getInt64Keyword_1()); + match(input,Int64,FOLLOW_2); + after(grammarAccess.getInt64Access().getInt64Keyword_1()); } @@ -42166,26 +33463,26 @@ public final void rule__Time__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Time__Group__1__Impl" + // $ANTLR end "rule__Int64__Group__1__Impl" - // $ANTLR start "rule__Duration__Group__0" - // InternalRos.g:14037:1: rule__Duration__Group__0 : rule__Duration__Group__0__Impl rule__Duration__Group__1 ; - public final void rule__Duration__Group__0() throws RecognitionException { + // $ANTLR start "rule__Uint64__Group__0" + // InternalRosParser.g:11186:1: rule__Uint64__Group__0 : rule__Uint64__Group__0__Impl rule__Uint64__Group__1 ; + public final void rule__Uint64__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14041:1: ( rule__Duration__Group__0__Impl rule__Duration__Group__1 ) - // InternalRos.g:14042:2: rule__Duration__Group__0__Impl rule__Duration__Group__1 + // InternalRosParser.g:11190:1: ( rule__Uint64__Group__0__Impl rule__Uint64__Group__1 ) + // InternalRosParser.g:11191:2: rule__Uint64__Group__0__Impl rule__Uint64__Group__1 { - pushFollow(FOLLOW_84); - rule__Duration__Group__0__Impl(); + pushFollow(FOLLOW_70); + rule__Uint64__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Duration__Group__1(); + rule__Uint64__Group__1(); state._fsp--; @@ -42204,29 +33501,29 @@ public final void rule__Duration__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Duration__Group__0" + // $ANTLR end "rule__Uint64__Group__0" - // $ANTLR start "rule__Duration__Group__0__Impl" - // InternalRos.g:14049:1: rule__Duration__Group__0__Impl : ( () ) ; - public final void rule__Duration__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint64__Group__0__Impl" + // InternalRosParser.g:11198:1: rule__Uint64__Group__0__Impl : ( () ) ; + public final void rule__Uint64__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14053:1: ( ( () ) ) - // InternalRos.g:14054:1: ( () ) + // InternalRosParser.g:11202:1: ( ( () ) ) + // InternalRosParser.g:11203:1: ( () ) { - // InternalRos.g:14054:1: ( () ) - // InternalRos.g:14055:2: () + // InternalRosParser.g:11203:1: ( () ) + // InternalRosParser.g:11204:2: () { - before(grammarAccess.getDurationAccess().getDurationAction_0()); - // InternalRos.g:14056:2: () - // InternalRos.g:14056:3: + before(grammarAccess.getUint64Access().getUint64Action_0()); + // InternalRosParser.g:11205:2: () + // InternalRosParser.g:11205:3: { } - after(grammarAccess.getDurationAccess().getDurationAction_0()); + after(grammarAccess.getUint64Access().getUint64Action_0()); } @@ -42241,21 +33538,21 @@ public final void rule__Duration__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Duration__Group__0__Impl" + // $ANTLR end "rule__Uint64__Group__0__Impl" - // $ANTLR start "rule__Duration__Group__1" - // InternalRos.g:14064:1: rule__Duration__Group__1 : rule__Duration__Group__1__Impl ; - public final void rule__Duration__Group__1() throws RecognitionException { + // $ANTLR start "rule__Uint64__Group__1" + // InternalRosParser.g:11213:1: rule__Uint64__Group__1 : rule__Uint64__Group__1__Impl ; + public final void rule__Uint64__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14068:1: ( rule__Duration__Group__1__Impl ) - // InternalRos.g:14069:2: rule__Duration__Group__1__Impl + // InternalRosParser.g:11217:1: ( rule__Uint64__Group__1__Impl ) + // InternalRosParser.g:11218:2: rule__Uint64__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Duration__Group__1__Impl(); + rule__Uint64__Group__1__Impl(); state._fsp--; @@ -42274,25 +33571,25 @@ public final void rule__Duration__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Duration__Group__1" + // $ANTLR end "rule__Uint64__Group__1" - // $ANTLR start "rule__Duration__Group__1__Impl" - // InternalRos.g:14075:1: rule__Duration__Group__1__Impl : ( 'duration' ) ; - public final void rule__Duration__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint64__Group__1__Impl" + // InternalRosParser.g:11224:1: rule__Uint64__Group__1__Impl : ( Uint64 ) ; + public final void rule__Uint64__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14079:1: ( ( 'duration' ) ) - // InternalRos.g:14080:1: ( 'duration' ) + // InternalRosParser.g:11228:1: ( ( Uint64 ) ) + // InternalRosParser.g:11229:1: ( Uint64 ) { - // InternalRos.g:14080:1: ( 'duration' ) - // InternalRos.g:14081:2: 'duration' + // InternalRosParser.g:11229:1: ( Uint64 ) + // InternalRosParser.g:11230:2: Uint64 { - before(grammarAccess.getDurationAccess().getDurationKeyword_1()); - match(input,38,FOLLOW_2); - after(grammarAccess.getDurationAccess().getDurationKeyword_1()); + before(grammarAccess.getUint64Access().getUint64Keyword_1()); + match(input,Uint64,FOLLOW_2); + after(grammarAccess.getUint64Access().getUint64Keyword_1()); } @@ -42311,26 +33608,26 @@ public final void rule__Duration__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Duration__Group__1__Impl" + // $ANTLR end "rule__Uint64__Group__1__Impl" - // $ANTLR start "rule__BoolArray__Group__0" - // InternalRos.g:14091:1: rule__BoolArray__Group__0 : rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 ; - public final void rule__BoolArray__Group__0() throws RecognitionException { + // $ANTLR start "rule__Float32__Group__0" + // InternalRosParser.g:11240:1: rule__Float32__Group__0 : rule__Float32__Group__0__Impl rule__Float32__Group__1 ; + public final void rule__Float32__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14095:1: ( rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 ) - // InternalRos.g:14096:2: rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 + // InternalRosParser.g:11244:1: ( rule__Float32__Group__0__Impl rule__Float32__Group__1 ) + // InternalRosParser.g:11245:2: rule__Float32__Group__0__Impl rule__Float32__Group__1 { - pushFollow(FOLLOW_85); - rule__BoolArray__Group__0__Impl(); + pushFollow(FOLLOW_71); + rule__Float32__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__BoolArray__Group__1(); + rule__Float32__Group__1(); state._fsp--; @@ -42349,29 +33646,29 @@ public final void rule__BoolArray__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__BoolArray__Group__0" + // $ANTLR end "rule__Float32__Group__0" - // $ANTLR start "rule__BoolArray__Group__0__Impl" - // InternalRos.g:14103:1: rule__BoolArray__Group__0__Impl : ( () ) ; - public final void rule__BoolArray__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Float32__Group__0__Impl" + // InternalRosParser.g:11252:1: rule__Float32__Group__0__Impl : ( () ) ; + public final void rule__Float32__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14107:1: ( ( () ) ) - // InternalRos.g:14108:1: ( () ) + // InternalRosParser.g:11256:1: ( ( () ) ) + // InternalRosParser.g:11257:1: ( () ) { - // InternalRos.g:14108:1: ( () ) - // InternalRos.g:14109:2: () + // InternalRosParser.g:11257:1: ( () ) + // InternalRosParser.g:11258:2: () { - before(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); - // InternalRos.g:14110:2: () - // InternalRos.g:14110:3: + before(grammarAccess.getFloat32Access().getFloat32Action_0()); + // InternalRosParser.g:11259:2: () + // InternalRosParser.g:11259:3: { } - after(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); + after(grammarAccess.getFloat32Access().getFloat32Action_0()); } @@ -42386,21 +33683,21 @@ public final void rule__BoolArray__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__BoolArray__Group__0__Impl" + // $ANTLR end "rule__Float32__Group__0__Impl" - // $ANTLR start "rule__BoolArray__Group__1" - // InternalRos.g:14118:1: rule__BoolArray__Group__1 : rule__BoolArray__Group__1__Impl ; - public final void rule__BoolArray__Group__1() throws RecognitionException { + // $ANTLR start "rule__Float32__Group__1" + // InternalRosParser.g:11267:1: rule__Float32__Group__1 : rule__Float32__Group__1__Impl ; + public final void rule__Float32__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14122:1: ( rule__BoolArray__Group__1__Impl ) - // InternalRos.g:14123:2: rule__BoolArray__Group__1__Impl + // InternalRosParser.g:11271:1: ( rule__Float32__Group__1__Impl ) + // InternalRosParser.g:11272:2: rule__Float32__Group__1__Impl { pushFollow(FOLLOW_2); - rule__BoolArray__Group__1__Impl(); + rule__Float32__Group__1__Impl(); state._fsp--; @@ -42419,25 +33716,25 @@ public final void rule__BoolArray__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__BoolArray__Group__1" + // $ANTLR end "rule__Float32__Group__1" - // $ANTLR start "rule__BoolArray__Group__1__Impl" - // InternalRos.g:14129:1: rule__BoolArray__Group__1__Impl : ( 'bool[]' ) ; - public final void rule__BoolArray__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Float32__Group__1__Impl" + // InternalRosParser.g:11278:1: rule__Float32__Group__1__Impl : ( Float32 ) ; + public final void rule__Float32__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14133:1: ( ( 'bool[]' ) ) - // InternalRos.g:14134:1: ( 'bool[]' ) + // InternalRosParser.g:11282:1: ( ( Float32 ) ) + // InternalRosParser.g:11283:1: ( Float32 ) { - // InternalRos.g:14134:1: ( 'bool[]' ) - // InternalRos.g:14135:2: 'bool[]' + // InternalRosParser.g:11283:1: ( Float32 ) + // InternalRosParser.g:11284:2: Float32 { - before(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); - match(input,100,FOLLOW_2); - after(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); + before(grammarAccess.getFloat32Access().getFloat32Keyword_1()); + match(input,Float32,FOLLOW_2); + after(grammarAccess.getFloat32Access().getFloat32Keyword_1()); } @@ -42456,26 +33753,26 @@ public final void rule__BoolArray__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__BoolArray__Group__1__Impl" + // $ANTLR end "rule__Float32__Group__1__Impl" - // $ANTLR start "rule__Int8Array__Group__0" - // InternalRos.g:14145:1: rule__Int8Array__Group__0 : rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 ; - public final void rule__Int8Array__Group__0() throws RecognitionException { + // $ANTLR start "rule__Float64__Group__0" + // InternalRosParser.g:11294:1: rule__Float64__Group__0 : rule__Float64__Group__0__Impl rule__Float64__Group__1 ; + public final void rule__Float64__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14149:1: ( rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 ) - // InternalRos.g:14150:2: rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 + // InternalRosParser.g:11298:1: ( rule__Float64__Group__0__Impl rule__Float64__Group__1 ) + // InternalRosParser.g:11299:2: rule__Float64__Group__0__Impl rule__Float64__Group__1 { - pushFollow(FOLLOW_86); - rule__Int8Array__Group__0__Impl(); + pushFollow(FOLLOW_72); + rule__Float64__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Int8Array__Group__1(); + rule__Float64__Group__1(); state._fsp--; @@ -42494,29 +33791,29 @@ public final void rule__Int8Array__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int8Array__Group__0" + // $ANTLR end "rule__Float64__Group__0" - // $ANTLR start "rule__Int8Array__Group__0__Impl" - // InternalRos.g:14157:1: rule__Int8Array__Group__0__Impl : ( () ) ; - public final void rule__Int8Array__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Float64__Group__0__Impl" + // InternalRosParser.g:11306:1: rule__Float64__Group__0__Impl : ( () ) ; + public final void rule__Float64__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14161:1: ( ( () ) ) - // InternalRos.g:14162:1: ( () ) + // InternalRosParser.g:11310:1: ( ( () ) ) + // InternalRosParser.g:11311:1: ( () ) { - // InternalRos.g:14162:1: ( () ) - // InternalRos.g:14163:2: () + // InternalRosParser.g:11311:1: ( () ) + // InternalRosParser.g:11312:2: () { - before(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); - // InternalRos.g:14164:2: () - // InternalRos.g:14164:3: + before(grammarAccess.getFloat64Access().getFloat64Action_0()); + // InternalRosParser.g:11313:2: () + // InternalRosParser.g:11313:3: { } - after(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); + after(grammarAccess.getFloat64Access().getFloat64Action_0()); } @@ -42531,21 +33828,21 @@ public final void rule__Int8Array__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Int8Array__Group__0__Impl" + // $ANTLR end "rule__Float64__Group__0__Impl" - // $ANTLR start "rule__Int8Array__Group__1" - // InternalRos.g:14172:1: rule__Int8Array__Group__1 : rule__Int8Array__Group__1__Impl ; - public final void rule__Int8Array__Group__1() throws RecognitionException { + // $ANTLR start "rule__Float64__Group__1" + // InternalRosParser.g:11321:1: rule__Float64__Group__1 : rule__Float64__Group__1__Impl ; + public final void rule__Float64__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14176:1: ( rule__Int8Array__Group__1__Impl ) - // InternalRos.g:14177:2: rule__Int8Array__Group__1__Impl + // InternalRosParser.g:11325:1: ( rule__Float64__Group__1__Impl ) + // InternalRosParser.g:11326:2: rule__Float64__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Int8Array__Group__1__Impl(); + rule__Float64__Group__1__Impl(); state._fsp--; @@ -42564,25 +33861,25 @@ public final void rule__Int8Array__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int8Array__Group__1" + // $ANTLR end "rule__Float64__Group__1" - // $ANTLR start "rule__Int8Array__Group__1__Impl" - // InternalRos.g:14183:1: rule__Int8Array__Group__1__Impl : ( 'int8[]' ) ; - public final void rule__Int8Array__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Float64__Group__1__Impl" + // InternalRosParser.g:11332:1: rule__Float64__Group__1__Impl : ( Float64 ) ; + public final void rule__Float64__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14187:1: ( ( 'int8[]' ) ) - // InternalRos.g:14188:1: ( 'int8[]' ) + // InternalRosParser.g:11336:1: ( ( Float64 ) ) + // InternalRosParser.g:11337:1: ( Float64 ) { - // InternalRos.g:14188:1: ( 'int8[]' ) - // InternalRos.g:14189:2: 'int8[]' + // InternalRosParser.g:11337:1: ( Float64 ) + // InternalRosParser.g:11338:2: Float64 { - before(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); - match(input,101,FOLLOW_2); - after(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); + before(grammarAccess.getFloat64Access().getFloat64Keyword_1()); + match(input,Float64,FOLLOW_2); + after(grammarAccess.getFloat64Access().getFloat64Keyword_1()); } @@ -42601,26 +33898,26 @@ public final void rule__Int8Array__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Int8Array__Group__1__Impl" + // $ANTLR end "rule__Float64__Group__1__Impl" - // $ANTLR start "rule__Uint8Array__Group__0" - // InternalRos.g:14199:1: rule__Uint8Array__Group__0 : rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 ; - public final void rule__Uint8Array__Group__0() throws RecognitionException { + // $ANTLR start "rule__String0__Group__0" + // InternalRosParser.g:11348:1: rule__String0__Group__0 : rule__String0__Group__0__Impl rule__String0__Group__1 ; + public final void rule__String0__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14203:1: ( rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 ) - // InternalRos.g:14204:2: rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 + // InternalRosParser.g:11352:1: ( rule__String0__Group__0__Impl rule__String0__Group__1 ) + // InternalRosParser.g:11353:2: rule__String0__Group__0__Impl rule__String0__Group__1 { - pushFollow(FOLLOW_87); - rule__Uint8Array__Group__0__Impl(); + pushFollow(FOLLOW_73); + rule__String0__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Uint8Array__Group__1(); + rule__String0__Group__1(); state._fsp--; @@ -42639,29 +33936,29 @@ public final void rule__Uint8Array__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint8Array__Group__0" + // $ANTLR end "rule__String0__Group__0" - // $ANTLR start "rule__Uint8Array__Group__0__Impl" - // InternalRos.g:14211:1: rule__Uint8Array__Group__0__Impl : ( () ) ; - public final void rule__Uint8Array__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__String0__Group__0__Impl" + // InternalRosParser.g:11360:1: rule__String0__Group__0__Impl : ( () ) ; + public final void rule__String0__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14215:1: ( ( () ) ) - // InternalRos.g:14216:1: ( () ) + // InternalRosParser.g:11364:1: ( ( () ) ) + // InternalRosParser.g:11365:1: ( () ) { - // InternalRos.g:14216:1: ( () ) - // InternalRos.g:14217:2: () + // InternalRosParser.g:11365:1: ( () ) + // InternalRosParser.g:11366:2: () { - before(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); - // InternalRos.g:14218:2: () - // InternalRos.g:14218:3: + before(grammarAccess.getString0Access().getStringAction_0()); + // InternalRosParser.g:11367:2: () + // InternalRosParser.g:11367:3: { } - after(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); + after(grammarAccess.getString0Access().getStringAction_0()); } @@ -42676,21 +33973,21 @@ public final void rule__Uint8Array__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Uint8Array__Group__0__Impl" + // $ANTLR end "rule__String0__Group__0__Impl" - // $ANTLR start "rule__Uint8Array__Group__1" - // InternalRos.g:14226:1: rule__Uint8Array__Group__1 : rule__Uint8Array__Group__1__Impl ; - public final void rule__Uint8Array__Group__1() throws RecognitionException { + // $ANTLR start "rule__String0__Group__1" + // InternalRosParser.g:11375:1: rule__String0__Group__1 : rule__String0__Group__1__Impl ; + public final void rule__String0__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14230:1: ( rule__Uint8Array__Group__1__Impl ) - // InternalRos.g:14231:2: rule__Uint8Array__Group__1__Impl + // InternalRosParser.g:11379:1: ( rule__String0__Group__1__Impl ) + // InternalRosParser.g:11380:2: rule__String0__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Uint8Array__Group__1__Impl(); + rule__String0__Group__1__Impl(); state._fsp--; @@ -42709,25 +34006,25 @@ public final void rule__Uint8Array__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint8Array__Group__1" + // $ANTLR end "rule__String0__Group__1" - // $ANTLR start "rule__Uint8Array__Group__1__Impl" - // InternalRos.g:14237:1: rule__Uint8Array__Group__1__Impl : ( 'uint8[]' ) ; - public final void rule__Uint8Array__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__String0__Group__1__Impl" + // InternalRosParser.g:11386:1: rule__String0__Group__1__Impl : ( String_1 ) ; + public final void rule__String0__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14241:1: ( ( 'uint8[]' ) ) - // InternalRos.g:14242:1: ( 'uint8[]' ) + // InternalRosParser.g:11390:1: ( ( String_1 ) ) + // InternalRosParser.g:11391:1: ( String_1 ) { - // InternalRos.g:14242:1: ( 'uint8[]' ) - // InternalRos.g:14243:2: 'uint8[]' + // InternalRosParser.g:11391:1: ( String_1 ) + // InternalRosParser.g:11392:2: String_1 { - before(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); - match(input,102,FOLLOW_2); - after(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); + before(grammarAccess.getString0Access().getStringKeyword_1()); + match(input,String_1,FOLLOW_2); + after(grammarAccess.getString0Access().getStringKeyword_1()); } @@ -42746,26 +34043,26 @@ public final void rule__Uint8Array__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Uint8Array__Group__1__Impl" + // $ANTLR end "rule__String0__Group__1__Impl" - // $ANTLR start "rule__Int16Array__Group__0" - // InternalRos.g:14253:1: rule__Int16Array__Group__0 : rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 ; - public final void rule__Int16Array__Group__0() throws RecognitionException { + // $ANTLR start "rule__Byte__Group__0" + // InternalRosParser.g:11402:1: rule__Byte__Group__0 : rule__Byte__Group__0__Impl rule__Byte__Group__1 ; + public final void rule__Byte__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14257:1: ( rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 ) - // InternalRos.g:14258:2: rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 + // InternalRosParser.g:11406:1: ( rule__Byte__Group__0__Impl rule__Byte__Group__1 ) + // InternalRosParser.g:11407:2: rule__Byte__Group__0__Impl rule__Byte__Group__1 { - pushFollow(FOLLOW_88); - rule__Int16Array__Group__0__Impl(); + pushFollow(FOLLOW_74); + rule__Byte__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Int16Array__Group__1(); + rule__Byte__Group__1(); state._fsp--; @@ -42784,29 +34081,29 @@ public final void rule__Int16Array__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int16Array__Group__0" + // $ANTLR end "rule__Byte__Group__0" - // $ANTLR start "rule__Int16Array__Group__0__Impl" - // InternalRos.g:14265:1: rule__Int16Array__Group__0__Impl : ( () ) ; - public final void rule__Int16Array__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Byte__Group__0__Impl" + // InternalRosParser.g:11414:1: rule__Byte__Group__0__Impl : ( () ) ; + public final void rule__Byte__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14269:1: ( ( () ) ) - // InternalRos.g:14270:1: ( () ) + // InternalRosParser.g:11418:1: ( ( () ) ) + // InternalRosParser.g:11419:1: ( () ) { - // InternalRos.g:14270:1: ( () ) - // InternalRos.g:14271:2: () + // InternalRosParser.g:11419:1: ( () ) + // InternalRosParser.g:11420:2: () { - before(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); - // InternalRos.g:14272:2: () - // InternalRos.g:14272:3: + before(grammarAccess.getByteAccess().getByteAction_0()); + // InternalRosParser.g:11421:2: () + // InternalRosParser.g:11421:3: { } - after(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); + after(grammarAccess.getByteAccess().getByteAction_0()); } @@ -42821,21 +34118,21 @@ public final void rule__Int16Array__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Int16Array__Group__0__Impl" + // $ANTLR end "rule__Byte__Group__0__Impl" - // $ANTLR start "rule__Int16Array__Group__1" - // InternalRos.g:14280:1: rule__Int16Array__Group__1 : rule__Int16Array__Group__1__Impl ; - public final void rule__Int16Array__Group__1() throws RecognitionException { + // $ANTLR start "rule__Byte__Group__1" + // InternalRosParser.g:11429:1: rule__Byte__Group__1 : rule__Byte__Group__1__Impl ; + public final void rule__Byte__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14284:1: ( rule__Int16Array__Group__1__Impl ) - // InternalRos.g:14285:2: rule__Int16Array__Group__1__Impl + // InternalRosParser.g:11433:1: ( rule__Byte__Group__1__Impl ) + // InternalRosParser.g:11434:2: rule__Byte__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Int16Array__Group__1__Impl(); + rule__Byte__Group__1__Impl(); state._fsp--; @@ -42854,25 +34151,25 @@ public final void rule__Int16Array__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int16Array__Group__1" + // $ANTLR end "rule__Byte__Group__1" - // $ANTLR start "rule__Int16Array__Group__1__Impl" - // InternalRos.g:14291:1: rule__Int16Array__Group__1__Impl : ( 'int16[]' ) ; - public final void rule__Int16Array__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Byte__Group__1__Impl" + // InternalRosParser.g:11440:1: rule__Byte__Group__1__Impl : ( Byte ) ; + public final void rule__Byte__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14295:1: ( ( 'int16[]' ) ) - // InternalRos.g:14296:1: ( 'int16[]' ) + // InternalRosParser.g:11444:1: ( ( Byte ) ) + // InternalRosParser.g:11445:1: ( Byte ) { - // InternalRos.g:14296:1: ( 'int16[]' ) - // InternalRos.g:14297:2: 'int16[]' + // InternalRosParser.g:11445:1: ( Byte ) + // InternalRosParser.g:11446:2: Byte { - before(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); - match(input,103,FOLLOW_2); - after(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); + before(grammarAccess.getByteAccess().getByteKeyword_1()); + match(input,Byte,FOLLOW_2); + after(grammarAccess.getByteAccess().getByteKeyword_1()); } @@ -42891,26 +34188,26 @@ public final void rule__Int16Array__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Int16Array__Group__1__Impl" + // $ANTLR end "rule__Byte__Group__1__Impl" - // $ANTLR start "rule__Uint16Array__Group__0" - // InternalRos.g:14307:1: rule__Uint16Array__Group__0 : rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 ; - public final void rule__Uint16Array__Group__0() throws RecognitionException { + // $ANTLR start "rule__Time__Group__0" + // InternalRosParser.g:11456:1: rule__Time__Group__0 : rule__Time__Group__0__Impl rule__Time__Group__1 ; + public final void rule__Time__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14311:1: ( rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 ) - // InternalRos.g:14312:2: rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 + // InternalRosParser.g:11460:1: ( rule__Time__Group__0__Impl rule__Time__Group__1 ) + // InternalRosParser.g:11461:2: rule__Time__Group__0__Impl rule__Time__Group__1 { - pushFollow(FOLLOW_89); - rule__Uint16Array__Group__0__Impl(); + pushFollow(FOLLOW_75); + rule__Time__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Uint16Array__Group__1(); + rule__Time__Group__1(); state._fsp--; @@ -42929,29 +34226,29 @@ public final void rule__Uint16Array__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint16Array__Group__0" + // $ANTLR end "rule__Time__Group__0" - // $ANTLR start "rule__Uint16Array__Group__0__Impl" - // InternalRos.g:14319:1: rule__Uint16Array__Group__0__Impl : ( () ) ; - public final void rule__Uint16Array__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Time__Group__0__Impl" + // InternalRosParser.g:11468:1: rule__Time__Group__0__Impl : ( () ) ; + public final void rule__Time__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14323:1: ( ( () ) ) - // InternalRos.g:14324:1: ( () ) + // InternalRosParser.g:11472:1: ( ( () ) ) + // InternalRosParser.g:11473:1: ( () ) { - // InternalRos.g:14324:1: ( () ) - // InternalRos.g:14325:2: () + // InternalRosParser.g:11473:1: ( () ) + // InternalRosParser.g:11474:2: () { - before(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); - // InternalRos.g:14326:2: () - // InternalRos.g:14326:3: + before(grammarAccess.getTimeAccess().getTimeAction_0()); + // InternalRosParser.g:11475:2: () + // InternalRosParser.g:11475:3: { } - after(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); + after(grammarAccess.getTimeAccess().getTimeAction_0()); } @@ -42966,21 +34263,21 @@ public final void rule__Uint16Array__Group__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Uint16Array__Group__0__Impl" + // $ANTLR end "rule__Time__Group__0__Impl" - // $ANTLR start "rule__Uint16Array__Group__1" - // InternalRos.g:14334:1: rule__Uint16Array__Group__1 : rule__Uint16Array__Group__1__Impl ; - public final void rule__Uint16Array__Group__1() throws RecognitionException { + // $ANTLR start "rule__Time__Group__1" + // InternalRosParser.g:11483:1: rule__Time__Group__1 : rule__Time__Group__1__Impl ; + public final void rule__Time__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14338:1: ( rule__Uint16Array__Group__1__Impl ) - // InternalRos.g:14339:2: rule__Uint16Array__Group__1__Impl + // InternalRosParser.g:11487:1: ( rule__Time__Group__1__Impl ) + // InternalRosParser.g:11488:2: rule__Time__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Uint16Array__Group__1__Impl(); + rule__Time__Group__1__Impl(); state._fsp--; @@ -42999,25 +34296,25 @@ public final void rule__Uint16Array__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint16Array__Group__1" + // $ANTLR end "rule__Time__Group__1" - // $ANTLR start "rule__Uint16Array__Group__1__Impl" - // InternalRos.g:14345:1: rule__Uint16Array__Group__1__Impl : ( 'uint16[]' ) ; - public final void rule__Uint16Array__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Time__Group__1__Impl" + // InternalRosParser.g:11494:1: rule__Time__Group__1__Impl : ( Time ) ; + public final void rule__Time__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14349:1: ( ( 'uint16[]' ) ) - // InternalRos.g:14350:1: ( 'uint16[]' ) + // InternalRosParser.g:11498:1: ( ( Time ) ) + // InternalRosParser.g:11499:1: ( Time ) { - // InternalRos.g:14350:1: ( 'uint16[]' ) - // InternalRos.g:14351:2: 'uint16[]' + // InternalRosParser.g:11499:1: ( Time ) + // InternalRosParser.g:11500:2: Time { - before(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); - match(input,104,FOLLOW_2); - after(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); + before(grammarAccess.getTimeAccess().getTimeKeyword_1()); + match(input,Time,FOLLOW_2); + after(grammarAccess.getTimeAccess().getTimeKeyword_1()); } @@ -43036,26 +34333,26 @@ public final void rule__Uint16Array__Group__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Uint16Array__Group__1__Impl" + // $ANTLR end "rule__Time__Group__1__Impl" - // $ANTLR start "rule__Int32Array__Group__0" - // InternalRos.g:14361:1: rule__Int32Array__Group__0 : rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 ; - public final void rule__Int32Array__Group__0() throws RecognitionException { + // $ANTLR start "rule__Duration__Group__0" + // InternalRosParser.g:11510:1: rule__Duration__Group__0 : rule__Duration__Group__0__Impl rule__Duration__Group__1 ; + public final void rule__Duration__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14365:1: ( rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 ) - // InternalRos.g:14366:2: rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 + // InternalRosParser.g:11514:1: ( rule__Duration__Group__0__Impl rule__Duration__Group__1 ) + // InternalRosParser.g:11515:2: rule__Duration__Group__0__Impl rule__Duration__Group__1 { - pushFollow(FOLLOW_90); - rule__Int32Array__Group__0__Impl(); + pushFollow(FOLLOW_76); + rule__Duration__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Int32Array__Group__1(); + rule__Duration__Group__1(); state._fsp--; @@ -43074,29 +34371,29 @@ public final void rule__Int32Array__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int32Array__Group__0" + // $ANTLR end "rule__Duration__Group__0" - // $ANTLR start "rule__Int32Array__Group__0__Impl" - // InternalRos.g:14373:1: rule__Int32Array__Group__0__Impl : ( () ) ; - public final void rule__Int32Array__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Duration__Group__0__Impl" + // InternalRosParser.g:11522:1: rule__Duration__Group__0__Impl : ( () ) ; + public final void rule__Duration__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14377:1: ( ( () ) ) - // InternalRos.g:14378:1: ( () ) + // InternalRosParser.g:11526:1: ( ( () ) ) + // InternalRosParser.g:11527:1: ( () ) { - // InternalRos.g:14378:1: ( () ) - // InternalRos.g:14379:2: () + // InternalRosParser.g:11527:1: ( () ) + // InternalRosParser.g:11528:2: () { - before(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); - // InternalRos.g:14380:2: () - // InternalRos.g:14380:3: + before(grammarAccess.getDurationAccess().getDurationAction_0()); + // InternalRosParser.g:11529:2: () + // InternalRosParser.g:11529:3: { } - after(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); + after(grammarAccess.getDurationAccess().getDurationAction_0()); } @@ -43111,21 +34408,21 @@ public final void rule__Int32Array__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Int32Array__Group__0__Impl" + // $ANTLR end "rule__Duration__Group__0__Impl" - // $ANTLR start "rule__Int32Array__Group__1" - // InternalRos.g:14388:1: rule__Int32Array__Group__1 : rule__Int32Array__Group__1__Impl ; - public final void rule__Int32Array__Group__1() throws RecognitionException { + // $ANTLR start "rule__Duration__Group__1" + // InternalRosParser.g:11537:1: rule__Duration__Group__1 : rule__Duration__Group__1__Impl ; + public final void rule__Duration__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14392:1: ( rule__Int32Array__Group__1__Impl ) - // InternalRos.g:14393:2: rule__Int32Array__Group__1__Impl + // InternalRosParser.g:11541:1: ( rule__Duration__Group__1__Impl ) + // InternalRosParser.g:11542:2: rule__Duration__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Int32Array__Group__1__Impl(); + rule__Duration__Group__1__Impl(); state._fsp--; @@ -43144,25 +34441,25 @@ public final void rule__Int32Array__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int32Array__Group__1" + // $ANTLR end "rule__Duration__Group__1" - // $ANTLR start "rule__Int32Array__Group__1__Impl" - // InternalRos.g:14399:1: rule__Int32Array__Group__1__Impl : ( 'int32[]' ) ; - public final void rule__Int32Array__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Duration__Group__1__Impl" + // InternalRosParser.g:11548:1: rule__Duration__Group__1__Impl : ( Duration ) ; + public final void rule__Duration__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14403:1: ( ( 'int32[]' ) ) - // InternalRos.g:14404:1: ( 'int32[]' ) + // InternalRosParser.g:11552:1: ( ( Duration ) ) + // InternalRosParser.g:11553:1: ( Duration ) { - // InternalRos.g:14404:1: ( 'int32[]' ) - // InternalRos.g:14405:2: 'int32[]' + // InternalRosParser.g:11553:1: ( Duration ) + // InternalRosParser.g:11554:2: Duration { - before(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); - match(input,105,FOLLOW_2); - after(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); + before(grammarAccess.getDurationAccess().getDurationKeyword_1()); + match(input,Duration,FOLLOW_2); + after(grammarAccess.getDurationAccess().getDurationKeyword_1()); } @@ -43181,26 +34478,26 @@ public final void rule__Int32Array__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Int32Array__Group__1__Impl" + // $ANTLR end "rule__Duration__Group__1__Impl" - // $ANTLR start "rule__Uint32Array__Group__0" - // InternalRos.g:14415:1: rule__Uint32Array__Group__0 : rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 ; - public final void rule__Uint32Array__Group__0() throws RecognitionException { + // $ANTLR start "rule__BoolArray__Group__0" + // InternalRosParser.g:11564:1: rule__BoolArray__Group__0 : rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 ; + public final void rule__BoolArray__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14419:1: ( rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 ) - // InternalRos.g:14420:2: rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 + // InternalRosParser.g:11568:1: ( rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 ) + // InternalRosParser.g:11569:2: rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 { - pushFollow(FOLLOW_91); - rule__Uint32Array__Group__0__Impl(); + pushFollow(FOLLOW_77); + rule__BoolArray__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Uint32Array__Group__1(); + rule__BoolArray__Group__1(); state._fsp--; @@ -43219,29 +34516,29 @@ public final void rule__Uint32Array__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint32Array__Group__0" + // $ANTLR end "rule__BoolArray__Group__0" - // $ANTLR start "rule__Uint32Array__Group__0__Impl" - // InternalRos.g:14427:1: rule__Uint32Array__Group__0__Impl : ( () ) ; - public final void rule__Uint32Array__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__BoolArray__Group__0__Impl" + // InternalRosParser.g:11576:1: rule__BoolArray__Group__0__Impl : ( () ) ; + public final void rule__BoolArray__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14431:1: ( ( () ) ) - // InternalRos.g:14432:1: ( () ) + // InternalRosParser.g:11580:1: ( ( () ) ) + // InternalRosParser.g:11581:1: ( () ) { - // InternalRos.g:14432:1: ( () ) - // InternalRos.g:14433:2: () + // InternalRosParser.g:11581:1: ( () ) + // InternalRosParser.g:11582:2: () { - before(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); - // InternalRos.g:14434:2: () - // InternalRos.g:14434:3: + before(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); + // InternalRosParser.g:11583:2: () + // InternalRosParser.g:11583:3: { } - after(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); + after(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); } @@ -43256,21 +34553,21 @@ public final void rule__Uint32Array__Group__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Uint32Array__Group__0__Impl" + // $ANTLR end "rule__BoolArray__Group__0__Impl" - // $ANTLR start "rule__Uint32Array__Group__1" - // InternalRos.g:14442:1: rule__Uint32Array__Group__1 : rule__Uint32Array__Group__1__Impl ; - public final void rule__Uint32Array__Group__1() throws RecognitionException { + // $ANTLR start "rule__BoolArray__Group__1" + // InternalRosParser.g:11591:1: rule__BoolArray__Group__1 : rule__BoolArray__Group__1__Impl ; + public final void rule__BoolArray__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14446:1: ( rule__Uint32Array__Group__1__Impl ) - // InternalRos.g:14447:2: rule__Uint32Array__Group__1__Impl + // InternalRosParser.g:11595:1: ( rule__BoolArray__Group__1__Impl ) + // InternalRosParser.g:11596:2: rule__BoolArray__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Uint32Array__Group__1__Impl(); + rule__BoolArray__Group__1__Impl(); state._fsp--; @@ -43289,25 +34586,25 @@ public final void rule__Uint32Array__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint32Array__Group__1" + // $ANTLR end "rule__BoolArray__Group__1" - // $ANTLR start "rule__Uint32Array__Group__1__Impl" - // InternalRos.g:14453:1: rule__Uint32Array__Group__1__Impl : ( 'uint32[]' ) ; - public final void rule__Uint32Array__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__BoolArray__Group__1__Impl" + // InternalRosParser.g:11602:1: rule__BoolArray__Group__1__Impl : ( Bool_1 ) ; + public final void rule__BoolArray__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14457:1: ( ( 'uint32[]' ) ) - // InternalRos.g:14458:1: ( 'uint32[]' ) + // InternalRosParser.g:11606:1: ( ( Bool_1 ) ) + // InternalRosParser.g:11607:1: ( Bool_1 ) { - // InternalRos.g:14458:1: ( 'uint32[]' ) - // InternalRos.g:14459:2: 'uint32[]' + // InternalRosParser.g:11607:1: ( Bool_1 ) + // InternalRosParser.g:11608:2: Bool_1 { - before(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); - match(input,106,FOLLOW_2); - after(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); + before(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); + match(input,Bool_1,FOLLOW_2); + after(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); } @@ -43326,26 +34623,26 @@ public final void rule__Uint32Array__Group__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Uint32Array__Group__1__Impl" + // $ANTLR end "rule__BoolArray__Group__1__Impl" - // $ANTLR start "rule__Int64Array__Group__0" - // InternalRos.g:14469:1: rule__Int64Array__Group__0 : rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 ; - public final void rule__Int64Array__Group__0() throws RecognitionException { + // $ANTLR start "rule__Int8Array__Group__0" + // InternalRosParser.g:11618:1: rule__Int8Array__Group__0 : rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 ; + public final void rule__Int8Array__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14473:1: ( rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 ) - // InternalRos.g:14474:2: rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 + // InternalRosParser.g:11622:1: ( rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 ) + // InternalRosParser.g:11623:2: rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 { - pushFollow(FOLLOW_92); - rule__Int64Array__Group__0__Impl(); + pushFollow(FOLLOW_78); + rule__Int8Array__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Int64Array__Group__1(); + rule__Int8Array__Group__1(); state._fsp--; @@ -43364,29 +34661,29 @@ public final void rule__Int64Array__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int64Array__Group__0" + // $ANTLR end "rule__Int8Array__Group__0" - // $ANTLR start "rule__Int64Array__Group__0__Impl" - // InternalRos.g:14481:1: rule__Int64Array__Group__0__Impl : ( () ) ; - public final void rule__Int64Array__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Int8Array__Group__0__Impl" + // InternalRosParser.g:11630:1: rule__Int8Array__Group__0__Impl : ( () ) ; + public final void rule__Int8Array__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14485:1: ( ( () ) ) - // InternalRos.g:14486:1: ( () ) + // InternalRosParser.g:11634:1: ( ( () ) ) + // InternalRosParser.g:11635:1: ( () ) { - // InternalRos.g:14486:1: ( () ) - // InternalRos.g:14487:2: () + // InternalRosParser.g:11635:1: ( () ) + // InternalRosParser.g:11636:2: () { - before(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); - // InternalRos.g:14488:2: () - // InternalRos.g:14488:3: + before(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); + // InternalRosParser.g:11637:2: () + // InternalRosParser.g:11637:3: { } - after(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); + after(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); } @@ -43401,21 +34698,21 @@ public final void rule__Int64Array__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Int64Array__Group__0__Impl" + // $ANTLR end "rule__Int8Array__Group__0__Impl" - // $ANTLR start "rule__Int64Array__Group__1" - // InternalRos.g:14496:1: rule__Int64Array__Group__1 : rule__Int64Array__Group__1__Impl ; - public final void rule__Int64Array__Group__1() throws RecognitionException { + // $ANTLR start "rule__Int8Array__Group__1" + // InternalRosParser.g:11645:1: rule__Int8Array__Group__1 : rule__Int8Array__Group__1__Impl ; + public final void rule__Int8Array__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14500:1: ( rule__Int64Array__Group__1__Impl ) - // InternalRos.g:14501:2: rule__Int64Array__Group__1__Impl + // InternalRosParser.g:11649:1: ( rule__Int8Array__Group__1__Impl ) + // InternalRosParser.g:11650:2: rule__Int8Array__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Int64Array__Group__1__Impl(); + rule__Int8Array__Group__1__Impl(); state._fsp--; @@ -43434,25 +34731,25 @@ public final void rule__Int64Array__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Int64Array__Group__1" + // $ANTLR end "rule__Int8Array__Group__1" - // $ANTLR start "rule__Int64Array__Group__1__Impl" - // InternalRos.g:14507:1: rule__Int64Array__Group__1__Impl : ( 'int64[]' ) ; - public final void rule__Int64Array__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Int8Array__Group__1__Impl" + // InternalRosParser.g:11656:1: rule__Int8Array__Group__1__Impl : ( Int8_1 ) ; + public final void rule__Int8Array__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14511:1: ( ( 'int64[]' ) ) - // InternalRos.g:14512:1: ( 'int64[]' ) + // InternalRosParser.g:11660:1: ( ( Int8_1 ) ) + // InternalRosParser.g:11661:1: ( Int8_1 ) { - // InternalRos.g:14512:1: ( 'int64[]' ) - // InternalRos.g:14513:2: 'int64[]' + // InternalRosParser.g:11661:1: ( Int8_1 ) + // InternalRosParser.g:11662:2: Int8_1 { - before(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); - match(input,107,FOLLOW_2); - after(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); + before(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); + match(input,Int8_1,FOLLOW_2); + after(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); } @@ -43471,26 +34768,26 @@ public final void rule__Int64Array__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Int64Array__Group__1__Impl" + // $ANTLR end "rule__Int8Array__Group__1__Impl" - // $ANTLR start "rule__Uint64Array__Group__0" - // InternalRos.g:14523:1: rule__Uint64Array__Group__0 : rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 ; - public final void rule__Uint64Array__Group__0() throws RecognitionException { + // $ANTLR start "rule__Uint8Array__Group__0" + // InternalRosParser.g:11672:1: rule__Uint8Array__Group__0 : rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 ; + public final void rule__Uint8Array__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14527:1: ( rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 ) - // InternalRos.g:14528:2: rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 + // InternalRosParser.g:11676:1: ( rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 ) + // InternalRosParser.g:11677:2: rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 { - pushFollow(FOLLOW_93); - rule__Uint64Array__Group__0__Impl(); + pushFollow(FOLLOW_79); + rule__Uint8Array__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Uint64Array__Group__1(); + rule__Uint8Array__Group__1(); state._fsp--; @@ -43509,29 +34806,29 @@ public final void rule__Uint64Array__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint64Array__Group__0" + // $ANTLR end "rule__Uint8Array__Group__0" - // $ANTLR start "rule__Uint64Array__Group__0__Impl" - // InternalRos.g:14535:1: rule__Uint64Array__Group__0__Impl : ( () ) ; - public final void rule__Uint64Array__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint8Array__Group__0__Impl" + // InternalRosParser.g:11684:1: rule__Uint8Array__Group__0__Impl : ( () ) ; + public final void rule__Uint8Array__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14539:1: ( ( () ) ) - // InternalRos.g:14540:1: ( () ) + // InternalRosParser.g:11688:1: ( ( () ) ) + // InternalRosParser.g:11689:1: ( () ) { - // InternalRos.g:14540:1: ( () ) - // InternalRos.g:14541:2: () + // InternalRosParser.g:11689:1: ( () ) + // InternalRosParser.g:11690:2: () { - before(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); - // InternalRos.g:14542:2: () - // InternalRos.g:14542:3: + before(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); + // InternalRosParser.g:11691:2: () + // InternalRosParser.g:11691:3: { } - after(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); + after(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); } @@ -43546,21 +34843,21 @@ public final void rule__Uint64Array__Group__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Uint64Array__Group__0__Impl" + // $ANTLR end "rule__Uint8Array__Group__0__Impl" - // $ANTLR start "rule__Uint64Array__Group__1" - // InternalRos.g:14550:1: rule__Uint64Array__Group__1 : rule__Uint64Array__Group__1__Impl ; - public final void rule__Uint64Array__Group__1() throws RecognitionException { + // $ANTLR start "rule__Uint8Array__Group__1" + // InternalRosParser.g:11699:1: rule__Uint8Array__Group__1 : rule__Uint8Array__Group__1__Impl ; + public final void rule__Uint8Array__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14554:1: ( rule__Uint64Array__Group__1__Impl ) - // InternalRos.g:14555:2: rule__Uint64Array__Group__1__Impl + // InternalRosParser.g:11703:1: ( rule__Uint8Array__Group__1__Impl ) + // InternalRosParser.g:11704:2: rule__Uint8Array__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Uint64Array__Group__1__Impl(); + rule__Uint8Array__Group__1__Impl(); state._fsp--; @@ -43579,25 +34876,25 @@ public final void rule__Uint64Array__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Uint64Array__Group__1" + // $ANTLR end "rule__Uint8Array__Group__1" - // $ANTLR start "rule__Uint64Array__Group__1__Impl" - // InternalRos.g:14561:1: rule__Uint64Array__Group__1__Impl : ( 'uint64[]' ) ; - public final void rule__Uint64Array__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint8Array__Group__1__Impl" + // InternalRosParser.g:11710:1: rule__Uint8Array__Group__1__Impl : ( Uint8_1 ) ; + public final void rule__Uint8Array__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14565:1: ( ( 'uint64[]' ) ) - // InternalRos.g:14566:1: ( 'uint64[]' ) + // InternalRosParser.g:11714:1: ( ( Uint8_1 ) ) + // InternalRosParser.g:11715:1: ( Uint8_1 ) { - // InternalRos.g:14566:1: ( 'uint64[]' ) - // InternalRos.g:14567:2: 'uint64[]' + // InternalRosParser.g:11715:1: ( Uint8_1 ) + // InternalRosParser.g:11716:2: Uint8_1 { - before(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); - match(input,108,FOLLOW_2); - after(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); + before(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); + match(input,Uint8_1,FOLLOW_2); + after(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); } @@ -43616,26 +34913,26 @@ public final void rule__Uint64Array__Group__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Uint64Array__Group__1__Impl" + // $ANTLR end "rule__Uint8Array__Group__1__Impl" - // $ANTLR start "rule__Float32Array__Group__0" - // InternalRos.g:14577:1: rule__Float32Array__Group__0 : rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 ; - public final void rule__Float32Array__Group__0() throws RecognitionException { + // $ANTLR start "rule__Int16Array__Group__0" + // InternalRosParser.g:11726:1: rule__Int16Array__Group__0 : rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 ; + public final void rule__Int16Array__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14581:1: ( rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 ) - // InternalRos.g:14582:2: rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 + // InternalRosParser.g:11730:1: ( rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 ) + // InternalRosParser.g:11731:2: rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 { - pushFollow(FOLLOW_94); - rule__Float32Array__Group__0__Impl(); + pushFollow(FOLLOW_80); + rule__Int16Array__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Float32Array__Group__1(); + rule__Int16Array__Group__1(); state._fsp--; @@ -43654,29 +34951,29 @@ public final void rule__Float32Array__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float32Array__Group__0" + // $ANTLR end "rule__Int16Array__Group__0" - // $ANTLR start "rule__Float32Array__Group__0__Impl" - // InternalRos.g:14589:1: rule__Float32Array__Group__0__Impl : ( () ) ; - public final void rule__Float32Array__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Int16Array__Group__0__Impl" + // InternalRosParser.g:11738:1: rule__Int16Array__Group__0__Impl : ( () ) ; + public final void rule__Int16Array__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14593:1: ( ( () ) ) - // InternalRos.g:14594:1: ( () ) + // InternalRosParser.g:11742:1: ( ( () ) ) + // InternalRosParser.g:11743:1: ( () ) { - // InternalRos.g:14594:1: ( () ) - // InternalRos.g:14595:2: () + // InternalRosParser.g:11743:1: ( () ) + // InternalRosParser.g:11744:2: () { - before(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); - // InternalRos.g:14596:2: () - // InternalRos.g:14596:3: + before(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); + // InternalRosParser.g:11745:2: () + // InternalRosParser.g:11745:3: { } - after(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); + after(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); } @@ -43691,21 +34988,21 @@ public final void rule__Float32Array__Group__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Float32Array__Group__0__Impl" + // $ANTLR end "rule__Int16Array__Group__0__Impl" - // $ANTLR start "rule__Float32Array__Group__1" - // InternalRos.g:14604:1: rule__Float32Array__Group__1 : rule__Float32Array__Group__1__Impl ; - public final void rule__Float32Array__Group__1() throws RecognitionException { + // $ANTLR start "rule__Int16Array__Group__1" + // InternalRosParser.g:11753:1: rule__Int16Array__Group__1 : rule__Int16Array__Group__1__Impl ; + public final void rule__Int16Array__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14608:1: ( rule__Float32Array__Group__1__Impl ) - // InternalRos.g:14609:2: rule__Float32Array__Group__1__Impl + // InternalRosParser.g:11757:1: ( rule__Int16Array__Group__1__Impl ) + // InternalRosParser.g:11758:2: rule__Int16Array__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Float32Array__Group__1__Impl(); + rule__Int16Array__Group__1__Impl(); state._fsp--; @@ -43724,25 +35021,25 @@ public final void rule__Float32Array__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float32Array__Group__1" - + // $ANTLR end "rule__Int16Array__Group__1" - // $ANTLR start "rule__Float32Array__Group__1__Impl" - // InternalRos.g:14615:1: rule__Float32Array__Group__1__Impl : ( 'float32[]' ) ; - public final void rule__Float32Array__Group__1__Impl() throws RecognitionException { + + // $ANTLR start "rule__Int16Array__Group__1__Impl" + // InternalRosParser.g:11764:1: rule__Int16Array__Group__1__Impl : ( Int16_1 ) ; + public final void rule__Int16Array__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14619:1: ( ( 'float32[]' ) ) - // InternalRos.g:14620:1: ( 'float32[]' ) + // InternalRosParser.g:11768:1: ( ( Int16_1 ) ) + // InternalRosParser.g:11769:1: ( Int16_1 ) { - // InternalRos.g:14620:1: ( 'float32[]' ) - // InternalRos.g:14621:2: 'float32[]' + // InternalRosParser.g:11769:1: ( Int16_1 ) + // InternalRosParser.g:11770:2: Int16_1 { - before(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); - match(input,109,FOLLOW_2); - after(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); + before(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); + match(input,Int16_1,FOLLOW_2); + after(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); } @@ -43761,26 +35058,26 @@ public final void rule__Float32Array__Group__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Float32Array__Group__1__Impl" + // $ANTLR end "rule__Int16Array__Group__1__Impl" - // $ANTLR start "rule__Float64Array__Group__0" - // InternalRos.g:14631:1: rule__Float64Array__Group__0 : rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 ; - public final void rule__Float64Array__Group__0() throws RecognitionException { + // $ANTLR start "rule__Uint16Array__Group__0" + // InternalRosParser.g:11780:1: rule__Uint16Array__Group__0 : rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 ; + public final void rule__Uint16Array__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14635:1: ( rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 ) - // InternalRos.g:14636:2: rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 + // InternalRosParser.g:11784:1: ( rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 ) + // InternalRosParser.g:11785:2: rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 { - pushFollow(FOLLOW_95); - rule__Float64Array__Group__0__Impl(); + pushFollow(FOLLOW_81); + rule__Uint16Array__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Float64Array__Group__1(); + rule__Uint16Array__Group__1(); state._fsp--; @@ -43799,29 +35096,29 @@ public final void rule__Float64Array__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float64Array__Group__0" + // $ANTLR end "rule__Uint16Array__Group__0" - // $ANTLR start "rule__Float64Array__Group__0__Impl" - // InternalRos.g:14643:1: rule__Float64Array__Group__0__Impl : ( () ) ; - public final void rule__Float64Array__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint16Array__Group__0__Impl" + // InternalRosParser.g:11792:1: rule__Uint16Array__Group__0__Impl : ( () ) ; + public final void rule__Uint16Array__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14647:1: ( ( () ) ) - // InternalRos.g:14648:1: ( () ) + // InternalRosParser.g:11796:1: ( ( () ) ) + // InternalRosParser.g:11797:1: ( () ) { - // InternalRos.g:14648:1: ( () ) - // InternalRos.g:14649:2: () + // InternalRosParser.g:11797:1: ( () ) + // InternalRosParser.g:11798:2: () { - before(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); - // InternalRos.g:14650:2: () - // InternalRos.g:14650:3: + before(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); + // InternalRosParser.g:11799:2: () + // InternalRosParser.g:11799:3: { } - after(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); + after(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); } @@ -43836,21 +35133,21 @@ public final void rule__Float64Array__Group__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Float64Array__Group__0__Impl" + // $ANTLR end "rule__Uint16Array__Group__0__Impl" - // $ANTLR start "rule__Float64Array__Group__1" - // InternalRos.g:14658:1: rule__Float64Array__Group__1 : rule__Float64Array__Group__1__Impl ; - public final void rule__Float64Array__Group__1() throws RecognitionException { + // $ANTLR start "rule__Uint16Array__Group__1" + // InternalRosParser.g:11807:1: rule__Uint16Array__Group__1 : rule__Uint16Array__Group__1__Impl ; + public final void rule__Uint16Array__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14662:1: ( rule__Float64Array__Group__1__Impl ) - // InternalRos.g:14663:2: rule__Float64Array__Group__1__Impl + // InternalRosParser.g:11811:1: ( rule__Uint16Array__Group__1__Impl ) + // InternalRosParser.g:11812:2: rule__Uint16Array__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Float64Array__Group__1__Impl(); + rule__Uint16Array__Group__1__Impl(); state._fsp--; @@ -43869,25 +35166,25 @@ public final void rule__Float64Array__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Float64Array__Group__1" + // $ANTLR end "rule__Uint16Array__Group__1" - // $ANTLR start "rule__Float64Array__Group__1__Impl" - // InternalRos.g:14669:1: rule__Float64Array__Group__1__Impl : ( 'float64[]' ) ; - public final void rule__Float64Array__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint16Array__Group__1__Impl" + // InternalRosParser.g:11818:1: rule__Uint16Array__Group__1__Impl : ( Uint16_1 ) ; + public final void rule__Uint16Array__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14673:1: ( ( 'float64[]' ) ) - // InternalRos.g:14674:1: ( 'float64[]' ) + // InternalRosParser.g:11822:1: ( ( Uint16_1 ) ) + // InternalRosParser.g:11823:1: ( Uint16_1 ) { - // InternalRos.g:14674:1: ( 'float64[]' ) - // InternalRos.g:14675:2: 'float64[]' + // InternalRosParser.g:11823:1: ( Uint16_1 ) + // InternalRosParser.g:11824:2: Uint16_1 { - before(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); - match(input,110,FOLLOW_2); - after(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); + before(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); + match(input,Uint16_1,FOLLOW_2); + after(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); } @@ -43906,26 +35203,26 @@ public final void rule__Float64Array__Group__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Float64Array__Group__1__Impl" + // $ANTLR end "rule__Uint16Array__Group__1__Impl" - // $ANTLR start "rule__String0Array__Group__0" - // InternalRos.g:14685:1: rule__String0Array__Group__0 : rule__String0Array__Group__0__Impl rule__String0Array__Group__1 ; - public final void rule__String0Array__Group__0() throws RecognitionException { + // $ANTLR start "rule__Int32Array__Group__0" + // InternalRosParser.g:11834:1: rule__Int32Array__Group__0 : rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 ; + public final void rule__Int32Array__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14689:1: ( rule__String0Array__Group__0__Impl rule__String0Array__Group__1 ) - // InternalRos.g:14690:2: rule__String0Array__Group__0__Impl rule__String0Array__Group__1 + // InternalRosParser.g:11838:1: ( rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 ) + // InternalRosParser.g:11839:2: rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 { - pushFollow(FOLLOW_96); - rule__String0Array__Group__0__Impl(); + pushFollow(FOLLOW_82); + rule__Int32Array__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__String0Array__Group__1(); + rule__Int32Array__Group__1(); state._fsp--; @@ -43944,29 +35241,29 @@ public final void rule__String0Array__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__String0Array__Group__0" + // $ANTLR end "rule__Int32Array__Group__0" - // $ANTLR start "rule__String0Array__Group__0__Impl" - // InternalRos.g:14697:1: rule__String0Array__Group__0__Impl : ( () ) ; - public final void rule__String0Array__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Int32Array__Group__0__Impl" + // InternalRosParser.g:11846:1: rule__Int32Array__Group__0__Impl : ( () ) ; + public final void rule__Int32Array__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14701:1: ( ( () ) ) - // InternalRos.g:14702:1: ( () ) + // InternalRosParser.g:11850:1: ( ( () ) ) + // InternalRosParser.g:11851:1: ( () ) { - // InternalRos.g:14702:1: ( () ) - // InternalRos.g:14703:2: () + // InternalRosParser.g:11851:1: ( () ) + // InternalRosParser.g:11852:2: () { - before(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); - // InternalRos.g:14704:2: () - // InternalRos.g:14704:3: + before(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); + // InternalRosParser.g:11853:2: () + // InternalRosParser.g:11853:3: { } - after(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); + after(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); } @@ -43981,21 +35278,21 @@ public final void rule__String0Array__Group__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__String0Array__Group__0__Impl" + // $ANTLR end "rule__Int32Array__Group__0__Impl" - // $ANTLR start "rule__String0Array__Group__1" - // InternalRos.g:14712:1: rule__String0Array__Group__1 : rule__String0Array__Group__1__Impl ; - public final void rule__String0Array__Group__1() throws RecognitionException { + // $ANTLR start "rule__Int32Array__Group__1" + // InternalRosParser.g:11861:1: rule__Int32Array__Group__1 : rule__Int32Array__Group__1__Impl ; + public final void rule__Int32Array__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14716:1: ( rule__String0Array__Group__1__Impl ) - // InternalRos.g:14717:2: rule__String0Array__Group__1__Impl + // InternalRosParser.g:11865:1: ( rule__Int32Array__Group__1__Impl ) + // InternalRosParser.g:11866:2: rule__Int32Array__Group__1__Impl { pushFollow(FOLLOW_2); - rule__String0Array__Group__1__Impl(); + rule__Int32Array__Group__1__Impl(); state._fsp--; @@ -44014,25 +35311,25 @@ public final void rule__String0Array__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__String0Array__Group__1" + // $ANTLR end "rule__Int32Array__Group__1" - // $ANTLR start "rule__String0Array__Group__1__Impl" - // InternalRos.g:14723:1: rule__String0Array__Group__1__Impl : ( 'string[]' ) ; - public final void rule__String0Array__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Int32Array__Group__1__Impl" + // InternalRosParser.g:11872:1: rule__Int32Array__Group__1__Impl : ( Int32_1 ) ; + public final void rule__Int32Array__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14727:1: ( ( 'string[]' ) ) - // InternalRos.g:14728:1: ( 'string[]' ) + // InternalRosParser.g:11876:1: ( ( Int32_1 ) ) + // InternalRosParser.g:11877:1: ( Int32_1 ) { - // InternalRos.g:14728:1: ( 'string[]' ) - // InternalRos.g:14729:2: 'string[]' + // InternalRosParser.g:11877:1: ( Int32_1 ) + // InternalRosParser.g:11878:2: Int32_1 { - before(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); - match(input,111,FOLLOW_2); - after(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); + before(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); + match(input,Int32_1,FOLLOW_2); + after(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); } @@ -44051,26 +35348,26 @@ public final void rule__String0Array__Group__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__String0Array__Group__1__Impl" + // $ANTLR end "rule__Int32Array__Group__1__Impl" - // $ANTLR start "rule__ByteArray__Group__0" - // InternalRos.g:14739:1: rule__ByteArray__Group__0 : rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 ; - public final void rule__ByteArray__Group__0() throws RecognitionException { + // $ANTLR start "rule__Uint32Array__Group__0" + // InternalRosParser.g:11888:1: rule__Uint32Array__Group__0 : rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 ; + public final void rule__Uint32Array__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14743:1: ( rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 ) - // InternalRos.g:14744:2: rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 + // InternalRosParser.g:11892:1: ( rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 ) + // InternalRosParser.g:11893:2: rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 { - pushFollow(FOLLOW_97); - rule__ByteArray__Group__0__Impl(); + pushFollow(FOLLOW_83); + rule__Uint32Array__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ByteArray__Group__1(); + rule__Uint32Array__Group__1(); state._fsp--; @@ -44089,29 +35386,29 @@ public final void rule__ByteArray__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ByteArray__Group__0" + // $ANTLR end "rule__Uint32Array__Group__0" - // $ANTLR start "rule__ByteArray__Group__0__Impl" - // InternalRos.g:14751:1: rule__ByteArray__Group__0__Impl : ( () ) ; - public final void rule__ByteArray__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint32Array__Group__0__Impl" + // InternalRosParser.g:11900:1: rule__Uint32Array__Group__0__Impl : ( () ) ; + public final void rule__Uint32Array__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14755:1: ( ( () ) ) - // InternalRos.g:14756:1: ( () ) + // InternalRosParser.g:11904:1: ( ( () ) ) + // InternalRosParser.g:11905:1: ( () ) { - // InternalRos.g:14756:1: ( () ) - // InternalRos.g:14757:2: () + // InternalRosParser.g:11905:1: ( () ) + // InternalRosParser.g:11906:2: () { - before(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); - // InternalRos.g:14758:2: () - // InternalRos.g:14758:3: + before(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); + // InternalRosParser.g:11907:2: () + // InternalRosParser.g:11907:3: { } - after(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); + after(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); } @@ -44126,21 +35423,21 @@ public final void rule__ByteArray__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ByteArray__Group__0__Impl" + // $ANTLR end "rule__Uint32Array__Group__0__Impl" - // $ANTLR start "rule__ByteArray__Group__1" - // InternalRos.g:14766:1: rule__ByteArray__Group__1 : rule__ByteArray__Group__1__Impl ; - public final void rule__ByteArray__Group__1() throws RecognitionException { + // $ANTLR start "rule__Uint32Array__Group__1" + // InternalRosParser.g:11915:1: rule__Uint32Array__Group__1 : rule__Uint32Array__Group__1__Impl ; + public final void rule__Uint32Array__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14770:1: ( rule__ByteArray__Group__1__Impl ) - // InternalRos.g:14771:2: rule__ByteArray__Group__1__Impl + // InternalRosParser.g:11919:1: ( rule__Uint32Array__Group__1__Impl ) + // InternalRosParser.g:11920:2: rule__Uint32Array__Group__1__Impl { pushFollow(FOLLOW_2); - rule__ByteArray__Group__1__Impl(); + rule__Uint32Array__Group__1__Impl(); state._fsp--; @@ -44159,25 +35456,25 @@ public final void rule__ByteArray__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ByteArray__Group__1" + // $ANTLR end "rule__Uint32Array__Group__1" - // $ANTLR start "rule__ByteArray__Group__1__Impl" - // InternalRos.g:14777:1: rule__ByteArray__Group__1__Impl : ( 'byte[]' ) ; - public final void rule__ByteArray__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint32Array__Group__1__Impl" + // InternalRosParser.g:11926:1: rule__Uint32Array__Group__1__Impl : ( Uint32_1 ) ; + public final void rule__Uint32Array__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14781:1: ( ( 'byte[]' ) ) - // InternalRos.g:14782:1: ( 'byte[]' ) + // InternalRosParser.g:11930:1: ( ( Uint32_1 ) ) + // InternalRosParser.g:11931:1: ( Uint32_1 ) { - // InternalRos.g:14782:1: ( 'byte[]' ) - // InternalRos.g:14783:2: 'byte[]' + // InternalRosParser.g:11931:1: ( Uint32_1 ) + // InternalRosParser.g:11932:2: Uint32_1 { - before(grammarAccess.getByteArrayAccess().getByteKeyword_1()); - match(input,112,FOLLOW_2); - after(grammarAccess.getByteArrayAccess().getByteKeyword_1()); + before(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); + match(input,Uint32_1,FOLLOW_2); + after(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); } @@ -44196,26 +35493,26 @@ public final void rule__ByteArray__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ByteArray__Group__1__Impl" + // $ANTLR end "rule__Uint32Array__Group__1__Impl" - // $ANTLR start "rule__Header__Group__0" - // InternalRos.g:14793:1: rule__Header__Group__0 : rule__Header__Group__0__Impl rule__Header__Group__1 ; - public final void rule__Header__Group__0() throws RecognitionException { + // $ANTLR start "rule__Int64Array__Group__0" + // InternalRosParser.g:11942:1: rule__Int64Array__Group__0 : rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 ; + public final void rule__Int64Array__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14797:1: ( rule__Header__Group__0__Impl rule__Header__Group__1 ) - // InternalRos.g:14798:2: rule__Header__Group__0__Impl rule__Header__Group__1 + // InternalRosParser.g:11946:1: ( rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 ) + // InternalRosParser.g:11947:2: rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 { - pushFollow(FOLLOW_98); - rule__Header__Group__0__Impl(); + pushFollow(FOLLOW_84); + rule__Int64Array__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__Header__Group__1(); + rule__Int64Array__Group__1(); state._fsp--; @@ -44234,29 +35531,29 @@ public final void rule__Header__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Header__Group__0" + // $ANTLR end "rule__Int64Array__Group__0" - // $ANTLR start "rule__Header__Group__0__Impl" - // InternalRos.g:14805:1: rule__Header__Group__0__Impl : ( () ) ; - public final void rule__Header__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Int64Array__Group__0__Impl" + // InternalRosParser.g:11954:1: rule__Int64Array__Group__0__Impl : ( () ) ; + public final void rule__Int64Array__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14809:1: ( ( () ) ) - // InternalRos.g:14810:1: ( () ) + // InternalRosParser.g:11958:1: ( ( () ) ) + // InternalRosParser.g:11959:1: ( () ) { - // InternalRos.g:14810:1: ( () ) - // InternalRos.g:14811:2: () + // InternalRosParser.g:11959:1: ( () ) + // InternalRosParser.g:11960:2: () { - before(grammarAccess.getHeaderAccess().getHeaderAction_0()); - // InternalRos.g:14812:2: () - // InternalRos.g:14812:3: + before(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); + // InternalRosParser.g:11961:2: () + // InternalRosParser.g:11961:3: { } - after(grammarAccess.getHeaderAccess().getHeaderAction_0()); + after(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); } @@ -44271,21 +35568,21 @@ public final void rule__Header__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Header__Group__0__Impl" + // $ANTLR end "rule__Int64Array__Group__0__Impl" - // $ANTLR start "rule__Header__Group__1" - // InternalRos.g:14820:1: rule__Header__Group__1 : rule__Header__Group__1__Impl ; - public final void rule__Header__Group__1() throws RecognitionException { + // $ANTLR start "rule__Int64Array__Group__1" + // InternalRosParser.g:11969:1: rule__Int64Array__Group__1 : rule__Int64Array__Group__1__Impl ; + public final void rule__Int64Array__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14824:1: ( rule__Header__Group__1__Impl ) - // InternalRos.g:14825:2: rule__Header__Group__1__Impl + // InternalRosParser.g:11973:1: ( rule__Int64Array__Group__1__Impl ) + // InternalRosParser.g:11974:2: rule__Int64Array__Group__1__Impl { pushFollow(FOLLOW_2); - rule__Header__Group__1__Impl(); + rule__Int64Array__Group__1__Impl(); state._fsp--; @@ -44304,25 +35601,25 @@ public final void rule__Header__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Header__Group__1" + // $ANTLR end "rule__Int64Array__Group__1" - // $ANTLR start "rule__Header__Group__1__Impl" - // InternalRos.g:14831:1: rule__Header__Group__1__Impl : ( 'Header' ) ; - public final void rule__Header__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Int64Array__Group__1__Impl" + // InternalRosParser.g:11980:1: rule__Int64Array__Group__1__Impl : ( Int64_1 ) ; + public final void rule__Int64Array__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14835:1: ( ( 'Header' ) ) - // InternalRos.g:14836:1: ( 'Header' ) + // InternalRosParser.g:11984:1: ( ( Int64_1 ) ) + // InternalRosParser.g:11985:1: ( Int64_1 ) { - // InternalRos.g:14836:1: ( 'Header' ) - // InternalRos.g:14837:2: 'Header' + // InternalRosParser.g:11985:1: ( Int64_1 ) + // InternalRosParser.g:11986:2: Int64_1 { - before(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); - match(input,27,FOLLOW_2); - after(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); + before(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); + match(input,Int64_1,FOLLOW_2); + after(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); } @@ -44341,26 +35638,26 @@ public final void rule__Header__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Header__Group__1__Impl" + // $ANTLR end "rule__Int64Array__Group__1__Impl" - // $ANTLR start "rule__ArrayTopicSpecRef__Group__0" - // InternalRos.g:14847:1: rule__ArrayTopicSpecRef__Group__0 : rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 ; - public final void rule__ArrayTopicSpecRef__Group__0() throws RecognitionException { + // $ANTLR start "rule__Uint64Array__Group__0" + // InternalRosParser.g:11996:1: rule__Uint64Array__Group__0 : rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 ; + public final void rule__Uint64Array__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14851:1: ( rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 ) - // InternalRos.g:14852:2: rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 + // InternalRosParser.g:12000:1: ( rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 ) + // InternalRosParser.g:12001:2: rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 { - pushFollow(FOLLOW_99); - rule__ArrayTopicSpecRef__Group__0__Impl(); + pushFollow(FOLLOW_85); + rule__Uint64Array__Group__0__Impl(); state._fsp--; pushFollow(FOLLOW_2); - rule__ArrayTopicSpecRef__Group__1(); + rule__Uint64Array__Group__1(); state._fsp--; @@ -44379,35 +35676,29 @@ public final void rule__ArrayTopicSpecRef__Group__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ArrayTopicSpecRef__Group__0" + // $ANTLR end "rule__Uint64Array__Group__0" - // $ANTLR start "rule__ArrayTopicSpecRef__Group__0__Impl" - // InternalRos.g:14859:1: rule__ArrayTopicSpecRef__Group__0__Impl : ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) ; - public final void rule__ArrayTopicSpecRef__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint64Array__Group__0__Impl" + // InternalRosParser.g:12008:1: rule__Uint64Array__Group__0__Impl : ( () ) ; + public final void rule__Uint64Array__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14863:1: ( ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) ) - // InternalRos.g:14864:1: ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) + // InternalRosParser.g:12012:1: ( ( () ) ) + // InternalRosParser.g:12013:1: ( () ) { - // InternalRos.g:14864:1: ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) - // InternalRos.g:14865:2: ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) + // InternalRosParser.g:12013:1: ( () ) + // InternalRosParser.g:12014:2: () { - before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); - // InternalRos.g:14866:2: ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) - // InternalRos.g:14866:3: rule__ArrayTopicSpecRef__TopicSpecAssignment_0 + before(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); + // InternalRosParser.g:12015:2: () + // InternalRosParser.g:12015:3: { - pushFollow(FOLLOW_2); - rule__ArrayTopicSpecRef__TopicSpecAssignment_0(); - - state._fsp--; - - } - after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); + after(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); } @@ -44415,10 +35706,6 @@ public final void rule__ArrayTopicSpecRef__Group__0__Impl() throws RecognitionEx } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -44426,21 +35713,21 @@ public final void rule__ArrayTopicSpecRef__Group__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ArrayTopicSpecRef__Group__0__Impl" + // $ANTLR end "rule__Uint64Array__Group__0__Impl" - // $ANTLR start "rule__ArrayTopicSpecRef__Group__1" - // InternalRos.g:14874:1: rule__ArrayTopicSpecRef__Group__1 : rule__ArrayTopicSpecRef__Group__1__Impl ; - public final void rule__ArrayTopicSpecRef__Group__1() throws RecognitionException { + // $ANTLR start "rule__Uint64Array__Group__1" + // InternalRosParser.g:12023:1: rule__Uint64Array__Group__1 : rule__Uint64Array__Group__1__Impl ; + public final void rule__Uint64Array__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14878:1: ( rule__ArrayTopicSpecRef__Group__1__Impl ) - // InternalRos.g:14879:2: rule__ArrayTopicSpecRef__Group__1__Impl + // InternalRosParser.g:12027:1: ( rule__Uint64Array__Group__1__Impl ) + // InternalRosParser.g:12028:2: rule__Uint64Array__Group__1__Impl { pushFollow(FOLLOW_2); - rule__ArrayTopicSpecRef__Group__1__Impl(); + rule__Uint64Array__Group__1__Impl(); state._fsp--; @@ -44459,25 +35746,25 @@ public final void rule__ArrayTopicSpecRef__Group__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ArrayTopicSpecRef__Group__1" + // $ANTLR end "rule__Uint64Array__Group__1" - // $ANTLR start "rule__ArrayTopicSpecRef__Group__1__Impl" - // InternalRos.g:14885:1: rule__ArrayTopicSpecRef__Group__1__Impl : ( '[]' ) ; - public final void rule__ArrayTopicSpecRef__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Uint64Array__Group__1__Impl" + // InternalRosParser.g:12034:1: rule__Uint64Array__Group__1__Impl : ( Uint64_1 ) ; + public final void rule__Uint64Array__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14889:1: ( ( '[]' ) ) - // InternalRos.g:14890:1: ( '[]' ) + // InternalRosParser.g:12038:1: ( ( Uint64_1 ) ) + // InternalRosParser.g:12039:1: ( Uint64_1 ) { - // InternalRos.g:14890:1: ( '[]' ) - // InternalRos.g:14891:2: '[]' + // InternalRosParser.g:12039:1: ( Uint64_1 ) + // InternalRosParser.g:12040:2: Uint64_1 { - before(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); - match(input,113,FOLLOW_2); - after(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); + before(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); + match(input,Uint64_1,FOLLOW_2); + after(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); } @@ -44496,31 +35783,28 @@ public final void rule__ArrayTopicSpecRef__Group__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ArrayTopicSpecRef__Group__1__Impl" + // $ANTLR end "rule__Uint64Array__Group__1__Impl" - // $ANTLR start "rule__PackageSet__PackageAssignment_3_0" - // InternalRos.g:14901:1: rule__PackageSet__PackageAssignment_3_0 : ( rulePackage ) ; - public final void rule__PackageSet__PackageAssignment_3_0() throws RecognitionException { + // $ANTLR start "rule__Float32Array__Group__0" + // InternalRosParser.g:12050:1: rule__Float32Array__Group__0 : rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 ; + public final void rule__Float32Array__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14905:1: ( ( rulePackage ) ) - // InternalRos.g:14906:2: ( rulePackage ) + // InternalRosParser.g:12054:1: ( rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 ) + // InternalRosParser.g:12055:2: rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 { - // InternalRos.g:14906:2: ( rulePackage ) - // InternalRos.g:14907:3: rulePackage - { - before(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_0_0()); - pushFollow(FOLLOW_2); - rulePackage(); + pushFollow(FOLLOW_86); + rule__Float32Array__Group__0__Impl(); state._fsp--; - after(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_0_0()); + pushFollow(FOLLOW_2); + rule__Float32Array__Group__1(); - } + state._fsp--; } @@ -44537,29 +35821,29 @@ public final void rule__PackageSet__PackageAssignment_3_0() throws RecognitionEx } return ; } - // $ANTLR end "rule__PackageSet__PackageAssignment_3_0" + // $ANTLR end "rule__Float32Array__Group__0" - // $ANTLR start "rule__PackageSet__PackageAssignment_3_1_1" - // InternalRos.g:14916:1: rule__PackageSet__PackageAssignment_3_1_1 : ( rulePackage ) ; - public final void rule__PackageSet__PackageAssignment_3_1_1() throws RecognitionException { + // $ANTLR start "rule__Float32Array__Group__0__Impl" + // InternalRosParser.g:12062:1: rule__Float32Array__Group__0__Impl : ( () ) ; + public final void rule__Float32Array__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14920:1: ( ( rulePackage ) ) - // InternalRos.g:14921:2: ( rulePackage ) + // InternalRosParser.g:12066:1: ( ( () ) ) + // InternalRosParser.g:12067:1: ( () ) { - // InternalRos.g:14921:2: ( rulePackage ) - // InternalRos.g:14922:3: rulePackage + // InternalRosParser.g:12067:1: ( () ) + // InternalRosParser.g:12068:2: () { - before(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_1_1_0()); - pushFollow(FOLLOW_2); - rulePackage(); - - state._fsp--; + before(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); + // InternalRosParser.g:12069:2: () + // InternalRosParser.g:12069:3: + { + } - after(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_1_1_0()); + after(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); } @@ -44567,10 +35851,6 @@ public final void rule__PackageSet__PackageAssignment_3_1_1() throws Recognition } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -44578,32 +35858,24 @@ public final void rule__PackageSet__PackageAssignment_3_1_1() throws Recognition } return ; } - // $ANTLR end "rule__PackageSet__PackageAssignment_3_1_1" + // $ANTLR end "rule__Float32Array__Group__0__Impl" - // $ANTLR start "rule__Package_Impl__NameAssignment_2" - // InternalRos.g:14931:1: rule__Package_Impl__NameAssignment_2 : ( ruleEString ) ; - public final void rule__Package_Impl__NameAssignment_2() throws RecognitionException { + // $ANTLR start "rule__Float32Array__Group__1" + // InternalRosParser.g:12077:1: rule__Float32Array__Group__1 : rule__Float32Array__Group__1__Impl ; + public final void rule__Float32Array__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14935:1: ( ( ruleEString ) ) - // InternalRos.g:14936:2: ( ruleEString ) - { - // InternalRos.g:14936:2: ( ruleEString ) - // InternalRos.g:14937:3: ruleEString + // InternalRosParser.g:12081:1: ( rule__Float32Array__Group__1__Impl ) + // InternalRosParser.g:12082:2: rule__Float32Array__Group__1__Impl { - before(grammarAccess.getPackage_ImplAccess().getNameEStringParserRuleCall_2_0()); pushFollow(FOLLOW_2); - ruleEString(); + rule__Float32Array__Group__1__Impl(); state._fsp--; - after(grammarAccess.getPackage_ImplAccess().getNameEStringParserRuleCall_2_0()); - - } - } @@ -44619,29 +35891,25 @@ public final void rule__Package_Impl__NameAssignment_2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Package_Impl__NameAssignment_2" + // $ANTLR end "rule__Float32Array__Group__1" - // $ANTLR start "rule__Package_Impl__FromGitRepoAssignment_4_1" - // InternalRos.g:14946:1: rule__Package_Impl__FromGitRepoAssignment_4_1 : ( ruleEString ) ; - public final void rule__Package_Impl__FromGitRepoAssignment_4_1() throws RecognitionException { + // $ANTLR start "rule__Float32Array__Group__1__Impl" + // InternalRosParser.g:12088:1: rule__Float32Array__Group__1__Impl : ( Float32_1 ) ; + public final void rule__Float32Array__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14950:1: ( ( ruleEString ) ) - // InternalRos.g:14951:2: ( ruleEString ) + // InternalRosParser.g:12092:1: ( ( Float32_1 ) ) + // InternalRosParser.g:12093:1: ( Float32_1 ) { - // InternalRos.g:14951:2: ( ruleEString ) - // InternalRos.g:14952:3: ruleEString + // InternalRosParser.g:12093:1: ( Float32_1 ) + // InternalRosParser.g:12094:2: Float32_1 { - before(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); - pushFollow(FOLLOW_2); - ruleEString(); - - state._fsp--; - - after(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + before(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); + match(input,Float32_1,FOLLOW_2); + after(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); } @@ -44660,31 +35928,28 @@ public final void rule__Package_Impl__FromGitRepoAssignment_4_1() throws Recogni } return ; } - // $ANTLR end "rule__Package_Impl__FromGitRepoAssignment_4_1" + // $ANTLR end "rule__Float32Array__Group__1__Impl" - // $ANTLR start "rule__Package_Impl__SpecAssignment_5_2" - // InternalRos.g:14961:1: rule__Package_Impl__SpecAssignment_5_2 : ( ruleSpecBase ) ; - public final void rule__Package_Impl__SpecAssignment_5_2() throws RecognitionException { + // $ANTLR start "rule__Float64Array__Group__0" + // InternalRosParser.g:12104:1: rule__Float64Array__Group__0 : rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 ; + public final void rule__Float64Array__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14965:1: ( ( ruleSpecBase ) ) - // InternalRos.g:14966:2: ( ruleSpecBase ) - { - // InternalRos.g:14966:2: ( ruleSpecBase ) - // InternalRos.g:14967:3: ruleSpecBase + // InternalRosParser.g:12108:1: ( rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 ) + // InternalRosParser.g:12109:2: rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 { - before(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); - pushFollow(FOLLOW_2); - ruleSpecBase(); + pushFollow(FOLLOW_87); + rule__Float64Array__Group__0__Impl(); state._fsp--; - after(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); + pushFollow(FOLLOW_2); + rule__Float64Array__Group__1(); - } + state._fsp--; } @@ -44701,29 +35966,29 @@ public final void rule__Package_Impl__SpecAssignment_5_2() throws RecognitionExc } return ; } - // $ANTLR end "rule__Package_Impl__SpecAssignment_5_2" + // $ANTLR end "rule__Float64Array__Group__0" - // $ANTLR start "rule__Package_Impl__SpecAssignment_5_3_1" - // InternalRos.g:14976:1: rule__Package_Impl__SpecAssignment_5_3_1 : ( ruleSpecBase ) ; - public final void rule__Package_Impl__SpecAssignment_5_3_1() throws RecognitionException { + // $ANTLR start "rule__Float64Array__Group__0__Impl" + // InternalRosParser.g:12116:1: rule__Float64Array__Group__0__Impl : ( () ) ; + public final void rule__Float64Array__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14980:1: ( ( ruleSpecBase ) ) - // InternalRos.g:14981:2: ( ruleSpecBase ) + // InternalRosParser.g:12120:1: ( ( () ) ) + // InternalRosParser.g:12121:1: ( () ) { - // InternalRos.g:14981:2: ( ruleSpecBase ) - // InternalRos.g:14982:3: ruleSpecBase + // InternalRosParser.g:12121:1: ( () ) + // InternalRosParser.g:12122:2: () { - before(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_3_1_0()); - pushFollow(FOLLOW_2); - ruleSpecBase(); - - state._fsp--; + before(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); + // InternalRosParser.g:12123:2: () + // InternalRosParser.g:12123:3: + { + } - after(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_3_1_0()); + after(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); } @@ -44731,10 +35996,6 @@ public final void rule__Package_Impl__SpecAssignment_5_3_1() throws RecognitionE } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -44742,32 +36003,24 @@ public final void rule__Package_Impl__SpecAssignment_5_3_1() throws RecognitionE } return ; } - // $ANTLR end "rule__Package_Impl__SpecAssignment_5_3_1" + // $ANTLR end "rule__Float64Array__Group__0__Impl" - // $ANTLR start "rule__Package_Impl__ArtifactAssignment_6_0" - // InternalRos.g:14991:1: rule__Package_Impl__ArtifactAssignment_6_0 : ( ruleArtifact ) ; - public final void rule__Package_Impl__ArtifactAssignment_6_0() throws RecognitionException { + // $ANTLR start "rule__Float64Array__Group__1" + // InternalRosParser.g:12131:1: rule__Float64Array__Group__1 : rule__Float64Array__Group__1__Impl ; + public final void rule__Float64Array__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:14995:1: ( ( ruleArtifact ) ) - // InternalRos.g:14996:2: ( ruleArtifact ) - { - // InternalRos.g:14996:2: ( ruleArtifact ) - // InternalRos.g:14997:3: ruleArtifact + // InternalRosParser.g:12135:1: ( rule__Float64Array__Group__1__Impl ) + // InternalRosParser.g:12136:2: rule__Float64Array__Group__1__Impl { - before(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_0_0()); pushFollow(FOLLOW_2); - ruleArtifact(); + rule__Float64Array__Group__1__Impl(); state._fsp--; - after(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_0_0()); - - } - } @@ -44783,29 +36036,25 @@ public final void rule__Package_Impl__ArtifactAssignment_6_0() throws Recognitio } return ; } - // $ANTLR end "rule__Package_Impl__ArtifactAssignment_6_0" + // $ANTLR end "rule__Float64Array__Group__1" - // $ANTLR start "rule__Package_Impl__ArtifactAssignment_6_1_1" - // InternalRos.g:15006:1: rule__Package_Impl__ArtifactAssignment_6_1_1 : ( ruleArtifact ) ; - public final void rule__Package_Impl__ArtifactAssignment_6_1_1() throws RecognitionException { + // $ANTLR start "rule__Float64Array__Group__1__Impl" + // InternalRosParser.g:12142:1: rule__Float64Array__Group__1__Impl : ( Float64_1 ) ; + public final void rule__Float64Array__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15010:1: ( ( ruleArtifact ) ) - // InternalRos.g:15011:2: ( ruleArtifact ) + // InternalRosParser.g:12146:1: ( ( Float64_1 ) ) + // InternalRosParser.g:12147:1: ( Float64_1 ) { - // InternalRos.g:15011:2: ( ruleArtifact ) - // InternalRos.g:15012:3: ruleArtifact + // InternalRosParser.g:12147:1: ( Float64_1 ) + // InternalRosParser.g:12148:2: Float64_1 { - before(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_1_1_0()); - pushFollow(FOLLOW_2); - ruleArtifact(); - - state._fsp--; - - after(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_1_1_0()); + before(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); + match(input,Float64_1,FOLLOW_2); + after(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); } @@ -44824,31 +36073,28 @@ public final void rule__Package_Impl__ArtifactAssignment_6_1_1() throws Recognit } return ; } - // $ANTLR end "rule__Package_Impl__ArtifactAssignment_6_1_1" + // $ANTLR end "rule__Float64Array__Group__1__Impl" - // $ANTLR start "rule__Artifact__NameAssignment_2" - // InternalRos.g:15021:1: rule__Artifact__NameAssignment_2 : ( ruleRosNames ) ; - public final void rule__Artifact__NameAssignment_2() throws RecognitionException { + // $ANTLR start "rule__String0Array__Group__0" + // InternalRosParser.g:12158:1: rule__String0Array__Group__0 : rule__String0Array__Group__0__Impl rule__String0Array__Group__1 ; + public final void rule__String0Array__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15025:1: ( ( ruleRosNames ) ) - // InternalRos.g:15026:2: ( ruleRosNames ) + // InternalRosParser.g:12162:1: ( rule__String0Array__Group__0__Impl rule__String0Array__Group__1 ) + // InternalRosParser.g:12163:2: rule__String0Array__Group__0__Impl rule__String0Array__Group__1 { - // InternalRos.g:15026:2: ( ruleRosNames ) - // InternalRos.g:15027:3: ruleRosNames - { - before(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_2_0()); - pushFollow(FOLLOW_2); - ruleRosNames(); + pushFollow(FOLLOW_88); + rule__String0Array__Group__0__Impl(); state._fsp--; - after(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_2_0()); + pushFollow(FOLLOW_2); + rule__String0Array__Group__1(); - } + state._fsp--; } @@ -44865,29 +36111,29 @@ public final void rule__Artifact__NameAssignment_2() throws RecognitionException } return ; } - // $ANTLR end "rule__Artifact__NameAssignment_2" + // $ANTLR end "rule__String0Array__Group__0" - // $ANTLR start "rule__Artifact__NodeAssignment_4" - // InternalRos.g:15036:1: rule__Artifact__NodeAssignment_4 : ( ruleNode ) ; - public final void rule__Artifact__NodeAssignment_4() throws RecognitionException { + // $ANTLR start "rule__String0Array__Group__0__Impl" + // InternalRosParser.g:12170:1: rule__String0Array__Group__0__Impl : ( () ) ; + public final void rule__String0Array__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15040:1: ( ( ruleNode ) ) - // InternalRos.g:15041:2: ( ruleNode ) + // InternalRosParser.g:12174:1: ( ( () ) ) + // InternalRosParser.g:12175:1: ( () ) { - // InternalRos.g:15041:2: ( ruleNode ) - // InternalRos.g:15042:3: ruleNode + // InternalRosParser.g:12175:1: ( () ) + // InternalRosParser.g:12176:2: () { - before(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); - pushFollow(FOLLOW_2); - ruleNode(); - - state._fsp--; + before(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); + // InternalRosParser.g:12177:2: () + // InternalRosParser.g:12177:3: + { + } - after(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); + after(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); } @@ -44895,10 +36141,6 @@ public final void rule__Artifact__NodeAssignment_4() throws RecognitionException } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -44906,32 +36148,24 @@ public final void rule__Artifact__NodeAssignment_4() throws RecognitionException } return ; } - // $ANTLR end "rule__Artifact__NodeAssignment_4" + // $ANTLR end "rule__String0Array__Group__0__Impl" - // $ANTLR start "rule__CatkinPackage__NameAssignment_2" - // InternalRos.g:15051:1: rule__CatkinPackage__NameAssignment_2 : ( ruleRosNames ) ; - public final void rule__CatkinPackage__NameAssignment_2() throws RecognitionException { + // $ANTLR start "rule__String0Array__Group__1" + // InternalRosParser.g:12185:1: rule__String0Array__Group__1 : rule__String0Array__Group__1__Impl ; + public final void rule__String0Array__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15055:1: ( ( ruleRosNames ) ) - // InternalRos.g:15056:2: ( ruleRosNames ) + // InternalRosParser.g:12189:1: ( rule__String0Array__Group__1__Impl ) + // InternalRosParser.g:12190:2: rule__String0Array__Group__1__Impl { - // InternalRos.g:15056:2: ( ruleRosNames ) - // InternalRos.g:15057:3: ruleRosNames - { - before(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_2_0()); pushFollow(FOLLOW_2); - ruleRosNames(); + rule__String0Array__Group__1__Impl(); state._fsp--; - after(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_2_0()); - - } - } @@ -44947,29 +36181,25 @@ public final void rule__CatkinPackage__NameAssignment_2() throws RecognitionExce } return ; } - // $ANTLR end "rule__CatkinPackage__NameAssignment_2" + // $ANTLR end "rule__String0Array__Group__1" - // $ANTLR start "rule__CatkinPackage__FromGitRepoAssignment_4_1" - // InternalRos.g:15066:1: rule__CatkinPackage__FromGitRepoAssignment_4_1 : ( ruleEString ) ; - public final void rule__CatkinPackage__FromGitRepoAssignment_4_1() throws RecognitionException { + // $ANTLR start "rule__String0Array__Group__1__Impl" + // InternalRosParser.g:12196:1: rule__String0Array__Group__1__Impl : ( String_2 ) ; + public final void rule__String0Array__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15070:1: ( ( ruleEString ) ) - // InternalRos.g:15071:2: ( ruleEString ) + // InternalRosParser.g:12200:1: ( ( String_2 ) ) + // InternalRosParser.g:12201:1: ( String_2 ) { - // InternalRos.g:15071:2: ( ruleEString ) - // InternalRos.g:15072:3: ruleEString + // InternalRosParser.g:12201:1: ( String_2 ) + // InternalRosParser.g:12202:2: String_2 { - before(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); - pushFollow(FOLLOW_2); - ruleEString(); - - state._fsp--; - - after(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + before(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); + match(input,String_2,FOLLOW_2); + after(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); } @@ -44988,31 +36218,28 @@ public final void rule__CatkinPackage__FromGitRepoAssignment_4_1() throws Recogn } return ; } - // $ANTLR end "rule__CatkinPackage__FromGitRepoAssignment_4_1" + // $ANTLR end "rule__String0Array__Group__1__Impl" - // $ANTLR start "rule__CatkinPackage__DependencyAssignment_5_2" - // InternalRos.g:15081:1: rule__CatkinPackage__DependencyAssignment_5_2 : ( ruleDependency ) ; - public final void rule__CatkinPackage__DependencyAssignment_5_2() throws RecognitionException { + // $ANTLR start "rule__ByteArray__Group__0" + // InternalRosParser.g:12212:1: rule__ByteArray__Group__0 : rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 ; + public final void rule__ByteArray__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15085:1: ( ( ruleDependency ) ) - // InternalRos.g:15086:2: ( ruleDependency ) - { - // InternalRos.g:15086:2: ( ruleDependency ) - // InternalRos.g:15087:3: ruleDependency + // InternalRosParser.g:12216:1: ( rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 ) + // InternalRosParser.g:12217:2: rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 { - before(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); - pushFollow(FOLLOW_2); - ruleDependency(); + pushFollow(FOLLOW_89); + rule__ByteArray__Group__0__Impl(); state._fsp--; - after(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); + pushFollow(FOLLOW_2); + rule__ByteArray__Group__1(); - } + state._fsp--; } @@ -45029,29 +36256,29 @@ public final void rule__CatkinPackage__DependencyAssignment_5_2() throws Recogni } return ; } - // $ANTLR end "rule__CatkinPackage__DependencyAssignment_5_2" + // $ANTLR end "rule__ByteArray__Group__0" - // $ANTLR start "rule__CatkinPackage__DependencyAssignment_5_3_1" - // InternalRos.g:15096:1: rule__CatkinPackage__DependencyAssignment_5_3_1 : ( ruleDependency ) ; - public final void rule__CatkinPackage__DependencyAssignment_5_3_1() throws RecognitionException { + // $ANTLR start "rule__ByteArray__Group__0__Impl" + // InternalRosParser.g:12224:1: rule__ByteArray__Group__0__Impl : ( () ) ; + public final void rule__ByteArray__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15100:1: ( ( ruleDependency ) ) - // InternalRos.g:15101:2: ( ruleDependency ) + // InternalRosParser.g:12228:1: ( ( () ) ) + // InternalRosParser.g:12229:1: ( () ) { - // InternalRos.g:15101:2: ( ruleDependency ) - // InternalRos.g:15102:3: ruleDependency + // InternalRosParser.g:12229:1: ( () ) + // InternalRosParser.g:12230:2: () { - before(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); - pushFollow(FOLLOW_2); - ruleDependency(); - - state._fsp--; + before(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); + // InternalRosParser.g:12231:2: () + // InternalRosParser.g:12231:3: + { + } - after(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); + after(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); } @@ -45059,10 +36286,6 @@ public final void rule__CatkinPackage__DependencyAssignment_5_3_1() throws Recog } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -45070,32 +36293,24 @@ public final void rule__CatkinPackage__DependencyAssignment_5_3_1() throws Recog } return ; } - // $ANTLR end "rule__CatkinPackage__DependencyAssignment_5_3_1" + // $ANTLR end "rule__ByteArray__Group__0__Impl" - // $ANTLR start "rule__CatkinPackage__SpecAssignment_6_2" - // InternalRos.g:15111:1: rule__CatkinPackage__SpecAssignment_6_2 : ( ruleSpecBase ) ; - public final void rule__CatkinPackage__SpecAssignment_6_2() throws RecognitionException { + // $ANTLR start "rule__ByteArray__Group__1" + // InternalRosParser.g:12239:1: rule__ByteArray__Group__1 : rule__ByteArray__Group__1__Impl ; + public final void rule__ByteArray__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15115:1: ( ( ruleSpecBase ) ) - // InternalRos.g:15116:2: ( ruleSpecBase ) + // InternalRosParser.g:12243:1: ( rule__ByteArray__Group__1__Impl ) + // InternalRosParser.g:12244:2: rule__ByteArray__Group__1__Impl { - // InternalRos.g:15116:2: ( ruleSpecBase ) - // InternalRos.g:15117:3: ruleSpecBase - { - before(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); pushFollow(FOLLOW_2); - ruleSpecBase(); + rule__ByteArray__Group__1__Impl(); state._fsp--; - after(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); - - } - } @@ -45111,29 +36326,25 @@ public final void rule__CatkinPackage__SpecAssignment_6_2() throws RecognitionEx } return ; } - // $ANTLR end "rule__CatkinPackage__SpecAssignment_6_2" + // $ANTLR end "rule__ByteArray__Group__1" - // $ANTLR start "rule__CatkinPackage__SpecAssignment_6_3_1" - // InternalRos.g:15126:1: rule__CatkinPackage__SpecAssignment_6_3_1 : ( ruleSpecBase ) ; - public final void rule__CatkinPackage__SpecAssignment_6_3_1() throws RecognitionException { + // $ANTLR start "rule__ByteArray__Group__1__Impl" + // InternalRosParser.g:12250:1: rule__ByteArray__Group__1__Impl : ( Byte_1 ) ; + public final void rule__ByteArray__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15130:1: ( ( ruleSpecBase ) ) - // InternalRos.g:15131:2: ( ruleSpecBase ) + // InternalRosParser.g:12254:1: ( ( Byte_1 ) ) + // InternalRosParser.g:12255:1: ( Byte_1 ) { - // InternalRos.g:15131:2: ( ruleSpecBase ) - // InternalRos.g:15132:3: ruleSpecBase + // InternalRosParser.g:12255:1: ( Byte_1 ) + // InternalRosParser.g:12256:2: Byte_1 { - before(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); - pushFollow(FOLLOW_2); - ruleSpecBase(); - - state._fsp--; - - after(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); + before(grammarAccess.getByteArrayAccess().getByteKeyword_1()); + match(input,Byte_1,FOLLOW_2); + after(grammarAccess.getByteArrayAccess().getByteKeyword_1()); } @@ -45152,31 +36363,28 @@ public final void rule__CatkinPackage__SpecAssignment_6_3_1() throws Recognition } return ; } - // $ANTLR end "rule__CatkinPackage__SpecAssignment_6_3_1" + // $ANTLR end "rule__ByteArray__Group__1__Impl" - // $ANTLR start "rule__CatkinPackage__ArtifactAssignment_7_0" - // InternalRos.g:15141:1: rule__CatkinPackage__ArtifactAssignment_7_0 : ( ruleArtifact ) ; - public final void rule__CatkinPackage__ArtifactAssignment_7_0() throws RecognitionException { + // $ANTLR start "rule__Header__Group__0" + // InternalRosParser.g:12266:1: rule__Header__Group__0 : rule__Header__Group__0__Impl rule__Header__Group__1 ; + public final void rule__Header__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15145:1: ( ( ruleArtifact ) ) - // InternalRos.g:15146:2: ( ruleArtifact ) - { - // InternalRos.g:15146:2: ( ruleArtifact ) - // InternalRos.g:15147:3: ruleArtifact + // InternalRosParser.g:12270:1: ( rule__Header__Group__0__Impl rule__Header__Group__1 ) + // InternalRosParser.g:12271:2: rule__Header__Group__0__Impl rule__Header__Group__1 { - before(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); - pushFollow(FOLLOW_2); - ruleArtifact(); + pushFollow(FOLLOW_90); + rule__Header__Group__0__Impl(); state._fsp--; - after(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); + pushFollow(FOLLOW_2); + rule__Header__Group__1(); - } + state._fsp--; } @@ -45193,32 +36401,61 @@ public final void rule__CatkinPackage__ArtifactAssignment_7_0() throws Recogniti } return ; } - // $ANTLR end "rule__CatkinPackage__ArtifactAssignment_7_0" + // $ANTLR end "rule__Header__Group__0" - // $ANTLR start "rule__CatkinPackage__ArtifactAssignment_7_1_1" - // InternalRos.g:15156:1: rule__CatkinPackage__ArtifactAssignment_7_1_1 : ( ruleArtifact ) ; - public final void rule__CatkinPackage__ArtifactAssignment_7_1_1() throws RecognitionException { + // $ANTLR start "rule__Header__Group__0__Impl" + // InternalRosParser.g:12278:1: rule__Header__Group__0__Impl : ( () ) ; + public final void rule__Header__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15160:1: ( ( ruleArtifact ) ) - // InternalRos.g:15161:2: ( ruleArtifact ) + // InternalRosParser.g:12282:1: ( ( () ) ) + // InternalRosParser.g:12283:1: ( () ) { - // InternalRos.g:15161:2: ( ruleArtifact ) - // InternalRos.g:15162:3: ruleArtifact + // InternalRosParser.g:12283:1: ( () ) + // InternalRosParser.g:12284:2: () { - before(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); - pushFollow(FOLLOW_2); - ruleArtifact(); + before(grammarAccess.getHeaderAccess().getHeaderAction_0()); + // InternalRosParser.g:12285:2: () + // InternalRosParser.g:12285:3: + { + } - state._fsp--; + after(grammarAccess.getHeaderAccess().getHeaderAction_0()); + + } - after(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); } + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Header__Group__0__Impl" + + + // $ANTLR start "rule__Header__Group__1" + // InternalRosParser.g:12293:1: rule__Header__Group__1 : rule__Header__Group__1__Impl ; + public final void rule__Header__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRosParser.g:12297:1: ( rule__Header__Group__1__Impl ) + // InternalRosParser.g:12298:2: rule__Header__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Header__Group__1__Impl(); + + state._fsp--; + } @@ -45234,29 +36471,25 @@ public final void rule__CatkinPackage__ArtifactAssignment_7_1_1() throws Recogni } return ; } - // $ANTLR end "rule__CatkinPackage__ArtifactAssignment_7_1_1" + // $ANTLR end "rule__Header__Group__1" - // $ANTLR start "rule__AmentPackage__NameAssignment_2" - // InternalRos.g:15171:1: rule__AmentPackage__NameAssignment_2 : ( ruleRosNames ) ; - public final void rule__AmentPackage__NameAssignment_2() throws RecognitionException { + // $ANTLR start "rule__Header__Group__1__Impl" + // InternalRosParser.g:12304:1: rule__Header__Group__1__Impl : ( Header ) ; + public final void rule__Header__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15175:1: ( ( ruleRosNames ) ) - // InternalRos.g:15176:2: ( ruleRosNames ) + // InternalRosParser.g:12308:1: ( ( Header ) ) + // InternalRosParser.g:12309:1: ( Header ) { - // InternalRos.g:15176:2: ( ruleRosNames ) - // InternalRos.g:15177:3: ruleRosNames + // InternalRosParser.g:12309:1: ( Header ) + // InternalRosParser.g:12310:2: Header { - before(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_2_0()); - pushFollow(FOLLOW_2); - ruleRosNames(); - - state._fsp--; - - after(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_2_0()); + before(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); + match(input,Header,FOLLOW_2); + after(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); } @@ -45275,31 +36508,28 @@ public final void rule__AmentPackage__NameAssignment_2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AmentPackage__NameAssignment_2" + // $ANTLR end "rule__Header__Group__1__Impl" - // $ANTLR start "rule__AmentPackage__FromGitRepoAssignment_4_1" - // InternalRos.g:15186:1: rule__AmentPackage__FromGitRepoAssignment_4_1 : ( ruleEString ) ; - public final void rule__AmentPackage__FromGitRepoAssignment_4_1() throws RecognitionException { + // $ANTLR start "rule__ArrayTopicSpecRef__Group__0" + // InternalRosParser.g:12320:1: rule__ArrayTopicSpecRef__Group__0 : rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 ; + public final void rule__ArrayTopicSpecRef__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15190:1: ( ( ruleEString ) ) - // InternalRos.g:15191:2: ( ruleEString ) + // InternalRosParser.g:12324:1: ( rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 ) + // InternalRosParser.g:12325:2: rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 { - // InternalRos.g:15191:2: ( ruleEString ) - // InternalRos.g:15192:3: ruleEString - { - before(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); - pushFollow(FOLLOW_2); - ruleEString(); + pushFollow(FOLLOW_91); + rule__ArrayTopicSpecRef__Group__0__Impl(); state._fsp--; - after(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + pushFollow(FOLLOW_2); + rule__ArrayTopicSpecRef__Group__1(); - } + state._fsp--; } @@ -45316,29 +36546,35 @@ public final void rule__AmentPackage__FromGitRepoAssignment_4_1() throws Recogni } return ; } - // $ANTLR end "rule__AmentPackage__FromGitRepoAssignment_4_1" + // $ANTLR end "rule__ArrayTopicSpecRef__Group__0" - // $ANTLR start "rule__AmentPackage__DependencyAssignment_5_2" - // InternalRos.g:15201:1: rule__AmentPackage__DependencyAssignment_5_2 : ( ruleDependency ) ; - public final void rule__AmentPackage__DependencyAssignment_5_2() throws RecognitionException { + // $ANTLR start "rule__ArrayTopicSpecRef__Group__0__Impl" + // InternalRosParser.g:12332:1: rule__ArrayTopicSpecRef__Group__0__Impl : ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) ; + public final void rule__ArrayTopicSpecRef__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15205:1: ( ( ruleDependency ) ) - // InternalRos.g:15206:2: ( ruleDependency ) + // InternalRosParser.g:12336:1: ( ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) ) + // InternalRosParser.g:12337:1: ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) { - // InternalRos.g:15206:2: ( ruleDependency ) - // InternalRos.g:15207:3: ruleDependency + // InternalRosParser.g:12337:1: ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) + // InternalRosParser.g:12338:2: ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) + { + before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); + // InternalRosParser.g:12339:2: ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) + // InternalRosParser.g:12339:3: rule__ArrayTopicSpecRef__TopicSpecAssignment_0 { - before(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); pushFollow(FOLLOW_2); - ruleDependency(); + rule__ArrayTopicSpecRef__TopicSpecAssignment_0(); state._fsp--; - after(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); + + } + + after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); } @@ -45357,32 +36593,24 @@ public final void rule__AmentPackage__DependencyAssignment_5_2() throws Recognit } return ; } - // $ANTLR end "rule__AmentPackage__DependencyAssignment_5_2" + // $ANTLR end "rule__ArrayTopicSpecRef__Group__0__Impl" - // $ANTLR start "rule__AmentPackage__DependencyAssignment_5_3_1" - // InternalRos.g:15216:1: rule__AmentPackage__DependencyAssignment_5_3_1 : ( ruleDependency ) ; - public final void rule__AmentPackage__DependencyAssignment_5_3_1() throws RecognitionException { + // $ANTLR start "rule__ArrayTopicSpecRef__Group__1" + // InternalRosParser.g:12347:1: rule__ArrayTopicSpecRef__Group__1 : rule__ArrayTopicSpecRef__Group__1__Impl ; + public final void rule__ArrayTopicSpecRef__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15220:1: ( ( ruleDependency ) ) - // InternalRos.g:15221:2: ( ruleDependency ) - { - // InternalRos.g:15221:2: ( ruleDependency ) - // InternalRos.g:15222:3: ruleDependency + // InternalRosParser.g:12351:1: ( rule__ArrayTopicSpecRef__Group__1__Impl ) + // InternalRosParser.g:12352:2: rule__ArrayTopicSpecRef__Group__1__Impl { - before(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); pushFollow(FOLLOW_2); - ruleDependency(); + rule__ArrayTopicSpecRef__Group__1__Impl(); state._fsp--; - after(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); - - } - } @@ -45398,29 +36626,25 @@ public final void rule__AmentPackage__DependencyAssignment_5_3_1() throws Recogn } return ; } - // $ANTLR end "rule__AmentPackage__DependencyAssignment_5_3_1" + // $ANTLR end "rule__ArrayTopicSpecRef__Group__1" - // $ANTLR start "rule__AmentPackage__SpecAssignment_6_2" - // InternalRos.g:15231:1: rule__AmentPackage__SpecAssignment_6_2 : ( ruleSpecBase ) ; - public final void rule__AmentPackage__SpecAssignment_6_2() throws RecognitionException { + // $ANTLR start "rule__ArrayTopicSpecRef__Group__1__Impl" + // InternalRosParser.g:12358:1: rule__ArrayTopicSpecRef__Group__1__Impl : ( LeftSquareBracketRightSquareBracket ) ; + public final void rule__ArrayTopicSpecRef__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15235:1: ( ( ruleSpecBase ) ) - // InternalRos.g:15236:2: ( ruleSpecBase ) + // InternalRosParser.g:12362:1: ( ( LeftSquareBracketRightSquareBracket ) ) + // InternalRosParser.g:12363:1: ( LeftSquareBracketRightSquareBracket ) { - // InternalRos.g:15236:2: ( ruleSpecBase ) - // InternalRos.g:15237:3: ruleSpecBase + // InternalRosParser.g:12363:1: ( LeftSquareBracketRightSquareBracket ) + // InternalRosParser.g:12364:2: LeftSquareBracketRightSquareBracket { - before(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); - pushFollow(FOLLOW_2); - ruleSpecBase(); - - state._fsp--; - - after(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); + before(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); + match(input,LeftSquareBracketRightSquareBracket,FOLLOW_2); + after(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); } @@ -45439,29 +36663,29 @@ public final void rule__AmentPackage__SpecAssignment_6_2() throws RecognitionExc } return ; } - // $ANTLR end "rule__AmentPackage__SpecAssignment_6_2" + // $ANTLR end "rule__ArrayTopicSpecRef__Group__1__Impl" - // $ANTLR start "rule__AmentPackage__SpecAssignment_6_3_1" - // InternalRos.g:15246:1: rule__AmentPackage__SpecAssignment_6_3_1 : ( ruleSpecBase ) ; - public final void rule__AmentPackage__SpecAssignment_6_3_1() throws RecognitionException { + // $ANTLR start "rule__PackageSet__PackageAssignment_1" + // InternalRosParser.g:12374:1: rule__PackageSet__PackageAssignment_1 : ( rulePackage_Impl ) ; + public final void rule__PackageSet__PackageAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15250:1: ( ( ruleSpecBase ) ) - // InternalRos.g:15251:2: ( ruleSpecBase ) + // InternalRosParser.g:12378:1: ( ( rulePackage_Impl ) ) + // InternalRosParser.g:12379:2: ( rulePackage_Impl ) { - // InternalRos.g:15251:2: ( ruleSpecBase ) - // InternalRos.g:15252:3: ruleSpecBase + // InternalRosParser.g:12379:2: ( rulePackage_Impl ) + // InternalRosParser.g:12380:3: rulePackage_Impl { - before(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); + before(grammarAccess.getPackageSetAccess().getPackagePackage_ImplParserRuleCall_1_0()); pushFollow(FOLLOW_2); - ruleSpecBase(); + rulePackage_Impl(); state._fsp--; - after(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); + after(grammarAccess.getPackageSetAccess().getPackagePackage_ImplParserRuleCall_1_0()); } @@ -45480,70 +36704,29 @@ public final void rule__AmentPackage__SpecAssignment_6_3_1() throws RecognitionE } return ; } - // $ANTLR end "rule__AmentPackage__SpecAssignment_6_3_1" + // $ANTLR end "rule__PackageSet__PackageAssignment_1" - // $ANTLR start "rule__AmentPackage__ArtifactAssignment_7_0" - // InternalRos.g:15261:1: rule__AmentPackage__ArtifactAssignment_7_0 : ( ruleArtifact ) ; - public final void rule__AmentPackage__ArtifactAssignment_7_0() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__NameAssignment_1" + // InternalRosParser.g:12389:1: rule__Package_Impl__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__Package_Impl__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15265:1: ( ( ruleArtifact ) ) - // InternalRos.g:15266:2: ( ruleArtifact ) + // InternalRosParser.g:12393:1: ( ( ruleRosNames ) ) + // InternalRosParser.g:12394:2: ( ruleRosNames ) { - // InternalRos.g:15266:2: ( ruleArtifact ) - // InternalRos.g:15267:3: ruleArtifact + // InternalRosParser.g:12394:2: ( ruleRosNames ) + // InternalRosParser.g:12395:3: ruleRosNames { - before(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); + before(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); pushFollow(FOLLOW_2); - ruleArtifact(); - - state._fsp--; - - after(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__AmentPackage__ArtifactAssignment_7_0" - - - // $ANTLR start "rule__AmentPackage__ArtifactAssignment_7_1_1" - // InternalRos.g:15276:1: rule__AmentPackage__ArtifactAssignment_7_1_1 : ( ruleArtifact ) ; - public final void rule__AmentPackage__ArtifactAssignment_7_1_1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:15280:1: ( ( ruleArtifact ) ) - // InternalRos.g:15281:2: ( ruleArtifact ) - { - // InternalRos.g:15281:2: ( ruleArtifact ) - // InternalRos.g:15282:3: ruleArtifact - { - before(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); - pushFollow(FOLLOW_2); - ruleArtifact(); + ruleRosNames(); state._fsp--; - after(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); + after(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); } @@ -45562,29 +36745,29 @@ public final void rule__AmentPackage__ArtifactAssignment_7_1_1() throws Recognit } return ; } - // $ANTLR end "rule__AmentPackage__ArtifactAssignment_7_1_1" + // $ANTLR end "rule__Package_Impl__NameAssignment_1" - // $ANTLR start "rule__ServiceSpec__NameAssignment_2" - // InternalRos.g:15291:1: rule__ServiceSpec__NameAssignment_2 : ( ruleEString ) ; - public final void rule__ServiceSpec__NameAssignment_2() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__FromGitRepoAssignment_4_1" + // InternalRosParser.g:12404:1: rule__Package_Impl__FromGitRepoAssignment_4_1 : ( ruleEString ) ; + public final void rule__Package_Impl__FromGitRepoAssignment_4_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15295:1: ( ( ruleEString ) ) - // InternalRos.g:15296:2: ( ruleEString ) + // InternalRosParser.g:12408:1: ( ( ruleEString ) ) + // InternalRosParser.g:12409:2: ( ruleEString ) { - // InternalRos.g:15296:2: ( ruleEString ) - // InternalRos.g:15297:3: ruleEString + // InternalRosParser.g:12409:2: ( ruleEString ) + // InternalRosParser.g:12410:3: ruleEString { - before(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); + before(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); + after(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } @@ -45603,29 +36786,29 @@ public final void rule__ServiceSpec__NameAssignment_2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ServiceSpec__NameAssignment_2" + // $ANTLR end "rule__Package_Impl__FromGitRepoAssignment_4_1" - // $ANTLR start "rule__ServiceSpec__RequestAssignment_4_1" - // InternalRos.g:15306:1: rule__ServiceSpec__RequestAssignment_4_1 : ( ruleMessageDefinition ) ; - public final void rule__ServiceSpec__RequestAssignment_4_1() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__SpecAssignment_5_2" + // InternalRosParser.g:12419:1: rule__Package_Impl__SpecAssignment_5_2 : ( ruleSpecBase ) ; + public final void rule__Package_Impl__SpecAssignment_5_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15310:1: ( ( ruleMessageDefinition ) ) - // InternalRos.g:15311:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12423:1: ( ( ruleSpecBase ) ) + // InternalRosParser.g:12424:2: ( ruleSpecBase ) { - // InternalRos.g:15311:2: ( ruleMessageDefinition ) - // InternalRos.g:15312:3: ruleMessageDefinition + // InternalRosParser.g:12424:2: ( ruleSpecBase ) + // InternalRosParser.g:12425:3: ruleSpecBase { - before(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_4_1_0()); + before(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); pushFollow(FOLLOW_2); - ruleMessageDefinition(); + ruleSpecBase(); state._fsp--; - after(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_4_1_0()); + after(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); } @@ -45644,29 +36827,29 @@ public final void rule__ServiceSpec__RequestAssignment_4_1() throws RecognitionE } return ; } - // $ANTLR end "rule__ServiceSpec__RequestAssignment_4_1" + // $ANTLR end "rule__Package_Impl__SpecAssignment_5_2" - // $ANTLR start "rule__ServiceSpec__ResponseAssignment_5_1" - // InternalRos.g:15321:1: rule__ServiceSpec__ResponseAssignment_5_1 : ( ruleMessageDefinition ) ; - public final void rule__ServiceSpec__ResponseAssignment_5_1() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__DependencyAssignment_6_2" + // InternalRosParser.g:12434:1: rule__Package_Impl__DependencyAssignment_6_2 : ( ruleDependency ) ; + public final void rule__Package_Impl__DependencyAssignment_6_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15325:1: ( ( ruleMessageDefinition ) ) - // InternalRos.g:15326:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12438:1: ( ( ruleDependency ) ) + // InternalRosParser.g:12439:2: ( ruleDependency ) { - // InternalRos.g:15326:2: ( ruleMessageDefinition ) - // InternalRos.g:15327:3: ruleMessageDefinition + // InternalRosParser.g:12439:2: ( ruleDependency ) + // InternalRosParser.g:12440:3: ruleDependency { - before(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_5_1_0()); + before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); pushFollow(FOLLOW_2); - ruleMessageDefinition(); + ruleDependency(); state._fsp--; - after(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_5_1_0()); + after(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); } @@ -45685,35 +36868,29 @@ public final void rule__ServiceSpec__ResponseAssignment_5_1() throws Recognition } return ; } - // $ANTLR end "rule__ServiceSpec__ResponseAssignment_5_1" + // $ANTLR end "rule__Package_Impl__DependencyAssignment_6_2" - // $ANTLR start "rule__TopicSpec__NameAssignment_2" - // InternalRos.g:15336:1: rule__TopicSpec__NameAssignment_2 : ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) ; - public final void rule__TopicSpec__NameAssignment_2() throws RecognitionException { + // $ANTLR start "rule__Package_Impl__DependencyAssignment_6_3_1" + // InternalRosParser.g:12449:1: rule__Package_Impl__DependencyAssignment_6_3_1 : ( ruleDependency ) ; + public final void rule__Package_Impl__DependencyAssignment_6_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15340:1: ( ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) ) - // InternalRos.g:15341:2: ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) + // InternalRosParser.g:12453:1: ( ( ruleDependency ) ) + // InternalRosParser.g:12454:2: ( ruleDependency ) { - // InternalRos.g:15341:2: ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) - // InternalRos.g:15342:3: ( rule__TopicSpec__NameAlternatives_2_0 ) - { - before(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); - // InternalRos.g:15343:3: ( rule__TopicSpec__NameAlternatives_2_0 ) - // InternalRos.g:15343:4: rule__TopicSpec__NameAlternatives_2_0 + // InternalRosParser.g:12454:2: ( ruleDependency ) + // InternalRosParser.g:12455:3: ruleDependency { + before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); pushFollow(FOLLOW_2); - rule__TopicSpec__NameAlternatives_2_0(); + ruleDependency(); state._fsp--; - - } - - after(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); + after(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); } @@ -45732,29 +36909,29 @@ public final void rule__TopicSpec__NameAssignment_2() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__TopicSpec__NameAssignment_2" + // $ANTLR end "rule__Package_Impl__DependencyAssignment_6_3_1" - // $ANTLR start "rule__TopicSpec__MessageAssignment_4_1" - // InternalRos.g:15351:1: rule__TopicSpec__MessageAssignment_4_1 : ( ruleMessageDefinition ) ; - public final void rule__TopicSpec__MessageAssignment_4_1() throws RecognitionException { + // $ANTLR start "rule__Artifact__NameAssignment_1" + // InternalRosParser.g:12464:1: rule__Artifact__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__Artifact__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15355:1: ( ( ruleMessageDefinition ) ) - // InternalRos.g:15356:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12468:1: ( ( ruleRosNames ) ) + // InternalRosParser.g:12469:2: ( ruleRosNames ) { - // InternalRos.g:15356:2: ( ruleMessageDefinition ) - // InternalRos.g:15357:3: ruleMessageDefinition + // InternalRosParser.g:12469:2: ( ruleRosNames ) + // InternalRosParser.g:12470:3: ruleRosNames { - before(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_4_1_0()); + before(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); pushFollow(FOLLOW_2); - ruleMessageDefinition(); + ruleRosNames(); state._fsp--; - after(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_4_1_0()); + after(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); } @@ -45773,29 +36950,29 @@ public final void rule__TopicSpec__MessageAssignment_4_1() throws RecognitionExc } return ; } - // $ANTLR end "rule__TopicSpec__MessageAssignment_4_1" + // $ANTLR end "rule__Artifact__NameAssignment_1" - // $ANTLR start "rule__ActionSpec__NameAssignment_2" - // InternalRos.g:15366:1: rule__ActionSpec__NameAssignment_2 : ( ruleEString ) ; - public final void rule__ActionSpec__NameAssignment_2() throws RecognitionException { + // $ANTLR start "rule__Artifact__NodeAssignment_4" + // InternalRosParser.g:12479:1: rule__Artifact__NodeAssignment_4 : ( ruleNode ) ; + public final void rule__Artifact__NodeAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15370:1: ( ( ruleEString ) ) - // InternalRos.g:15371:2: ( ruleEString ) + // InternalRosParser.g:12483:1: ( ( ruleNode ) ) + // InternalRosParser.g:12484:2: ( ruleNode ) { - // InternalRos.g:15371:2: ( ruleEString ) - // InternalRos.g:15372:3: ruleEString + // InternalRosParser.g:12484:2: ( ruleNode ) + // InternalRosParser.g:12485:3: ruleNode { - before(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + before(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); pushFollow(FOLLOW_2); - ruleEString(); + ruleNode(); state._fsp--; - after(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + after(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); } @@ -45814,29 +36991,29 @@ public final void rule__ActionSpec__NameAssignment_2() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ActionSpec__NameAssignment_2" + // $ANTLR end "rule__Artifact__NodeAssignment_4" - // $ANTLR start "rule__ActionSpec__GoalAssignment_4_1" - // InternalRos.g:15381:1: rule__ActionSpec__GoalAssignment_4_1 : ( ruleMessageDefinition ) ; - public final void rule__ActionSpec__GoalAssignment_4_1() throws RecognitionException { + // $ANTLR start "rule__Node__NameAssignment_1" + // InternalRosParser.g:12494:1: rule__Node__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__Node__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15385:1: ( ( ruleMessageDefinition ) ) - // InternalRos.g:15386:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12498:1: ( ( ruleRosNames ) ) + // InternalRosParser.g:12499:2: ( ruleRosNames ) { - // InternalRos.g:15386:2: ( ruleMessageDefinition ) - // InternalRos.g:15387:3: ruleMessageDefinition + // InternalRosParser.g:12499:2: ( ruleRosNames ) + // InternalRosParser.g:12500:3: ruleRosNames { - before(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_4_1_0()); + before(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); pushFollow(FOLLOW_2); - ruleMessageDefinition(); + ruleRosNames(); state._fsp--; - after(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_4_1_0()); + after(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); } @@ -45855,29 +37032,29 @@ public final void rule__ActionSpec__GoalAssignment_4_1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ActionSpec__GoalAssignment_4_1" + // $ANTLR end "rule__Node__NameAssignment_1" - // $ANTLR start "rule__ActionSpec__ResultAssignment_5_1" - // InternalRos.g:15396:1: rule__ActionSpec__ResultAssignment_5_1 : ( ruleMessageDefinition ) ; - public final void rule__ActionSpec__ResultAssignment_5_1() throws RecognitionException { + // $ANTLR start "rule__Node__PublisherAssignment_3_0_2" + // InternalRosParser.g:12509:1: rule__Node__PublisherAssignment_3_0_2 : ( rulePublisher ) ; + public final void rule__Node__PublisherAssignment_3_0_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15400:1: ( ( ruleMessageDefinition ) ) - // InternalRos.g:15401:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12513:1: ( ( rulePublisher ) ) + // InternalRosParser.g:12514:2: ( rulePublisher ) { - // InternalRos.g:15401:2: ( ruleMessageDefinition ) - // InternalRos.g:15402:3: ruleMessageDefinition + // InternalRosParser.g:12514:2: ( rulePublisher ) + // InternalRosParser.g:12515:3: rulePublisher { - before(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_5_1_0()); + before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); pushFollow(FOLLOW_2); - ruleMessageDefinition(); + rulePublisher(); state._fsp--; - after(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_5_1_0()); + after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); } @@ -45896,29 +37073,29 @@ public final void rule__ActionSpec__ResultAssignment_5_1() throws RecognitionExc } return ; } - // $ANTLR end "rule__ActionSpec__ResultAssignment_5_1" + // $ANTLR end "rule__Node__PublisherAssignment_3_0_2" - // $ANTLR start "rule__ActionSpec__FeedbackAssignment_6_1" - // InternalRos.g:15411:1: rule__ActionSpec__FeedbackAssignment_6_1 : ( ruleMessageDefinition ) ; - public final void rule__ActionSpec__FeedbackAssignment_6_1() throws RecognitionException { + // $ANTLR start "rule__Node__SubscriberAssignment_3_1_2" + // InternalRosParser.g:12524:1: rule__Node__SubscriberAssignment_3_1_2 : ( ruleSubscriber ) ; + public final void rule__Node__SubscriberAssignment_3_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15415:1: ( ( ruleMessageDefinition ) ) - // InternalRos.g:15416:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12528:1: ( ( ruleSubscriber ) ) + // InternalRosParser.g:12529:2: ( ruleSubscriber ) { - // InternalRos.g:15416:2: ( ruleMessageDefinition ) - // InternalRos.g:15417:3: ruleMessageDefinition + // InternalRosParser.g:12529:2: ( ruleSubscriber ) + // InternalRosParser.g:12530:3: ruleSubscriber { - before(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_6_1_0()); + before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); pushFollow(FOLLOW_2); - ruleMessageDefinition(); + ruleSubscriber(); state._fsp--; - after(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_6_1_0()); + after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); } @@ -45937,29 +37114,29 @@ public final void rule__ActionSpec__FeedbackAssignment_6_1() throws RecognitionE } return ; } - // $ANTLR end "rule__ActionSpec__FeedbackAssignment_6_1" + // $ANTLR end "rule__Node__SubscriberAssignment_3_1_2" - // $ANTLR start "rule__MessageDefinition__MessagePartAssignment_2_0" - // InternalRos.g:15426:1: rule__MessageDefinition__MessagePartAssignment_2_0 : ( ruleMessagePart ) ; - public final void rule__MessageDefinition__MessagePartAssignment_2_0() throws RecognitionException { + // $ANTLR start "rule__Node__ServiceserverAssignment_3_2_2" + // InternalRosParser.g:12539:1: rule__Node__ServiceserverAssignment_3_2_2 : ( ruleServiceServer ) ; + public final void rule__Node__ServiceserverAssignment_3_2_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15430:1: ( ( ruleMessagePart ) ) - // InternalRos.g:15431:2: ( ruleMessagePart ) + // InternalRosParser.g:12543:1: ( ( ruleServiceServer ) ) + // InternalRosParser.g:12544:2: ( ruleServiceServer ) { - // InternalRos.g:15431:2: ( ruleMessagePart ) - // InternalRos.g:15432:3: ruleMessagePart + // InternalRosParser.g:12544:2: ( ruleServiceServer ) + // InternalRosParser.g:12545:3: ruleServiceServer { - before(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_0_0()); + before(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); pushFollow(FOLLOW_2); - ruleMessagePart(); + ruleServiceServer(); state._fsp--; - after(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_0_0()); + after(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); } @@ -45978,29 +37155,29 @@ public final void rule__MessageDefinition__MessagePartAssignment_2_0() throws Re } return ; } - // $ANTLR end "rule__MessageDefinition__MessagePartAssignment_2_0" + // $ANTLR end "rule__Node__ServiceserverAssignment_3_2_2" - // $ANTLR start "rule__MessageDefinition__MessagePartAssignment_2_1" - // InternalRos.g:15441:1: rule__MessageDefinition__MessagePartAssignment_2_1 : ( ruleMessagePart ) ; - public final void rule__MessageDefinition__MessagePartAssignment_2_1() throws RecognitionException { + // $ANTLR start "rule__Node__ServiceclientAssignment_3_3_2" + // InternalRosParser.g:12554:1: rule__Node__ServiceclientAssignment_3_3_2 : ( ruleServiceClient ) ; + public final void rule__Node__ServiceclientAssignment_3_3_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15445:1: ( ( ruleMessagePart ) ) - // InternalRos.g:15446:2: ( ruleMessagePart ) + // InternalRosParser.g:12558:1: ( ( ruleServiceClient ) ) + // InternalRosParser.g:12559:2: ( ruleServiceClient ) { - // InternalRos.g:15446:2: ( ruleMessagePart ) - // InternalRos.g:15447:3: ruleMessagePart + // InternalRosParser.g:12559:2: ( ruleServiceClient ) + // InternalRosParser.g:12560:3: ruleServiceClient { - before(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_1_0()); + before(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); pushFollow(FOLLOW_2); - ruleMessagePart(); + ruleServiceClient(); state._fsp--; - after(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_1_0()); + after(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); } @@ -46019,29 +37196,29 @@ public final void rule__MessageDefinition__MessagePartAssignment_2_1() throws Re } return ; } - // $ANTLR end "rule__MessageDefinition__MessagePartAssignment_2_1" + // $ANTLR end "rule__Node__ServiceclientAssignment_3_3_2" - // $ANTLR start "rule__Node__NameAssignment_3" - // InternalRos.g:15456:1: rule__Node__NameAssignment_3 : ( ruleRosNames ) ; - public final void rule__Node__NameAssignment_3() throws RecognitionException { + // $ANTLR start "rule__Node__ActionserverAssignment_3_4_2" + // InternalRosParser.g:12569:1: rule__Node__ActionserverAssignment_3_4_2 : ( ruleActionServer ) ; + public final void rule__Node__ActionserverAssignment_3_4_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15460:1: ( ( ruleRosNames ) ) - // InternalRos.g:15461:2: ( ruleRosNames ) + // InternalRosParser.g:12573:1: ( ( ruleActionServer ) ) + // InternalRosParser.g:12574:2: ( ruleActionServer ) { - // InternalRos.g:15461:2: ( ruleRosNames ) - // InternalRos.g:15462:3: ruleRosNames + // InternalRosParser.g:12574:2: ( ruleActionServer ) + // InternalRosParser.g:12575:3: ruleActionServer { - before(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_3_0()); + before(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); pushFollow(FOLLOW_2); - ruleRosNames(); + ruleActionServer(); state._fsp--; - after(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_3_0()); + after(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); } @@ -46060,29 +37237,29 @@ public final void rule__Node__NameAssignment_3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Node__NameAssignment_3" + // $ANTLR end "rule__Node__ActionserverAssignment_3_4_2" - // $ANTLR start "rule__Node__ServiceserverAssignment_4_2" - // InternalRos.g:15471:1: rule__Node__ServiceserverAssignment_4_2 : ( ruleServiceServer ) ; - public final void rule__Node__ServiceserverAssignment_4_2() throws RecognitionException { + // $ANTLR start "rule__Node__ActionclientAssignment_3_5_2" + // InternalRosParser.g:12584:1: rule__Node__ActionclientAssignment_3_5_2 : ( ruleActionClient ) ; + public final void rule__Node__ActionclientAssignment_3_5_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15475:1: ( ( ruleServiceServer ) ) - // InternalRos.g:15476:2: ( ruleServiceServer ) + // InternalRosParser.g:12588:1: ( ( ruleActionClient ) ) + // InternalRosParser.g:12589:2: ( ruleActionClient ) { - // InternalRos.g:15476:2: ( ruleServiceServer ) - // InternalRos.g:15477:3: ruleServiceServer + // InternalRosParser.g:12589:2: ( ruleActionClient ) + // InternalRosParser.g:12590:3: ruleActionClient { - before(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_2_0()); + before(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); pushFollow(FOLLOW_2); - ruleServiceServer(); + ruleActionClient(); state._fsp--; - after(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_2_0()); + after(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); } @@ -46101,29 +37278,29 @@ public final void rule__Node__ServiceserverAssignment_4_2() throws RecognitionEx } return ; } - // $ANTLR end "rule__Node__ServiceserverAssignment_4_2" + // $ANTLR end "rule__Node__ActionclientAssignment_3_5_2" - // $ANTLR start "rule__Node__ServiceserverAssignment_4_3_1" - // InternalRos.g:15486:1: rule__Node__ServiceserverAssignment_4_3_1 : ( ruleServiceServer ) ; - public final void rule__Node__ServiceserverAssignment_4_3_1() throws RecognitionException { + // $ANTLR start "rule__Node__ParameterAssignment_3_6_2" + // InternalRosParser.g:12599:1: rule__Node__ParameterAssignment_3_6_2 : ( ruleParameter ) ; + public final void rule__Node__ParameterAssignment_3_6_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15490:1: ( ( ruleServiceServer ) ) - // InternalRos.g:15491:2: ( ruleServiceServer ) + // InternalRosParser.g:12603:1: ( ( ruleParameter ) ) + // InternalRosParser.g:12604:2: ( ruleParameter ) { - // InternalRos.g:15491:2: ( ruleServiceServer ) - // InternalRos.g:15492:3: ruleServiceServer + // InternalRosParser.g:12604:2: ( ruleParameter ) + // InternalRosParser.g:12605:3: ruleParameter { - before(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_3_1_0()); + before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); pushFollow(FOLLOW_2); - ruleServiceServer(); + ruleParameter(); state._fsp--; - after(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_3_1_0()); + after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); } @@ -46142,111 +37319,35 @@ public final void rule__Node__ServiceserverAssignment_4_3_1() throws Recognition } return ; } - // $ANTLR end "rule__Node__ServiceserverAssignment_4_3_1" + // $ANTLR end "rule__Node__ParameterAssignment_3_6_2" - // $ANTLR start "rule__Node__PublisherAssignment_5_2" - // InternalRos.g:15501:1: rule__Node__PublisherAssignment_5_2 : ( rulePublisher ) ; - public final void rule__Node__PublisherAssignment_5_2() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__NameAssignment_2" + // InternalRosParser.g:12614:1: rule__TopicSpec__NameAssignment_2 : ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) ; + public final void rule__TopicSpec__NameAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15505:1: ( ( rulePublisher ) ) - // InternalRos.g:15506:2: ( rulePublisher ) + // InternalRosParser.g:12618:1: ( ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) ) + // InternalRosParser.g:12619:2: ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) { - // InternalRos.g:15506:2: ( rulePublisher ) - // InternalRos.g:15507:3: rulePublisher + // InternalRosParser.g:12619:2: ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) + // InternalRosParser.g:12620:3: ( rule__TopicSpec__NameAlternatives_2_0 ) { - before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_2_0()); - pushFollow(FOLLOW_2); - rulePublisher(); - - state._fsp--; - - after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_2_0()); - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__PublisherAssignment_5_2" - - - // $ANTLR start "rule__Node__PublisherAssignment_5_3_1" - // InternalRos.g:15516:1: rule__Node__PublisherAssignment_5_3_1 : ( rulePublisher ) ; - public final void rule__Node__PublisherAssignment_5_3_1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:15520:1: ( ( rulePublisher ) ) - // InternalRos.g:15521:2: ( rulePublisher ) - { - // InternalRos.g:15521:2: ( rulePublisher ) - // InternalRos.g:15522:3: rulePublisher + before(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); + // InternalRosParser.g:12621:3: ( rule__TopicSpec__NameAlternatives_2_0 ) + // InternalRosParser.g:12621:4: rule__TopicSpec__NameAlternatives_2_0 { - before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_3_1_0()); pushFollow(FOLLOW_2); - rulePublisher(); + rule__TopicSpec__NameAlternatives_2_0(); state._fsp--; - after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_3_1_0()); - - } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Node__PublisherAssignment_5_3_1" - - - // $ANTLR start "rule__Node__SubscriberAssignment_6_2" - // InternalRos.g:15531:1: rule__Node__SubscriberAssignment_6_2 : ( ruleSubscriber ) ; - public final void rule__Node__SubscriberAssignment_6_2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalRos.g:15535:1: ( ( ruleSubscriber ) ) - // InternalRos.g:15536:2: ( ruleSubscriber ) - { - // InternalRos.g:15536:2: ( ruleSubscriber ) - // InternalRos.g:15537:3: ruleSubscriber - { - before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_2_0()); - pushFollow(FOLLOW_2); - ruleSubscriber(); - - state._fsp--; - - after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_2_0()); + after(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); } @@ -46265,29 +37366,29 @@ public final void rule__Node__SubscriberAssignment_6_2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Node__SubscriberAssignment_6_2" + // $ANTLR end "rule__TopicSpec__NameAssignment_2" - // $ANTLR start "rule__Node__SubscriberAssignment_6_3_1" - // InternalRos.g:15546:1: rule__Node__SubscriberAssignment_6_3_1 : ( ruleSubscriber ) ; - public final void rule__Node__SubscriberAssignment_6_3_1() throws RecognitionException { + // $ANTLR start "rule__TopicSpec__MessageAssignment_5_1" + // InternalRosParser.g:12629:1: rule__TopicSpec__MessageAssignment_5_1 : ( ruleMessageDefinition ) ; + public final void rule__TopicSpec__MessageAssignment_5_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15550:1: ( ( ruleSubscriber ) ) - // InternalRos.g:15551:2: ( ruleSubscriber ) + // InternalRosParser.g:12633:1: ( ( ruleMessageDefinition ) ) + // InternalRosParser.g:12634:2: ( ruleMessageDefinition ) { - // InternalRos.g:15551:2: ( ruleSubscriber ) - // InternalRos.g:15552:3: ruleSubscriber + // InternalRosParser.g:12634:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12635:3: ruleMessageDefinition { - before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_3_1_0()); + before(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); pushFollow(FOLLOW_2); - ruleSubscriber(); + ruleMessageDefinition(); state._fsp--; - after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_3_1_0()); + after(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); } @@ -46306,29 +37407,29 @@ public final void rule__Node__SubscriberAssignment_6_3_1() throws RecognitionExc } return ; } - // $ANTLR end "rule__Node__SubscriberAssignment_6_3_1" + // $ANTLR end "rule__TopicSpec__MessageAssignment_5_1" - // $ANTLR start "rule__Node__ServiceclientAssignment_7_2" - // InternalRos.g:15561:1: rule__Node__ServiceclientAssignment_7_2 : ( ruleServiceClient ) ; - public final void rule__Node__ServiceclientAssignment_7_2() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__NameAssignment_2" + // InternalRosParser.g:12644:1: rule__ServiceSpec__NameAssignment_2 : ( ruleEString ) ; + public final void rule__ServiceSpec__NameAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15565:1: ( ( ruleServiceClient ) ) - // InternalRos.g:15566:2: ( ruleServiceClient ) + // InternalRosParser.g:12648:1: ( ( ruleEString ) ) + // InternalRosParser.g:12649:2: ( ruleEString ) { - // InternalRos.g:15566:2: ( ruleServiceClient ) - // InternalRos.g:15567:3: ruleServiceClient + // InternalRosParser.g:12649:2: ( ruleEString ) + // InternalRosParser.g:12650:3: ruleEString { - before(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_2_0()); + before(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); pushFollow(FOLLOW_2); - ruleServiceClient(); + ruleEString(); state._fsp--; - after(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_2_0()); + after(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); } @@ -46347,29 +37448,29 @@ public final void rule__Node__ServiceclientAssignment_7_2() throws RecognitionEx } return ; } - // $ANTLR end "rule__Node__ServiceclientAssignment_7_2" + // $ANTLR end "rule__ServiceSpec__NameAssignment_2" - // $ANTLR start "rule__Node__ServiceclientAssignment_7_3_1" - // InternalRos.g:15576:1: rule__Node__ServiceclientAssignment_7_3_1 : ( ruleServiceClient ) ; - public final void rule__Node__ServiceclientAssignment_7_3_1() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__RequestAssignment_5_1" + // InternalRosParser.g:12659:1: rule__ServiceSpec__RequestAssignment_5_1 : ( ruleMessageDefinition ) ; + public final void rule__ServiceSpec__RequestAssignment_5_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15580:1: ( ( ruleServiceClient ) ) - // InternalRos.g:15581:2: ( ruleServiceClient ) + // InternalRosParser.g:12663:1: ( ( ruleMessageDefinition ) ) + // InternalRosParser.g:12664:2: ( ruleMessageDefinition ) { - // InternalRos.g:15581:2: ( ruleServiceClient ) - // InternalRos.g:15582:3: ruleServiceClient + // InternalRosParser.g:12664:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12665:3: ruleMessageDefinition { - before(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_3_1_0()); + before(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); pushFollow(FOLLOW_2); - ruleServiceClient(); + ruleMessageDefinition(); state._fsp--; - after(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_3_1_0()); + after(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); } @@ -46388,29 +37489,29 @@ public final void rule__Node__ServiceclientAssignment_7_3_1() throws Recognition } return ; } - // $ANTLR end "rule__Node__ServiceclientAssignment_7_3_1" + // $ANTLR end "rule__ServiceSpec__RequestAssignment_5_1" - // $ANTLR start "rule__Node__ActionserverAssignment_8_2" - // InternalRos.g:15591:1: rule__Node__ActionserverAssignment_8_2 : ( ruleActionServer ) ; - public final void rule__Node__ActionserverAssignment_8_2() throws RecognitionException { + // $ANTLR start "rule__ServiceSpec__ResponseAssignment_7_1" + // InternalRosParser.g:12674:1: rule__ServiceSpec__ResponseAssignment_7_1 : ( ruleMessageDefinition ) ; + public final void rule__ServiceSpec__ResponseAssignment_7_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15595:1: ( ( ruleActionServer ) ) - // InternalRos.g:15596:2: ( ruleActionServer ) + // InternalRosParser.g:12678:1: ( ( ruleMessageDefinition ) ) + // InternalRosParser.g:12679:2: ( ruleMessageDefinition ) { - // InternalRos.g:15596:2: ( ruleActionServer ) - // InternalRos.g:15597:3: ruleActionServer + // InternalRosParser.g:12679:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12680:3: ruleMessageDefinition { - before(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_2_0()); + before(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); pushFollow(FOLLOW_2); - ruleActionServer(); + ruleMessageDefinition(); state._fsp--; - after(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_2_0()); + after(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); } @@ -46429,29 +37530,29 @@ public final void rule__Node__ActionserverAssignment_8_2() throws RecognitionExc } return ; } - // $ANTLR end "rule__Node__ActionserverAssignment_8_2" + // $ANTLR end "rule__ServiceSpec__ResponseAssignment_7_1" - // $ANTLR start "rule__Node__ActionserverAssignment_8_3_1" - // InternalRos.g:15606:1: rule__Node__ActionserverAssignment_8_3_1 : ( ruleActionServer ) ; - public final void rule__Node__ActionserverAssignment_8_3_1() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__NameAssignment_2" + // InternalRosParser.g:12689:1: rule__ActionSpec__NameAssignment_2 : ( ruleEString ) ; + public final void rule__ActionSpec__NameAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15610:1: ( ( ruleActionServer ) ) - // InternalRos.g:15611:2: ( ruleActionServer ) + // InternalRosParser.g:12693:1: ( ( ruleEString ) ) + // InternalRosParser.g:12694:2: ( ruleEString ) { - // InternalRos.g:15611:2: ( ruleActionServer ) - // InternalRos.g:15612:3: ruleActionServer + // InternalRosParser.g:12694:2: ( ruleEString ) + // InternalRosParser.g:12695:3: ruleEString { - before(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_3_1_0()); + before(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); pushFollow(FOLLOW_2); - ruleActionServer(); + ruleEString(); state._fsp--; - after(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_3_1_0()); + after(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); } @@ -46470,29 +37571,29 @@ public final void rule__Node__ActionserverAssignment_8_3_1() throws RecognitionE } return ; } - // $ANTLR end "rule__Node__ActionserverAssignment_8_3_1" + // $ANTLR end "rule__ActionSpec__NameAssignment_2" - // $ANTLR start "rule__Node__ActionclientAssignment_9_2" - // InternalRos.g:15621:1: rule__Node__ActionclientAssignment_9_2 : ( ruleActionClient ) ; - public final void rule__Node__ActionclientAssignment_9_2() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__GoalAssignment_5_1" + // InternalRosParser.g:12704:1: rule__ActionSpec__GoalAssignment_5_1 : ( ruleMessageDefinition ) ; + public final void rule__ActionSpec__GoalAssignment_5_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15625:1: ( ( ruleActionClient ) ) - // InternalRos.g:15626:2: ( ruleActionClient ) + // InternalRosParser.g:12708:1: ( ( ruleMessageDefinition ) ) + // InternalRosParser.g:12709:2: ( ruleMessageDefinition ) { - // InternalRos.g:15626:2: ( ruleActionClient ) - // InternalRos.g:15627:3: ruleActionClient + // InternalRosParser.g:12709:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12710:3: ruleMessageDefinition { - before(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_2_0()); + before(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); pushFollow(FOLLOW_2); - ruleActionClient(); + ruleMessageDefinition(); state._fsp--; - after(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_2_0()); + after(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); } @@ -46511,29 +37612,29 @@ public final void rule__Node__ActionclientAssignment_9_2() throws RecognitionExc } return ; } - // $ANTLR end "rule__Node__ActionclientAssignment_9_2" + // $ANTLR end "rule__ActionSpec__GoalAssignment_5_1" - // $ANTLR start "rule__Node__ActionclientAssignment_9_3_1" - // InternalRos.g:15636:1: rule__Node__ActionclientAssignment_9_3_1 : ( ruleActionClient ) ; - public final void rule__Node__ActionclientAssignment_9_3_1() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__ResultAssignment_7_1" + // InternalRosParser.g:12719:1: rule__ActionSpec__ResultAssignment_7_1 : ( ruleMessageDefinition ) ; + public final void rule__ActionSpec__ResultAssignment_7_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15640:1: ( ( ruleActionClient ) ) - // InternalRos.g:15641:2: ( ruleActionClient ) + // InternalRosParser.g:12723:1: ( ( ruleMessageDefinition ) ) + // InternalRosParser.g:12724:2: ( ruleMessageDefinition ) { - // InternalRos.g:15641:2: ( ruleActionClient ) - // InternalRos.g:15642:3: ruleActionClient + // InternalRosParser.g:12724:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12725:3: ruleMessageDefinition { - before(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_3_1_0()); + before(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); pushFollow(FOLLOW_2); - ruleActionClient(); + ruleMessageDefinition(); state._fsp--; - after(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_3_1_0()); + after(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); } @@ -46552,29 +37653,29 @@ public final void rule__Node__ActionclientAssignment_9_3_1() throws RecognitionE } return ; } - // $ANTLR end "rule__Node__ActionclientAssignment_9_3_1" + // $ANTLR end "rule__ActionSpec__ResultAssignment_7_1" - // $ANTLR start "rule__Node__ParameterAssignment_10_2" - // InternalRos.g:15651:1: rule__Node__ParameterAssignment_10_2 : ( ruleParameter ) ; - public final void rule__Node__ParameterAssignment_10_2() throws RecognitionException { + // $ANTLR start "rule__ActionSpec__FeedbackAssignment_9_1" + // InternalRosParser.g:12734:1: rule__ActionSpec__FeedbackAssignment_9_1 : ( ruleMessageDefinition ) ; + public final void rule__ActionSpec__FeedbackAssignment_9_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15655:1: ( ( ruleParameter ) ) - // InternalRos.g:15656:2: ( ruleParameter ) + // InternalRosParser.g:12738:1: ( ( ruleMessageDefinition ) ) + // InternalRosParser.g:12739:2: ( ruleMessageDefinition ) { - // InternalRos.g:15656:2: ( ruleParameter ) - // InternalRos.g:15657:3: ruleParameter + // InternalRosParser.g:12739:2: ( ruleMessageDefinition ) + // InternalRosParser.g:12740:3: ruleMessageDefinition { - before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_2_0()); + before(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); pushFollow(FOLLOW_2); - ruleParameter(); + ruleMessageDefinition(); state._fsp--; - after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_2_0()); + after(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); } @@ -46593,29 +37694,29 @@ public final void rule__Node__ParameterAssignment_10_2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Node__ParameterAssignment_10_2" + // $ANTLR end "rule__ActionSpec__FeedbackAssignment_9_1" - // $ANTLR start "rule__Node__ParameterAssignment_10_3_1" - // InternalRos.g:15666:1: rule__Node__ParameterAssignment_10_3_1 : ( ruleParameter ) ; - public final void rule__Node__ParameterAssignment_10_3_1() throws RecognitionException { + // $ANTLR start "rule__MessageDefinition__MessagePartAssignment_1" + // InternalRosParser.g:12749:1: rule__MessageDefinition__MessagePartAssignment_1 : ( ruleMessagePart ) ; + public final void rule__MessageDefinition__MessagePartAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15670:1: ( ( ruleParameter ) ) - // InternalRos.g:15671:2: ( ruleParameter ) + // InternalRosParser.g:12753:1: ( ( ruleMessagePart ) ) + // InternalRosParser.g:12754:2: ( ruleMessagePart ) { - // InternalRos.g:15671:2: ( ruleParameter ) - // InternalRos.g:15672:3: ruleParameter + // InternalRosParser.g:12754:2: ( ruleMessagePart ) + // InternalRosParser.g:12755:3: ruleMessagePart { - before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_3_1_0()); + before(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); pushFollow(FOLLOW_2); - ruleParameter(); + ruleMessagePart(); state._fsp--; - after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_3_1_0()); + after(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); } @@ -46634,29 +37735,29 @@ public final void rule__Node__ParameterAssignment_10_3_1() throws RecognitionExc } return ; } - // $ANTLR end "rule__Node__ParameterAssignment_10_3_1" + // $ANTLR end "rule__MessageDefinition__MessagePartAssignment_1" - // $ANTLR start "rule__ServiceServer__NameAssignment_3" - // InternalRos.g:15681:1: rule__ServiceServer__NameAssignment_3 : ( ruleEString ) ; - public final void rule__ServiceServer__NameAssignment_3() throws RecognitionException { + // $ANTLR start "rule__Publisher__NameAssignment_1" + // InternalRosParser.g:12764:1: rule__Publisher__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Publisher__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15685:1: ( ( ruleEString ) ) - // InternalRos.g:15686:2: ( ruleEString ) + // InternalRosParser.g:12768:1: ( ( ruleEString ) ) + // InternalRosParser.g:12769:2: ( ruleEString ) { - // InternalRos.g:15686:2: ( ruleEString ) - // InternalRos.g:15687:3: ruleEString + // InternalRosParser.g:12769:2: ( ruleEString ) + // InternalRosParser.g:12770:3: ruleEString { - before(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_3_0()); + before(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_3_0()); + after(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); } @@ -46675,37 +37776,37 @@ public final void rule__ServiceServer__NameAssignment_3() throws RecognitionExce } return ; } - // $ANTLR end "rule__ServiceServer__NameAssignment_3" + // $ANTLR end "rule__Publisher__NameAssignment_1" - // $ANTLR start "rule__ServiceServer__ServiceAssignment_5" - // InternalRos.g:15696:1: rule__ServiceServer__ServiceAssignment_5 : ( ( ruleEString ) ) ; - public final void rule__ServiceServer__ServiceAssignment_5() throws RecognitionException { + // $ANTLR start "rule__Publisher__MessageAssignment_5" + // InternalRosParser.g:12779:1: rule__Publisher__MessageAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__Publisher__MessageAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15700:1: ( ( ( ruleEString ) ) ) - // InternalRos.g:15701:2: ( ( ruleEString ) ) + // InternalRosParser.g:12783:1: ( ( ( ruleEString ) ) ) + // InternalRosParser.g:12784:2: ( ( ruleEString ) ) { - // InternalRos.g:15701:2: ( ( ruleEString ) ) - // InternalRos.g:15702:3: ( ruleEString ) + // InternalRosParser.g:12784:2: ( ( ruleEString ) ) + // InternalRosParser.g:12785:3: ( ruleEString ) { - before(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); - // InternalRos.g:15703:3: ( ruleEString ) - // InternalRos.g:15704:4: ruleEString + before(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + // InternalRosParser.g:12786:3: ( ruleEString ) + // InternalRosParser.g:12787:4: ruleEString { - before(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); + before(grammarAccess.getPublisherAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); + after(grammarAccess.getPublisherAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); } - after(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); + after(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); } @@ -46724,29 +37825,29 @@ public final void rule__ServiceServer__ServiceAssignment_5() throws RecognitionE } return ; } - // $ANTLR end "rule__ServiceServer__ServiceAssignment_5" + // $ANTLR end "rule__Publisher__MessageAssignment_5" - // $ANTLR start "rule__ServiceServer__NamespaceAssignment_6_1" - // InternalRos.g:15715:1: rule__ServiceServer__NamespaceAssignment_6_1 : ( ruleNamespace ) ; - public final void rule__ServiceServer__NamespaceAssignment_6_1() throws RecognitionException { + // $ANTLR start "rule__Publisher__NamespaceAssignment_6_1" + // InternalRosParser.g:12798:1: rule__Publisher__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__Publisher__NamespaceAssignment_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15719:1: ( ( ruleNamespace ) ) - // InternalRos.g:15720:2: ( ruleNamespace ) + // InternalRosParser.g:12802:1: ( ( ruleNamespace ) ) + // InternalRosParser.g:12803:2: ( ruleNamespace ) { - // InternalRos.g:15720:2: ( ruleNamespace ) - // InternalRos.g:15721:3: ruleNamespace + // InternalRosParser.g:12803:2: ( ruleNamespace ) + // InternalRosParser.g:12804:3: ruleNamespace { - before(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + before(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); pushFollow(FOLLOW_2); ruleNamespace(); state._fsp--; - after(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + after(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } @@ -46765,29 +37866,29 @@ public final void rule__ServiceServer__NamespaceAssignment_6_1() throws Recognit } return ; } - // $ANTLR end "rule__ServiceServer__NamespaceAssignment_6_1" + // $ANTLR end "rule__Publisher__NamespaceAssignment_6_1" - // $ANTLR start "rule__Publisher__NameAssignment_3" - // InternalRos.g:15730:1: rule__Publisher__NameAssignment_3 : ( ruleEString ) ; - public final void rule__Publisher__NameAssignment_3() throws RecognitionException { + // $ANTLR start "rule__Subscriber__NameAssignment_1" + // InternalRosParser.g:12813:1: rule__Subscriber__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Subscriber__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15734:1: ( ( ruleEString ) ) - // InternalRos.g:15735:2: ( ruleEString ) + // InternalRosParser.g:12817:1: ( ( ruleEString ) ) + // InternalRosParser.g:12818:2: ( ruleEString ) { - // InternalRos.g:15735:2: ( ruleEString ) - // InternalRos.g:15736:3: ruleEString + // InternalRosParser.g:12818:2: ( ruleEString ) + // InternalRosParser.g:12819:3: ruleEString { - before(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_3_0()); + before(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_3_0()); + after(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); } @@ -46806,37 +37907,37 @@ public final void rule__Publisher__NameAssignment_3() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Publisher__NameAssignment_3" + // $ANTLR end "rule__Subscriber__NameAssignment_1" - // $ANTLR start "rule__Publisher__MessageAssignment_5" - // InternalRos.g:15745:1: rule__Publisher__MessageAssignment_5 : ( ( ruleEString ) ) ; - public final void rule__Publisher__MessageAssignment_5() throws RecognitionException { + // $ANTLR start "rule__Subscriber__MessageAssignment_5" + // InternalRosParser.g:12828:1: rule__Subscriber__MessageAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__Subscriber__MessageAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15749:1: ( ( ( ruleEString ) ) ) - // InternalRos.g:15750:2: ( ( ruleEString ) ) + // InternalRosParser.g:12832:1: ( ( ( ruleEString ) ) ) + // InternalRosParser.g:12833:2: ( ( ruleEString ) ) { - // InternalRos.g:15750:2: ( ( ruleEString ) ) - // InternalRos.g:15751:3: ( ruleEString ) + // InternalRosParser.g:12833:2: ( ( ruleEString ) ) + // InternalRosParser.g:12834:3: ( ruleEString ) { - before(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); - // InternalRos.g:15752:3: ( ruleEString ) - // InternalRos.g:15753:4: ruleEString + before(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + // InternalRosParser.g:12835:3: ( ruleEString ) + // InternalRosParser.g:12836:4: ruleEString { - before(grammarAccess.getPublisherAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); + before(grammarAccess.getSubscriberAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getPublisherAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); + after(grammarAccess.getSubscriberAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); } - after(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + after(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); } @@ -46855,29 +37956,29 @@ public final void rule__Publisher__MessageAssignment_5() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Publisher__MessageAssignment_5" + // $ANTLR end "rule__Subscriber__MessageAssignment_5" - // $ANTLR start "rule__Publisher__NamespaceAssignment_6_1" - // InternalRos.g:15764:1: rule__Publisher__NamespaceAssignment_6_1 : ( ruleNamespace ) ; - public final void rule__Publisher__NamespaceAssignment_6_1() throws RecognitionException { + // $ANTLR start "rule__Subscriber__NamespaceAssignment_6_1" + // InternalRosParser.g:12847:1: rule__Subscriber__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__Subscriber__NamespaceAssignment_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15768:1: ( ( ruleNamespace ) ) - // InternalRos.g:15769:2: ( ruleNamespace ) + // InternalRosParser.g:12851:1: ( ( ruleNamespace ) ) + // InternalRosParser.g:12852:2: ( ruleNamespace ) { - // InternalRos.g:15769:2: ( ruleNamespace ) - // InternalRos.g:15770:3: ruleNamespace + // InternalRosParser.g:12852:2: ( ruleNamespace ) + // InternalRosParser.g:12853:3: ruleNamespace { - before(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + before(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); pushFollow(FOLLOW_2); ruleNamespace(); state._fsp--; - after(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + after(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } @@ -46896,29 +37997,29 @@ public final void rule__Publisher__NamespaceAssignment_6_1() throws RecognitionE } return ; } - // $ANTLR end "rule__Publisher__NamespaceAssignment_6_1" + // $ANTLR end "rule__Subscriber__NamespaceAssignment_6_1" - // $ANTLR start "rule__Subscriber__NameAssignment_3" - // InternalRos.g:15779:1: rule__Subscriber__NameAssignment_3 : ( ruleEString ) ; - public final void rule__Subscriber__NameAssignment_3() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__NameAssignment_1" + // InternalRosParser.g:12862:1: rule__ServiceServer__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ServiceServer__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15783:1: ( ( ruleEString ) ) - // InternalRos.g:15784:2: ( ruleEString ) + // InternalRosParser.g:12866:1: ( ( ruleEString ) ) + // InternalRosParser.g:12867:2: ( ruleEString ) { - // InternalRos.g:15784:2: ( ruleEString ) - // InternalRos.g:15785:3: ruleEString + // InternalRosParser.g:12867:2: ( ruleEString ) + // InternalRosParser.g:12868:3: ruleEString { - before(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_3_0()); + before(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_3_0()); + after(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); } @@ -46937,37 +38038,37 @@ public final void rule__Subscriber__NameAssignment_3() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Subscriber__NameAssignment_3" + // $ANTLR end "rule__ServiceServer__NameAssignment_1" - // $ANTLR start "rule__Subscriber__MessageAssignment_5" - // InternalRos.g:15794:1: rule__Subscriber__MessageAssignment_5 : ( ( ruleEString ) ) ; - public final void rule__Subscriber__MessageAssignment_5() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__ServiceAssignment_5" + // InternalRosParser.g:12877:1: rule__ServiceServer__ServiceAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__ServiceServer__ServiceAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15798:1: ( ( ( ruleEString ) ) ) - // InternalRos.g:15799:2: ( ( ruleEString ) ) + // InternalRosParser.g:12881:1: ( ( ( ruleEString ) ) ) + // InternalRosParser.g:12882:2: ( ( ruleEString ) ) { - // InternalRos.g:15799:2: ( ( ruleEString ) ) - // InternalRos.g:15800:3: ( ruleEString ) + // InternalRosParser.g:12882:2: ( ( ruleEString ) ) + // InternalRosParser.g:12883:3: ( ruleEString ) { - before(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); - // InternalRos.g:15801:3: ( ruleEString ) - // InternalRos.g:15802:4: ruleEString + before(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); + // InternalRosParser.g:12884:3: ( ruleEString ) + // InternalRosParser.g:12885:4: ruleEString { - before(grammarAccess.getSubscriberAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); + before(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getSubscriberAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); + after(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } - after(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + after(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); } @@ -46986,29 +38087,29 @@ public final void rule__Subscriber__MessageAssignment_5() throws RecognitionExce } return ; } - // $ANTLR end "rule__Subscriber__MessageAssignment_5" + // $ANTLR end "rule__ServiceServer__ServiceAssignment_5" - // $ANTLR start "rule__Subscriber__NamespaceAssignment_6_1" - // InternalRos.g:15813:1: rule__Subscriber__NamespaceAssignment_6_1 : ( ruleNamespace ) ; - public final void rule__Subscriber__NamespaceAssignment_6_1() throws RecognitionException { + // $ANTLR start "rule__ServiceServer__NamespaceAssignment_6_1" + // InternalRosParser.g:12896:1: rule__ServiceServer__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__ServiceServer__NamespaceAssignment_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15817:1: ( ( ruleNamespace ) ) - // InternalRos.g:15818:2: ( ruleNamespace ) + // InternalRosParser.g:12900:1: ( ( ruleNamespace ) ) + // InternalRosParser.g:12901:2: ( ruleNamespace ) { - // InternalRos.g:15818:2: ( ruleNamespace ) - // InternalRos.g:15819:3: ruleNamespace + // InternalRosParser.g:12901:2: ( ruleNamespace ) + // InternalRosParser.g:12902:3: ruleNamespace { - before(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + before(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); pushFollow(FOLLOW_2); ruleNamespace(); state._fsp--; - after(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + after(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } @@ -47027,29 +38128,29 @@ public final void rule__Subscriber__NamespaceAssignment_6_1() throws Recognition } return ; } - // $ANTLR end "rule__Subscriber__NamespaceAssignment_6_1" + // $ANTLR end "rule__ServiceServer__NamespaceAssignment_6_1" - // $ANTLR start "rule__ServiceClient__NameAssignment_3" - // InternalRos.g:15828:1: rule__ServiceClient__NameAssignment_3 : ( ruleEString ) ; - public final void rule__ServiceClient__NameAssignment_3() throws RecognitionException { + // $ANTLR start "rule__ServiceClient__NameAssignment_1" + // InternalRosParser.g:12911:1: rule__ServiceClient__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ServiceClient__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15832:1: ( ( ruleEString ) ) - // InternalRos.g:15833:2: ( ruleEString ) + // InternalRosParser.g:12915:1: ( ( ruleEString ) ) + // InternalRosParser.g:12916:2: ( ruleEString ) { - // InternalRos.g:15833:2: ( ruleEString ) - // InternalRos.g:15834:3: ruleEString + // InternalRosParser.g:12916:2: ( ruleEString ) + // InternalRosParser.g:12917:3: ruleEString { - before(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_3_0()); + before(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_3_0()); + after(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); } @@ -47068,25 +38169,25 @@ public final void rule__ServiceClient__NameAssignment_3() throws RecognitionExce } return ; } - // $ANTLR end "rule__ServiceClient__NameAssignment_3" + // $ANTLR end "rule__ServiceClient__NameAssignment_1" // $ANTLR start "rule__ServiceClient__ServiceAssignment_5" - // InternalRos.g:15843:1: rule__ServiceClient__ServiceAssignment_5 : ( ( ruleEString ) ) ; + // InternalRosParser.g:12926:1: rule__ServiceClient__ServiceAssignment_5 : ( ( ruleEString ) ) ; public final void rule__ServiceClient__ServiceAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15847:1: ( ( ( ruleEString ) ) ) - // InternalRos.g:15848:2: ( ( ruleEString ) ) + // InternalRosParser.g:12930:1: ( ( ( ruleEString ) ) ) + // InternalRosParser.g:12931:2: ( ( ruleEString ) ) { - // InternalRos.g:15848:2: ( ( ruleEString ) ) - // InternalRos.g:15849:3: ( ruleEString ) + // InternalRosParser.g:12931:2: ( ( ruleEString ) ) + // InternalRosParser.g:12932:3: ( ruleEString ) { before(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); - // InternalRos.g:15850:3: ( ruleEString ) - // InternalRos.g:15851:4: ruleEString + // InternalRosParser.g:12933:3: ( ruleEString ) + // InternalRosParser.g:12934:4: ruleEString { before(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); pushFollow(FOLLOW_2); @@ -47121,17 +38222,17 @@ public final void rule__ServiceClient__ServiceAssignment_5() throws RecognitionE // $ANTLR start "rule__ServiceClient__NamespaceAssignment_6_1" - // InternalRos.g:15862:1: rule__ServiceClient__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + // InternalRosParser.g:12945:1: rule__ServiceClient__NamespaceAssignment_6_1 : ( ruleNamespace ) ; public final void rule__ServiceClient__NamespaceAssignment_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15866:1: ( ( ruleNamespace ) ) - // InternalRos.g:15867:2: ( ruleNamespace ) + // InternalRosParser.g:12949:1: ( ( ruleNamespace ) ) + // InternalRosParser.g:12950:2: ( ruleNamespace ) { - // InternalRos.g:15867:2: ( ruleNamespace ) - // InternalRos.g:15868:3: ruleNamespace + // InternalRosParser.g:12950:2: ( ruleNamespace ) + // InternalRosParser.g:12951:3: ruleNamespace { before(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); pushFollow(FOLLOW_2); @@ -47161,26 +38262,26 @@ public final void rule__ServiceClient__NamespaceAssignment_6_1() throws Recognit // $ANTLR end "rule__ServiceClient__NamespaceAssignment_6_1" - // $ANTLR start "rule__ActionServer__NameAssignment_3" - // InternalRos.g:15877:1: rule__ActionServer__NameAssignment_3 : ( ruleEString ) ; - public final void rule__ActionServer__NameAssignment_3() throws RecognitionException { + // $ANTLR start "rule__ActionServer__NameAssignment_1" + // InternalRosParser.g:12960:1: rule__ActionServer__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ActionServer__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15881:1: ( ( ruleEString ) ) - // InternalRos.g:15882:2: ( ruleEString ) + // InternalRosParser.g:12964:1: ( ( ruleEString ) ) + // InternalRosParser.g:12965:2: ( ruleEString ) { - // InternalRos.g:15882:2: ( ruleEString ) - // InternalRos.g:15883:3: ruleEString + // InternalRosParser.g:12965:2: ( ruleEString ) + // InternalRosParser.g:12966:3: ruleEString { - before(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_3_0()); + before(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_3_0()); + after(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); } @@ -47199,25 +38300,25 @@ public final void rule__ActionServer__NameAssignment_3() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ActionServer__NameAssignment_3" + // $ANTLR end "rule__ActionServer__NameAssignment_1" // $ANTLR start "rule__ActionServer__ActionAssignment_5" - // InternalRos.g:15892:1: rule__ActionServer__ActionAssignment_5 : ( ( ruleEString ) ) ; + // InternalRosParser.g:12975:1: rule__ActionServer__ActionAssignment_5 : ( ( ruleEString ) ) ; public final void rule__ActionServer__ActionAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15896:1: ( ( ( ruleEString ) ) ) - // InternalRos.g:15897:2: ( ( ruleEString ) ) + // InternalRosParser.g:12979:1: ( ( ( ruleEString ) ) ) + // InternalRosParser.g:12980:2: ( ( ruleEString ) ) { - // InternalRos.g:15897:2: ( ( ruleEString ) ) - // InternalRos.g:15898:3: ( ruleEString ) + // InternalRosParser.g:12980:2: ( ( ruleEString ) ) + // InternalRosParser.g:12981:3: ( ruleEString ) { before(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); - // InternalRos.g:15899:3: ( ruleEString ) - // InternalRos.g:15900:4: ruleEString + // InternalRosParser.g:12982:3: ( ruleEString ) + // InternalRosParser.g:12983:4: ruleEString { before(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); pushFollow(FOLLOW_2); @@ -47252,17 +38353,17 @@ public final void rule__ActionServer__ActionAssignment_5() throws RecognitionExc // $ANTLR start "rule__ActionServer__NamespaceAssignment_6_1" - // InternalRos.g:15911:1: rule__ActionServer__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + // InternalRosParser.g:12994:1: rule__ActionServer__NamespaceAssignment_6_1 : ( ruleNamespace ) ; public final void rule__ActionServer__NamespaceAssignment_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15915:1: ( ( ruleNamespace ) ) - // InternalRos.g:15916:2: ( ruleNamespace ) + // InternalRosParser.g:12998:1: ( ( ruleNamespace ) ) + // InternalRosParser.g:12999:2: ( ruleNamespace ) { - // InternalRos.g:15916:2: ( ruleNamespace ) - // InternalRos.g:15917:3: ruleNamespace + // InternalRosParser.g:12999:2: ( ruleNamespace ) + // InternalRosParser.g:13000:3: ruleNamespace { before(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); pushFollow(FOLLOW_2); @@ -47292,26 +38393,26 @@ public final void rule__ActionServer__NamespaceAssignment_6_1() throws Recogniti // $ANTLR end "rule__ActionServer__NamespaceAssignment_6_1" - // $ANTLR start "rule__ActionClient__NameAssignment_3" - // InternalRos.g:15926:1: rule__ActionClient__NameAssignment_3 : ( ruleEString ) ; - public final void rule__ActionClient__NameAssignment_3() throws RecognitionException { + // $ANTLR start "rule__ActionClient__NameAssignment_1" + // InternalRosParser.g:13009:1: rule__ActionClient__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ActionClient__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15930:1: ( ( ruleEString ) ) - // InternalRos.g:15931:2: ( ruleEString ) + // InternalRosParser.g:13013:1: ( ( ruleEString ) ) + // InternalRosParser.g:13014:2: ( ruleEString ) { - // InternalRos.g:15931:2: ( ruleEString ) - // InternalRos.g:15932:3: ruleEString + // InternalRosParser.g:13014:2: ( ruleEString ) + // InternalRosParser.g:13015:3: ruleEString { - before(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_3_0()); + before(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_3_0()); + after(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); } @@ -47330,25 +38431,25 @@ public final void rule__ActionClient__NameAssignment_3() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ActionClient__NameAssignment_3" + // $ANTLR end "rule__ActionClient__NameAssignment_1" // $ANTLR start "rule__ActionClient__ActionAssignment_5" - // InternalRos.g:15941:1: rule__ActionClient__ActionAssignment_5 : ( ( ruleEString ) ) ; + // InternalRosParser.g:13024:1: rule__ActionClient__ActionAssignment_5 : ( ( ruleEString ) ) ; public final void rule__ActionClient__ActionAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15945:1: ( ( ( ruleEString ) ) ) - // InternalRos.g:15946:2: ( ( ruleEString ) ) + // InternalRosParser.g:13028:1: ( ( ( ruleEString ) ) ) + // InternalRosParser.g:13029:2: ( ( ruleEString ) ) { - // InternalRos.g:15946:2: ( ( ruleEString ) ) - // InternalRos.g:15947:3: ( ruleEString ) + // InternalRosParser.g:13029:2: ( ( ruleEString ) ) + // InternalRosParser.g:13030:3: ( ruleEString ) { before(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); - // InternalRos.g:15948:3: ( ruleEString ) - // InternalRos.g:15949:4: ruleEString + // InternalRosParser.g:13031:3: ( ruleEString ) + // InternalRosParser.g:13032:4: ruleEString { before(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); pushFollow(FOLLOW_2); @@ -47383,17 +38484,17 @@ public final void rule__ActionClient__ActionAssignment_5() throws RecognitionExc // $ANTLR start "rule__ActionClient__NamespaceAssignment_6_1" - // InternalRos.g:15960:1: rule__ActionClient__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + // InternalRosParser.g:13043:1: rule__ActionClient__NamespaceAssignment_6_1 : ( ruleNamespace ) ; public final void rule__ActionClient__NamespaceAssignment_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15964:1: ( ( ruleNamespace ) ) - // InternalRos.g:15965:2: ( ruleNamespace ) + // InternalRosParser.g:13047:1: ( ( ruleNamespace ) ) + // InternalRosParser.g:13048:2: ( ruleNamespace ) { - // InternalRos.g:15965:2: ( ruleNamespace ) - // InternalRos.g:15966:3: ruleNamespace + // InternalRosParser.g:13048:2: ( ruleNamespace ) + // InternalRosParser.g:13049:3: ruleNamespace { before(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); pushFollow(FOLLOW_2); @@ -47424,21 +38525,21 @@ public final void rule__ActionClient__NamespaceAssignment_6_1() throws Recogniti // $ANTLR start "rule__PackageDependency__PackageAssignment" - // InternalRos.g:15975:1: rule__PackageDependency__PackageAssignment : ( ( ruleEString ) ) ; + // InternalRosParser.g:13058:1: rule__PackageDependency__PackageAssignment : ( ( ruleEString ) ) ; public final void rule__PackageDependency__PackageAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15979:1: ( ( ( ruleEString ) ) ) - // InternalRos.g:15980:2: ( ( ruleEString ) ) + // InternalRosParser.g:13062:1: ( ( ( ruleEString ) ) ) + // InternalRosParser.g:13063:2: ( ( ruleEString ) ) { - // InternalRos.g:15980:2: ( ( ruleEString ) ) - // InternalRos.g:15981:3: ( ruleEString ) + // InternalRosParser.g:13063:2: ( ( ruleEString ) ) + // InternalRosParser.g:13064:3: ( ruleEString ) { before(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); - // InternalRos.g:15982:3: ( ruleEString ) - // InternalRos.g:15983:4: ruleEString + // InternalRosParser.g:13065:3: ( ruleEString ) + // InternalRosParser.g:13066:4: ruleEString { before(grammarAccess.getPackageDependencyAccess().getPackagePackageEStringParserRuleCall_0_1()); pushFollow(FOLLOW_2); @@ -47473,17 +38574,17 @@ public final void rule__PackageDependency__PackageAssignment() throws Recognitio // $ANTLR start "rule__ExternalDependency__NameAssignment_2" - // InternalRos.g:15994:1: rule__ExternalDependency__NameAssignment_2 : ( ruleEString ) ; + // InternalRosParser.g:13077:1: rule__ExternalDependency__NameAssignment_2 : ( ruleEString ) ; public final void rule__ExternalDependency__NameAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:15998:1: ( ( ruleEString ) ) - // InternalRos.g:15999:2: ( ruleEString ) + // InternalRosParser.g:13081:1: ( ( ruleEString ) ) + // InternalRosParser.g:13082:2: ( ruleEString ) { - // InternalRos.g:15999:2: ( ruleEString ) - // InternalRos.g:16000:3: ruleEString + // InternalRosParser.g:13082:2: ( ruleEString ) + // InternalRosParser.g:13083:3: ruleEString { before(grammarAccess.getExternalDependencyAccess().getNameEStringParserRuleCall_2_0()); pushFollow(FOLLOW_2); @@ -47513,26 +38614,26 @@ public final void rule__ExternalDependency__NameAssignment_2() throws Recognitio // $ANTLR end "rule__ExternalDependency__NameAssignment_2" - // $ANTLR start "rule__GlobalNamespace__PartsAssignment_3_2" - // InternalRos.g:16009:1: rule__GlobalNamespace__PartsAssignment_3_2 : ( ruleGraphName ) ; - public final void rule__GlobalNamespace__PartsAssignment_3_2() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__PartsAssignment_2_1" + // InternalRosParser.g:13092:1: rule__GlobalNamespace__PartsAssignment_2_1 : ( ruleGraphName ) ; + public final void rule__GlobalNamespace__PartsAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16013:1: ( ( ruleGraphName ) ) - // InternalRos.g:16014:2: ( ruleGraphName ) + // InternalRosParser.g:13096:1: ( ( ruleGraphName ) ) + // InternalRosParser.g:13097:2: ( ruleGraphName ) { - // InternalRos.g:16014:2: ( ruleGraphName ) - // InternalRos.g:16015:3: ruleGraphName + // InternalRosParser.g:13097:2: ( ruleGraphName ) + // InternalRosParser.g:13098:3: ruleGraphName { - before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); + before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); pushFollow(FOLLOW_2); ruleGraphName(); state._fsp--; - after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); + after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } @@ -47551,29 +38652,29 @@ public final void rule__GlobalNamespace__PartsAssignment_3_2() throws Recognitio } return ; } - // $ANTLR end "rule__GlobalNamespace__PartsAssignment_3_2" + // $ANTLR end "rule__GlobalNamespace__PartsAssignment_2_1" - // $ANTLR start "rule__GlobalNamespace__PartsAssignment_3_3_1" - // InternalRos.g:16024:1: rule__GlobalNamespace__PartsAssignment_3_3_1 : ( ruleGraphName ) ; - public final void rule__GlobalNamespace__PartsAssignment_3_3_1() throws RecognitionException { + // $ANTLR start "rule__GlobalNamespace__PartsAssignment_2_2_1" + // InternalRosParser.g:13107:1: rule__GlobalNamespace__PartsAssignment_2_2_1 : ( ruleGraphName ) ; + public final void rule__GlobalNamespace__PartsAssignment_2_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16028:1: ( ( ruleGraphName ) ) - // InternalRos.g:16029:2: ( ruleGraphName ) + // InternalRosParser.g:13111:1: ( ( ruleGraphName ) ) + // InternalRosParser.g:13112:2: ( ruleGraphName ) { - // InternalRos.g:16029:2: ( ruleGraphName ) - // InternalRos.g:16030:3: ruleGraphName + // InternalRosParser.g:13112:2: ( ruleGraphName ) + // InternalRosParser.g:13113:3: ruleGraphName { - before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); pushFollow(FOLLOW_2); ruleGraphName(); state._fsp--; - after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } @@ -47592,29 +38693,29 @@ public final void rule__GlobalNamespace__PartsAssignment_3_3_1() throws Recognit } return ; } - // $ANTLR end "rule__GlobalNamespace__PartsAssignment_3_3_1" + // $ANTLR end "rule__GlobalNamespace__PartsAssignment_2_2_1" - // $ANTLR start "rule__RelativeNamespace_Impl__PartsAssignment_3_2" - // InternalRos.g:16039:1: rule__RelativeNamespace_Impl__PartsAssignment_3_2 : ( ruleGraphName ) ; - public final void rule__RelativeNamespace_Impl__PartsAssignment_3_2() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__PartsAssignment_2_1" + // InternalRosParser.g:13122:1: rule__RelativeNamespace_Impl__PartsAssignment_2_1 : ( ruleGraphName ) ; + public final void rule__RelativeNamespace_Impl__PartsAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16043:1: ( ( ruleGraphName ) ) - // InternalRos.g:16044:2: ( ruleGraphName ) + // InternalRosParser.g:13126:1: ( ( ruleGraphName ) ) + // InternalRosParser.g:13127:2: ( ruleGraphName ) { - // InternalRos.g:16044:2: ( ruleGraphName ) - // InternalRos.g:16045:3: ruleGraphName + // InternalRosParser.g:13127:2: ( ruleGraphName ) + // InternalRosParser.g:13128:3: ruleGraphName { - before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_2_0()); + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); pushFollow(FOLLOW_2); ruleGraphName(); state._fsp--; - after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_2_0()); + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); } @@ -47633,29 +38734,29 @@ public final void rule__RelativeNamespace_Impl__PartsAssignment_3_2() throws Rec } return ; } - // $ANTLR end "rule__RelativeNamespace_Impl__PartsAssignment_3_2" + // $ANTLR end "rule__RelativeNamespace_Impl__PartsAssignment_2_1" - // $ANTLR start "rule__RelativeNamespace_Impl__PartsAssignment_3_3_1" - // InternalRos.g:16054:1: rule__RelativeNamespace_Impl__PartsAssignment_3_3_1 : ( ruleGraphName ) ; - public final void rule__RelativeNamespace_Impl__PartsAssignment_3_3_1() throws RecognitionException { + // $ANTLR start "rule__RelativeNamespace_Impl__PartsAssignment_2_2_1" + // InternalRosParser.g:13137:1: rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 : ( ruleGraphName ) ; + public final void rule__RelativeNamespace_Impl__PartsAssignment_2_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16058:1: ( ( ruleGraphName ) ) - // InternalRos.g:16059:2: ( ruleGraphName ) + // InternalRosParser.g:13141:1: ( ( ruleGraphName ) ) + // InternalRosParser.g:13142:2: ( ruleGraphName ) { - // InternalRos.g:16059:2: ( ruleGraphName ) - // InternalRos.g:16060:3: ruleGraphName + // InternalRosParser.g:13142:2: ( ruleGraphName ) + // InternalRosParser.g:13143:3: ruleGraphName { - before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); pushFollow(FOLLOW_2); ruleGraphName(); state._fsp--; - after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } @@ -47674,29 +38775,29 @@ public final void rule__RelativeNamespace_Impl__PartsAssignment_3_3_1() throws R } return ; } - // $ANTLR end "rule__RelativeNamespace_Impl__PartsAssignment_3_3_1" + // $ANTLR end "rule__RelativeNamespace_Impl__PartsAssignment_2_2_1" - // $ANTLR start "rule__PrivateNamespace__PartsAssignment_3_2" - // InternalRos.g:16069:1: rule__PrivateNamespace__PartsAssignment_3_2 : ( ruleGraphName ) ; - public final void rule__PrivateNamespace__PartsAssignment_3_2() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__PartsAssignment_2_1" + // InternalRosParser.g:13152:1: rule__PrivateNamespace__PartsAssignment_2_1 : ( ruleGraphName ) ; + public final void rule__PrivateNamespace__PartsAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16073:1: ( ( ruleGraphName ) ) - // InternalRos.g:16074:2: ( ruleGraphName ) + // InternalRosParser.g:13156:1: ( ( ruleGraphName ) ) + // InternalRosParser.g:13157:2: ( ruleGraphName ) { - // InternalRos.g:16074:2: ( ruleGraphName ) - // InternalRos.g:16075:3: ruleGraphName + // InternalRosParser.g:13157:2: ( ruleGraphName ) + // InternalRosParser.g:13158:3: ruleGraphName { - before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); + before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); pushFollow(FOLLOW_2); ruleGraphName(); state._fsp--; - after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); + after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } @@ -47715,29 +38816,29 @@ public final void rule__PrivateNamespace__PartsAssignment_3_2() throws Recogniti } return ; } - // $ANTLR end "rule__PrivateNamespace__PartsAssignment_3_2" + // $ANTLR end "rule__PrivateNamespace__PartsAssignment_2_1" - // $ANTLR start "rule__PrivateNamespace__PartsAssignment_3_3_1" - // InternalRos.g:16084:1: rule__PrivateNamespace__PartsAssignment_3_3_1 : ( ruleGraphName ) ; - public final void rule__PrivateNamespace__PartsAssignment_3_3_1() throws RecognitionException { + // $ANTLR start "rule__PrivateNamespace__PartsAssignment_2_2_1" + // InternalRosParser.g:13167:1: rule__PrivateNamespace__PartsAssignment_2_2_1 : ( ruleGraphName ) ; + public final void rule__PrivateNamespace__PartsAssignment_2_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16088:1: ( ( ruleGraphName ) ) - // InternalRos.g:16089:2: ( ruleGraphName ) + // InternalRosParser.g:13171:1: ( ( ruleGraphName ) ) + // InternalRosParser.g:13172:2: ( ruleGraphName ) { - // InternalRos.g:16089:2: ( ruleGraphName ) - // InternalRos.g:16090:3: ruleGraphName + // InternalRosParser.g:13172:2: ( ruleGraphName ) + // InternalRosParser.g:13173:3: ruleGraphName { - before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); pushFollow(FOLLOW_2); ruleGraphName(); state._fsp--; - after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } @@ -47756,29 +38857,29 @@ public final void rule__PrivateNamespace__PartsAssignment_3_3_1() throws Recogni } return ; } - // $ANTLR end "rule__PrivateNamespace__PartsAssignment_3_3_1" + // $ANTLR end "rule__PrivateNamespace__PartsAssignment_2_2_1" - // $ANTLR start "rule__Parameter__NameAssignment_3" - // InternalRos.g:16099:1: rule__Parameter__NameAssignment_3 : ( ruleEString ) ; - public final void rule__Parameter__NameAssignment_3() throws RecognitionException { + // $ANTLR start "rule__Parameter__NameAssignment_1" + // InternalRosParser.g:13182:1: rule__Parameter__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Parameter__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16103:1: ( ( ruleEString ) ) - // InternalRos.g:16104:2: ( ruleEString ) + // InternalRosParser.g:13186:1: ( ( ruleEString ) ) + // InternalRosParser.g:13187:2: ( ruleEString ) { - // InternalRos.g:16104:2: ( ruleEString ) - // InternalRos.g:16105:3: ruleEString + // InternalRosParser.g:13187:2: ( ruleEString ) + // InternalRosParser.g:13188:3: ruleEString { - before(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_3_0()); + before(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_3_0()); + after(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); } @@ -47797,29 +38898,29 @@ public final void rule__Parameter__NameAssignment_3() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Parameter__NameAssignment_3" + // $ANTLR end "rule__Parameter__NameAssignment_1" - // $ANTLR start "rule__Parameter__NamespaceAssignment_4_1" - // InternalRos.g:16114:1: rule__Parameter__NamespaceAssignment_4_1 : ( ruleNamespace ) ; - public final void rule__Parameter__NamespaceAssignment_4_1() throws RecognitionException { + // $ANTLR start "rule__Parameter__TypeAssignment_5" + // InternalRosParser.g:13197:1: rule__Parameter__TypeAssignment_5 : ( ruleParameterType ) ; + public final void rule__Parameter__TypeAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16118:1: ( ( ruleNamespace ) ) - // InternalRos.g:16119:2: ( ruleNamespace ) + // InternalRosParser.g:13201:1: ( ( ruleParameterType ) ) + // InternalRosParser.g:13202:2: ( ruleParameterType ) { - // InternalRos.g:16119:2: ( ruleNamespace ) - // InternalRos.g:16120:3: ruleNamespace + // InternalRosParser.g:13202:2: ( ruleParameterType ) + // InternalRosParser.g:13203:3: ruleParameterType { - before(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_4_1_0()); + before(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); pushFollow(FOLLOW_2); - ruleNamespace(); + ruleParameterType(); state._fsp--; - after(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_4_1_0()); + after(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); } @@ -47838,29 +38939,29 @@ public final void rule__Parameter__NamespaceAssignment_4_1() throws RecognitionE } return ; } - // $ANTLR end "rule__Parameter__NamespaceAssignment_4_1" + // $ANTLR end "rule__Parameter__TypeAssignment_5" - // $ANTLR start "rule__Parameter__TypeAssignment_6" - // InternalRos.g:16129:1: rule__Parameter__TypeAssignment_6 : ( ruleParameterType ) ; - public final void rule__Parameter__TypeAssignment_6() throws RecognitionException { + // $ANTLR start "rule__Parameter__NamespaceAssignment_6_1" + // InternalRosParser.g:13212:1: rule__Parameter__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__Parameter__NamespaceAssignment_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16133:1: ( ( ruleParameterType ) ) - // InternalRos.g:16134:2: ( ruleParameterType ) + // InternalRosParser.g:13216:1: ( ( ruleNamespace ) ) + // InternalRosParser.g:13217:2: ( ruleNamespace ) { - // InternalRos.g:16134:2: ( ruleParameterType ) - // InternalRos.g:16135:3: ruleParameterType + // InternalRosParser.g:13217:2: ( ruleNamespace ) + // InternalRosParser.g:13218:3: ruleNamespace { - before(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_6_0()); + before(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); pushFollow(FOLLOW_2); - ruleParameterType(); + ruleNamespace(); state._fsp--; - after(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_6_0()); + after(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } @@ -47879,21 +38980,21 @@ public final void rule__Parameter__TypeAssignment_6() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Parameter__TypeAssignment_6" + // $ANTLR end "rule__Parameter__NamespaceAssignment_6_1" // $ANTLR start "rule__ParameterListType__SequenceAssignment_3" - // InternalRos.g:16144:1: rule__ParameterListType__SequenceAssignment_3 : ( ruleParameterType ) ; + // InternalRosParser.g:13227:1: rule__ParameterListType__SequenceAssignment_3 : ( ruleParameterType ) ; public final void rule__ParameterListType__SequenceAssignment_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16148:1: ( ( ruleParameterType ) ) - // InternalRos.g:16149:2: ( ruleParameterType ) + // InternalRosParser.g:13231:1: ( ( ruleParameterType ) ) + // InternalRosParser.g:13232:2: ( ruleParameterType ) { - // InternalRos.g:16149:2: ( ruleParameterType ) - // InternalRos.g:16150:3: ruleParameterType + // InternalRosParser.g:13232:2: ( ruleParameterType ) + // InternalRosParser.g:13233:3: ruleParameterType { before(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); pushFollow(FOLLOW_2); @@ -47924,17 +39025,17 @@ public final void rule__ParameterListType__SequenceAssignment_3() throws Recogni // $ANTLR start "rule__ParameterListType__SequenceAssignment_4_1" - // InternalRos.g:16159:1: rule__ParameterListType__SequenceAssignment_4_1 : ( ruleParameterType ) ; + // InternalRosParser.g:13242:1: rule__ParameterListType__SequenceAssignment_4_1 : ( ruleParameterType ) ; public final void rule__ParameterListType__SequenceAssignment_4_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16163:1: ( ( ruleParameterType ) ) - // InternalRos.g:16164:2: ( ruleParameterType ) + // InternalRosParser.g:13246:1: ( ( ruleParameterType ) ) + // InternalRosParser.g:13247:2: ( ruleParameterType ) { - // InternalRos.g:16164:2: ( ruleParameterType ) - // InternalRos.g:16165:3: ruleParameterType + // InternalRosParser.g:13247:2: ( ruleParameterType ) + // InternalRosParser.g:13248:3: ruleParameterType { before(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); pushFollow(FOLLOW_2); @@ -47965,17 +39066,17 @@ public final void rule__ParameterListType__SequenceAssignment_4_1() throws Recog // $ANTLR start "rule__ParameterStructType__ParameterstructypetmemberAssignment_3" - // InternalRos.g:16174:1: rule__ParameterStructType__ParameterstructypetmemberAssignment_3 : ( ruleParameterStructTypeMember ) ; + // InternalRosParser.g:13257:1: rule__ParameterStructType__ParameterstructypetmemberAssignment_3 : ( ruleParameterStructTypeMember ) ; public final void rule__ParameterStructType__ParameterstructypetmemberAssignment_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16178:1: ( ( ruleParameterStructTypeMember ) ) - // InternalRos.g:16179:2: ( ruleParameterStructTypeMember ) + // InternalRosParser.g:13261:1: ( ( ruleParameterStructTypeMember ) ) + // InternalRosParser.g:13262:2: ( ruleParameterStructTypeMember ) { - // InternalRos.g:16179:2: ( ruleParameterStructTypeMember ) - // InternalRos.g:16180:3: ruleParameterStructTypeMember + // InternalRosParser.g:13262:2: ( ruleParameterStructTypeMember ) + // InternalRosParser.g:13263:3: ruleParameterStructTypeMember { before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); pushFollow(FOLLOW_2); @@ -48006,17 +39107,17 @@ public final void rule__ParameterStructType__ParameterstructypetmemberAssignment // $ANTLR start "rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1" - // InternalRos.g:16189:1: rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 : ( ruleParameterStructTypeMember ) ; + // InternalRosParser.g:13272:1: rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 : ( ruleParameterStructTypeMember ) ; public final void rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16193:1: ( ( ruleParameterStructTypeMember ) ) - // InternalRos.g:16194:2: ( ruleParameterStructTypeMember ) + // InternalRosParser.g:13276:1: ( ( ruleParameterStructTypeMember ) ) + // InternalRosParser.g:13277:2: ( ruleParameterStructTypeMember ) { - // InternalRos.g:16194:2: ( ruleParameterStructTypeMember ) - // InternalRos.g:16195:3: ruleParameterStructTypeMember + // InternalRosParser.g:13277:2: ( ruleParameterStructTypeMember ) + // InternalRosParser.g:13278:3: ruleParameterStructTypeMember { before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); pushFollow(FOLLOW_2); @@ -48047,17 +39148,17 @@ public final void rule__ParameterStructType__ParameterstructypetmemberAssignment // $ANTLR start "rule__ParameterIntegerType__DefaultAssignment_2_1" - // InternalRos.g:16204:1: rule__ParameterIntegerType__DefaultAssignment_2_1 : ( ruleParameterInteger ) ; + // InternalRosParser.g:13287:1: rule__ParameterIntegerType__DefaultAssignment_2_1 : ( ruleParameterInteger ) ; public final void rule__ParameterIntegerType__DefaultAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16208:1: ( ( ruleParameterInteger ) ) - // InternalRos.g:16209:2: ( ruleParameterInteger ) + // InternalRosParser.g:13291:1: ( ( ruleParameterInteger ) ) + // InternalRosParser.g:13292:2: ( ruleParameterInteger ) { - // InternalRos.g:16209:2: ( ruleParameterInteger ) - // InternalRos.g:16210:3: ruleParameterInteger + // InternalRosParser.g:13292:2: ( ruleParameterInteger ) + // InternalRosParser.g:13293:3: ruleParameterInteger { before(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); pushFollow(FOLLOW_2); @@ -48088,17 +39189,17 @@ public final void rule__ParameterIntegerType__DefaultAssignment_2_1() throws Rec // $ANTLR start "rule__ParameterStringType__DefaultAssignment_2_1" - // InternalRos.g:16219:1: rule__ParameterStringType__DefaultAssignment_2_1 : ( ruleParameterString ) ; + // InternalRosParser.g:13302:1: rule__ParameterStringType__DefaultAssignment_2_1 : ( ruleParameterString ) ; public final void rule__ParameterStringType__DefaultAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16223:1: ( ( ruleParameterString ) ) - // InternalRos.g:16224:2: ( ruleParameterString ) + // InternalRosParser.g:13306:1: ( ( ruleParameterString ) ) + // InternalRosParser.g:13307:2: ( ruleParameterString ) { - // InternalRos.g:16224:2: ( ruleParameterString ) - // InternalRos.g:16225:3: ruleParameterString + // InternalRosParser.g:13307:2: ( ruleParameterString ) + // InternalRosParser.g:13308:3: ruleParameterString { before(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); pushFollow(FOLLOW_2); @@ -48129,17 +39230,17 @@ public final void rule__ParameterStringType__DefaultAssignment_2_1() throws Reco // $ANTLR start "rule__ParameterDoubleType__DefaultAssignment_2_1" - // InternalRos.g:16234:1: rule__ParameterDoubleType__DefaultAssignment_2_1 : ( ruleParameterDouble ) ; + // InternalRosParser.g:13317:1: rule__ParameterDoubleType__DefaultAssignment_2_1 : ( ruleParameterDouble ) ; public final void rule__ParameterDoubleType__DefaultAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16238:1: ( ( ruleParameterDouble ) ) - // InternalRos.g:16239:2: ( ruleParameterDouble ) + // InternalRosParser.g:13321:1: ( ( ruleParameterDouble ) ) + // InternalRosParser.g:13322:2: ( ruleParameterDouble ) { - // InternalRos.g:16239:2: ( ruleParameterDouble ) - // InternalRos.g:16240:3: ruleParameterDouble + // InternalRosParser.g:13322:2: ( ruleParameterDouble ) + // InternalRosParser.g:13323:3: ruleParameterDouble { before(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); pushFollow(FOLLOW_2); @@ -48170,17 +39271,17 @@ public final void rule__ParameterDoubleType__DefaultAssignment_2_1() throws Reco // $ANTLR start "rule__ParameterBooleanType__DefaultAssignment_2_1" - // InternalRos.g:16249:1: rule__ParameterBooleanType__DefaultAssignment_2_1 : ( ruleParameterBoolean ) ; + // InternalRosParser.g:13332:1: rule__ParameterBooleanType__DefaultAssignment_2_1 : ( ruleParameterBoolean ) ; public final void rule__ParameterBooleanType__DefaultAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16253:1: ( ( ruleParameterBoolean ) ) - // InternalRos.g:16254:2: ( ruleParameterBoolean ) + // InternalRosParser.g:13336:1: ( ( ruleParameterBoolean ) ) + // InternalRosParser.g:13337:2: ( ruleParameterBoolean ) { - // InternalRos.g:16254:2: ( ruleParameterBoolean ) - // InternalRos.g:16255:3: ruleParameterBoolean + // InternalRosParser.g:13337:2: ( ruleParameterBoolean ) + // InternalRosParser.g:13338:3: ruleParameterBoolean { before(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); pushFollow(FOLLOW_2); @@ -48211,17 +39312,17 @@ public final void rule__ParameterBooleanType__DefaultAssignment_2_1() throws Rec // $ANTLR start "rule__ParameterBase64Type__DefaultAssignment_2_1" - // InternalRos.g:16264:1: rule__ParameterBase64Type__DefaultAssignment_2_1 : ( ruleParameterBase64 ) ; + // InternalRosParser.g:13347:1: rule__ParameterBase64Type__DefaultAssignment_2_1 : ( ruleParameterBase64 ) ; public final void rule__ParameterBase64Type__DefaultAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16268:1: ( ( ruleParameterBase64 ) ) - // InternalRos.g:16269:2: ( ruleParameterBase64 ) + // InternalRosParser.g:13351:1: ( ( ruleParameterBase64 ) ) + // InternalRosParser.g:13352:2: ( ruleParameterBase64 ) { - // InternalRos.g:16269:2: ( ruleParameterBase64 ) - // InternalRos.g:16270:3: ruleParameterBase64 + // InternalRosParser.g:13352:2: ( ruleParameterBase64 ) + // InternalRosParser.g:13353:3: ruleParameterBase64 { before(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); pushFollow(FOLLOW_2); @@ -48252,17 +39353,17 @@ public final void rule__ParameterBase64Type__DefaultAssignment_2_1() throws Reco // $ANTLR start "rule__ParameterArrayType__TypeAssignment_3" - // InternalRos.g:16279:1: rule__ParameterArrayType__TypeAssignment_3 : ( ruleParameterType ) ; + // InternalRosParser.g:13362:1: rule__ParameterArrayType__TypeAssignment_3 : ( ruleParameterType ) ; public final void rule__ParameterArrayType__TypeAssignment_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16283:1: ( ( ruleParameterType ) ) - // InternalRos.g:16284:2: ( ruleParameterType ) + // InternalRosParser.g:13366:1: ( ( ruleParameterType ) ) + // InternalRosParser.g:13367:2: ( ruleParameterType ) { - // InternalRos.g:16284:2: ( ruleParameterType ) - // InternalRos.g:16285:3: ruleParameterType + // InternalRosParser.g:13367:2: ( ruleParameterType ) + // InternalRosParser.g:13368:3: ruleParameterType { before(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); pushFollow(FOLLOW_2); @@ -48293,17 +39394,17 @@ public final void rule__ParameterArrayType__TypeAssignment_3() throws Recognitio // $ANTLR start "rule__ParameterArrayType__DefaultAssignment_4_1" - // InternalRos.g:16294:1: rule__ParameterArrayType__DefaultAssignment_4_1 : ( ruleParameterList ) ; + // InternalRosParser.g:13377:1: rule__ParameterArrayType__DefaultAssignment_4_1 : ( ruleParameterList ) ; public final void rule__ParameterArrayType__DefaultAssignment_4_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16298:1: ( ( ruleParameterList ) ) - // InternalRos.g:16299:2: ( ruleParameterList ) + // InternalRosParser.g:13381:1: ( ( ruleParameterList ) ) + // InternalRosParser.g:13382:2: ( ruleParameterList ) { - // InternalRos.g:16299:2: ( ruleParameterList ) - // InternalRos.g:16300:3: ruleParameterList + // InternalRosParser.g:13382:2: ( ruleParameterList ) + // InternalRosParser.g:13383:3: ruleParameterList { before(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); pushFollow(FOLLOW_2); @@ -48334,17 +39435,17 @@ public final void rule__ParameterArrayType__DefaultAssignment_4_1() throws Recog // $ANTLR start "rule__ParameterList__ValueAssignment_2" - // InternalRos.g:16309:1: rule__ParameterList__ValueAssignment_2 : ( ruleParameterValue ) ; + // InternalRosParser.g:13392:1: rule__ParameterList__ValueAssignment_2 : ( ruleParameterValue ) ; public final void rule__ParameterList__ValueAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16313:1: ( ( ruleParameterValue ) ) - // InternalRos.g:16314:2: ( ruleParameterValue ) + // InternalRosParser.g:13396:1: ( ( ruleParameterValue ) ) + // InternalRosParser.g:13397:2: ( ruleParameterValue ) { - // InternalRos.g:16314:2: ( ruleParameterValue ) - // InternalRos.g:16315:3: ruleParameterValue + // InternalRosParser.g:13397:2: ( ruleParameterValue ) + // InternalRosParser.g:13398:3: ruleParameterValue { before(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); pushFollow(FOLLOW_2); @@ -48375,17 +39476,17 @@ public final void rule__ParameterList__ValueAssignment_2() throws RecognitionExc // $ANTLR start "rule__ParameterList__ValueAssignment_3_1" - // InternalRos.g:16324:1: rule__ParameterList__ValueAssignment_3_1 : ( ruleParameterValue ) ; + // InternalRosParser.g:13407:1: rule__ParameterList__ValueAssignment_3_1 : ( ruleParameterValue ) ; public final void rule__ParameterList__ValueAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16328:1: ( ( ruleParameterValue ) ) - // InternalRos.g:16329:2: ( ruleParameterValue ) + // InternalRosParser.g:13411:1: ( ( ruleParameterValue ) ) + // InternalRosParser.g:13412:2: ( ruleParameterValue ) { - // InternalRos.g:16329:2: ( ruleParameterValue ) - // InternalRos.g:16330:3: ruleParameterValue + // InternalRosParser.g:13412:2: ( ruleParameterValue ) + // InternalRosParser.g:13413:3: ruleParameterValue { before(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); pushFollow(FOLLOW_2); @@ -48415,26 +39516,26 @@ public final void rule__ParameterList__ValueAssignment_3_1() throws RecognitionE // $ANTLR end "rule__ParameterList__ValueAssignment_3_1" - // $ANTLR start "rule__ParameterAny__ValueAssignment_3_1" - // InternalRos.g:16339:1: rule__ParameterAny__ValueAssignment_3_1 : ( ruleEString ) ; - public final void rule__ParameterAny__ValueAssignment_3_1() throws RecognitionException { + // $ANTLR start "rule__ParameterAny__ValueAssignment_2_1" + // InternalRosParser.g:13422:1: rule__ParameterAny__ValueAssignment_2_1 : ( ruleEString ) ; + public final void rule__ParameterAny__ValueAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16343:1: ( ( ruleEString ) ) - // InternalRos.g:16344:2: ( ruleEString ) + // InternalRosParser.g:13426:1: ( ( ruleEString ) ) + // InternalRosParser.g:13427:2: ( ruleEString ) { - // InternalRos.g:16344:2: ( ruleEString ) - // InternalRos.g:16345:3: ruleEString + // InternalRosParser.g:13427:2: ( ruleEString ) + // InternalRosParser.g:13428:3: ruleEString { - before(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_3_1_0()); + before(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); pushFollow(FOLLOW_2); ruleEString(); state._fsp--; - after(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_3_1_0()); + after(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); } @@ -48453,21 +39554,21 @@ public final void rule__ParameterAny__ValueAssignment_3_1() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParameterAny__ValueAssignment_3_1" + // $ANTLR end "rule__ParameterAny__ValueAssignment_2_1" // $ANTLR start "rule__ParameterString__ValueAssignment" - // InternalRos.g:16354:1: rule__ParameterString__ValueAssignment : ( ruleEString ) ; + // InternalRosParser.g:13437:1: rule__ParameterString__ValueAssignment : ( ruleEString ) ; public final void rule__ParameterString__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16358:1: ( ( ruleEString ) ) - // InternalRos.g:16359:2: ( ruleEString ) + // InternalRosParser.g:13441:1: ( ( ruleEString ) ) + // InternalRosParser.g:13442:2: ( ruleEString ) { - // InternalRos.g:16359:2: ( ruleEString ) - // InternalRos.g:16360:3: ruleEString + // InternalRosParser.g:13442:2: ( ruleEString ) + // InternalRosParser.g:13443:3: ruleEString { before(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); pushFollow(FOLLOW_2); @@ -48498,17 +39599,17 @@ public final void rule__ParameterString__ValueAssignment() throws RecognitionExc // $ANTLR start "rule__ParameterBase64__ValueAssignment" - // InternalRos.g:16369:1: rule__ParameterBase64__ValueAssignment : ( ruleBase64Binary ) ; + // InternalRosParser.g:13452:1: rule__ParameterBase64__ValueAssignment : ( ruleBase64Binary ) ; public final void rule__ParameterBase64__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16373:1: ( ( ruleBase64Binary ) ) - // InternalRos.g:16374:2: ( ruleBase64Binary ) + // InternalRosParser.g:13456:1: ( ( ruleBase64Binary ) ) + // InternalRosParser.g:13457:2: ( ruleBase64Binary ) { - // InternalRos.g:16374:2: ( ruleBase64Binary ) - // InternalRos.g:16375:3: ruleBase64Binary + // InternalRosParser.g:13457:2: ( ruleBase64Binary ) + // InternalRosParser.g:13458:3: ruleBase64Binary { before(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); pushFollow(FOLLOW_2); @@ -48539,17 +39640,17 @@ public final void rule__ParameterBase64__ValueAssignment() throws RecognitionExc // $ANTLR start "rule__ParameterInteger__ValueAssignment" - // InternalRos.g:16384:1: rule__ParameterInteger__ValueAssignment : ( ruleInteger0 ) ; + // InternalRosParser.g:13467:1: rule__ParameterInteger__ValueAssignment : ( ruleInteger0 ) ; public final void rule__ParameterInteger__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16388:1: ( ( ruleInteger0 ) ) - // InternalRos.g:16389:2: ( ruleInteger0 ) + // InternalRosParser.g:13471:1: ( ( ruleInteger0 ) ) + // InternalRosParser.g:13472:2: ( ruleInteger0 ) { - // InternalRos.g:16389:2: ( ruleInteger0 ) - // InternalRos.g:16390:3: ruleInteger0 + // InternalRosParser.g:13472:2: ( ruleInteger0 ) + // InternalRosParser.g:13473:3: ruleInteger0 { before(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); pushFollow(FOLLOW_2); @@ -48580,17 +39681,17 @@ public final void rule__ParameterInteger__ValueAssignment() throws RecognitionEx // $ANTLR start "rule__ParameterDouble__ValueAssignment" - // InternalRos.g:16399:1: rule__ParameterDouble__ValueAssignment : ( ruleDouble0 ) ; + // InternalRosParser.g:13482:1: rule__ParameterDouble__ValueAssignment : ( ruleDouble0 ) ; public final void rule__ParameterDouble__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16403:1: ( ( ruleDouble0 ) ) - // InternalRos.g:16404:2: ( ruleDouble0 ) + // InternalRosParser.g:13486:1: ( ( ruleDouble0 ) ) + // InternalRosParser.g:13487:2: ( ruleDouble0 ) { - // InternalRos.g:16404:2: ( ruleDouble0 ) - // InternalRos.g:16405:3: ruleDouble0 + // InternalRosParser.g:13487:2: ( ruleDouble0 ) + // InternalRosParser.g:13488:3: ruleDouble0 { before(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); pushFollow(FOLLOW_2); @@ -48621,17 +39722,17 @@ public final void rule__ParameterDouble__ValueAssignment() throws RecognitionExc // $ANTLR start "rule__ParameterBoolean__ValueAssignment" - // InternalRos.g:16414:1: rule__ParameterBoolean__ValueAssignment : ( ruleboolean0 ) ; + // InternalRosParser.g:13497:1: rule__ParameterBoolean__ValueAssignment : ( ruleboolean0 ) ; public final void rule__ParameterBoolean__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16418:1: ( ( ruleboolean0 ) ) - // InternalRos.g:16419:2: ( ruleboolean0 ) + // InternalRosParser.g:13501:1: ( ( ruleboolean0 ) ) + // InternalRosParser.g:13502:2: ( ruleboolean0 ) { - // InternalRos.g:16419:2: ( ruleboolean0 ) - // InternalRos.g:16420:3: ruleboolean0 + // InternalRosParser.g:13502:2: ( ruleboolean0 ) + // InternalRosParser.g:13503:3: ruleboolean0 { before(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); pushFollow(FOLLOW_2); @@ -48662,17 +39763,17 @@ public final void rule__ParameterBoolean__ValueAssignment() throws RecognitionEx // $ANTLR start "rule__ParameterStruct__ValueAssignment_1_1" - // InternalRos.g:16429:1: rule__ParameterStruct__ValueAssignment_1_1 : ( ruleParameterStructMember ) ; + // InternalRosParser.g:13512:1: rule__ParameterStruct__ValueAssignment_1_1 : ( ruleParameterStructMember ) ; public final void rule__ParameterStruct__ValueAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16433:1: ( ( ruleParameterStructMember ) ) - // InternalRos.g:16434:2: ( ruleParameterStructMember ) + // InternalRosParser.g:13516:1: ( ( ruleParameterStructMember ) ) + // InternalRosParser.g:13517:2: ( ruleParameterStructMember ) { - // InternalRos.g:16434:2: ( ruleParameterStructMember ) - // InternalRos.g:16435:3: ruleParameterStructMember + // InternalRosParser.g:13517:2: ( ruleParameterStructMember ) + // InternalRosParser.g:13518:3: ruleParameterStructMember { before(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); pushFollow(FOLLOW_2); @@ -48703,17 +39804,17 @@ public final void rule__ParameterStruct__ValueAssignment_1_1() throws Recognitio // $ANTLR start "rule__ParameterStruct__ValueAssignment_1_2_2" - // InternalRos.g:16444:1: rule__ParameterStruct__ValueAssignment_1_2_2 : ( ruleParameterStructMember ) ; + // InternalRosParser.g:13527:1: rule__ParameterStruct__ValueAssignment_1_2_2 : ( ruleParameterStructMember ) ; public final void rule__ParameterStruct__ValueAssignment_1_2_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16448:1: ( ( ruleParameterStructMember ) ) - // InternalRos.g:16449:2: ( ruleParameterStructMember ) + // InternalRosParser.g:13531:1: ( ( ruleParameterStructMember ) ) + // InternalRosParser.g:13532:2: ( ruleParameterStructMember ) { - // InternalRos.g:16449:2: ( ruleParameterStructMember ) - // InternalRos.g:16450:3: ruleParameterStructMember + // InternalRosParser.g:13532:2: ( ruleParameterStructMember ) + // InternalRosParser.g:13533:3: ruleParameterStructMember { before(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); pushFollow(FOLLOW_2); @@ -48744,17 +39845,17 @@ public final void rule__ParameterStruct__ValueAssignment_1_2_2() throws Recognit // $ANTLR start "rule__ParameterDate__ValueAssignment" - // InternalRos.g:16459:1: rule__ParameterDate__ValueAssignment : ( ruleDateTime0 ) ; + // InternalRosParser.g:13542:1: rule__ParameterDate__ValueAssignment : ( ruleDateTime0 ) ; public final void rule__ParameterDate__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16463:1: ( ( ruleDateTime0 ) ) - // InternalRos.g:16464:2: ( ruleDateTime0 ) + // InternalRosParser.g:13546:1: ( ( ruleDateTime0 ) ) + // InternalRosParser.g:13547:2: ( ruleDateTime0 ) { - // InternalRos.g:16464:2: ( ruleDateTime0 ) - // InternalRos.g:16465:3: ruleDateTime0 + // InternalRosParser.g:13547:2: ( ruleDateTime0 ) + // InternalRosParser.g:13548:3: ruleDateTime0 { before(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); pushFollow(FOLLOW_2); @@ -48785,17 +39886,17 @@ public final void rule__ParameterDate__ValueAssignment() throws RecognitionExcep // $ANTLR start "rule__ParameterStructMember__NameAssignment_1" - // InternalRos.g:16474:1: rule__ParameterStructMember__NameAssignment_1 : ( ruleEString ) ; + // InternalRosParser.g:13557:1: rule__ParameterStructMember__NameAssignment_1 : ( ruleEString ) ; public final void rule__ParameterStructMember__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16478:1: ( ( ruleEString ) ) - // InternalRos.g:16479:2: ( ruleEString ) + // InternalRosParser.g:13561:1: ( ( ruleEString ) ) + // InternalRosParser.g:13562:2: ( ruleEString ) { - // InternalRos.g:16479:2: ( ruleEString ) - // InternalRos.g:16480:3: ruleEString + // InternalRosParser.g:13562:2: ( ruleEString ) + // InternalRosParser.g:13563:3: ruleEString { before(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); pushFollow(FOLLOW_2); @@ -48826,17 +39927,17 @@ public final void rule__ParameterStructMember__NameAssignment_1() throws Recogni // $ANTLR start "rule__ParameterStructMember__ValueAssignment_4" - // InternalRos.g:16489:1: rule__ParameterStructMember__ValueAssignment_4 : ( ruleParameterValue ) ; + // InternalRosParser.g:13572:1: rule__ParameterStructMember__ValueAssignment_4 : ( ruleParameterValue ) ; public final void rule__ParameterStructMember__ValueAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16493:1: ( ( ruleParameterValue ) ) - // InternalRos.g:16494:2: ( ruleParameterValue ) + // InternalRosParser.g:13576:1: ( ( ruleParameterValue ) ) + // InternalRosParser.g:13577:2: ( ruleParameterValue ) { - // InternalRos.g:16494:2: ( ruleParameterValue ) - // InternalRos.g:16495:3: ruleParameterValue + // InternalRosParser.g:13577:2: ( ruleParameterValue ) + // InternalRosParser.g:13578:3: ruleParameterValue { before(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); pushFollow(FOLLOW_2); @@ -48867,17 +39968,17 @@ public final void rule__ParameterStructMember__ValueAssignment_4() throws Recogn // $ANTLR start "rule__ParameterStructTypeMember__NameAssignment_0" - // InternalRos.g:16504:1: rule__ParameterStructTypeMember__NameAssignment_0 : ( ruleEString ) ; + // InternalRosParser.g:13587:1: rule__ParameterStructTypeMember__NameAssignment_0 : ( ruleEString ) ; public final void rule__ParameterStructTypeMember__NameAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16508:1: ( ( ruleEString ) ) - // InternalRos.g:16509:2: ( ruleEString ) + // InternalRosParser.g:13591:1: ( ( ruleEString ) ) + // InternalRosParser.g:13592:2: ( ruleEString ) { - // InternalRos.g:16509:2: ( ruleEString ) - // InternalRos.g:16510:3: ruleEString + // InternalRosParser.g:13592:2: ( ruleEString ) + // InternalRosParser.g:13593:3: ruleEString { before(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); pushFollow(FOLLOW_2); @@ -48908,17 +40009,17 @@ public final void rule__ParameterStructTypeMember__NameAssignment_0() throws Rec // $ANTLR start "rule__ParameterStructTypeMember__TypeAssignment_1" - // InternalRos.g:16519:1: rule__ParameterStructTypeMember__TypeAssignment_1 : ( ruleParameterType ) ; + // InternalRosParser.g:13602:1: rule__ParameterStructTypeMember__TypeAssignment_1 : ( ruleParameterType ) ; public final void rule__ParameterStructTypeMember__TypeAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16523:1: ( ( ruleParameterType ) ) - // InternalRos.g:16524:2: ( ruleParameterType ) + // InternalRosParser.g:13606:1: ( ( ruleParameterType ) ) + // InternalRosParser.g:13607:2: ( ruleParameterType ) { - // InternalRos.g:16524:2: ( ruleParameterType ) - // InternalRos.g:16525:3: ruleParameterType + // InternalRosParser.g:13607:2: ( ruleParameterType ) + // InternalRosParser.g:13608:3: ruleParameterType { before(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); pushFollow(FOLLOW_2); @@ -48949,17 +40050,17 @@ public final void rule__ParameterStructTypeMember__TypeAssignment_1() throws Rec // $ANTLR start "rule__MessagePart__TypeAssignment_0" - // InternalRos.g:16534:1: rule__MessagePart__TypeAssignment_0 : ( ruleAbstractType ) ; + // InternalRosParser.g:13617:1: rule__MessagePart__TypeAssignment_0 : ( ruleAbstractType ) ; public final void rule__MessagePart__TypeAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16538:1: ( ( ruleAbstractType ) ) - // InternalRos.g:16539:2: ( ruleAbstractType ) + // InternalRosParser.g:13621:1: ( ( ruleAbstractType ) ) + // InternalRosParser.g:13622:2: ( ruleAbstractType ) { - // InternalRos.g:16539:2: ( ruleAbstractType ) - // InternalRos.g:16540:3: ruleAbstractType + // InternalRosParser.g:13622:2: ( ruleAbstractType ) + // InternalRosParser.g:13623:3: ruleAbstractType { before(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); pushFollow(FOLLOW_2); @@ -48990,21 +40091,21 @@ public final void rule__MessagePart__TypeAssignment_0() throws RecognitionExcept // $ANTLR start "rule__MessagePart__DataAssignment_1" - // InternalRos.g:16549:1: rule__MessagePart__DataAssignment_1 : ( ( rule__MessagePart__DataAlternatives_1_0 ) ) ; + // InternalRosParser.g:13632:1: rule__MessagePart__DataAssignment_1 : ( ( rule__MessagePart__DataAlternatives_1_0 ) ) ; public final void rule__MessagePart__DataAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16553:1: ( ( ( rule__MessagePart__DataAlternatives_1_0 ) ) ) - // InternalRos.g:16554:2: ( ( rule__MessagePart__DataAlternatives_1_0 ) ) + // InternalRosParser.g:13636:1: ( ( ( rule__MessagePart__DataAlternatives_1_0 ) ) ) + // InternalRosParser.g:13637:2: ( ( rule__MessagePart__DataAlternatives_1_0 ) ) { - // InternalRos.g:16554:2: ( ( rule__MessagePart__DataAlternatives_1_0 ) ) - // InternalRos.g:16555:3: ( rule__MessagePart__DataAlternatives_1_0 ) + // InternalRosParser.g:13637:2: ( ( rule__MessagePart__DataAlternatives_1_0 ) ) + // InternalRosParser.g:13638:3: ( rule__MessagePart__DataAlternatives_1_0 ) { before(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0()); - // InternalRos.g:16556:3: ( rule__MessagePart__DataAlternatives_1_0 ) - // InternalRos.g:16556:4: rule__MessagePart__DataAlternatives_1_0 + // InternalRosParser.g:13639:3: ( rule__MessagePart__DataAlternatives_1_0 ) + // InternalRosParser.g:13639:4: rule__MessagePart__DataAlternatives_1_0 { pushFollow(FOLLOW_2); rule__MessagePart__DataAlternatives_1_0(); @@ -49037,21 +40138,21 @@ public final void rule__MessagePart__DataAssignment_1() throws RecognitionExcept // $ANTLR start "rule__TopicSpecRef__TopicSpecAssignment" - // InternalRos.g:16564:1: rule__TopicSpecRef__TopicSpecAssignment : ( ( ruleEString ) ) ; + // InternalRosParser.g:13647:1: rule__TopicSpecRef__TopicSpecAssignment : ( ( ruleEString ) ) ; public final void rule__TopicSpecRef__TopicSpecAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16568:1: ( ( ( ruleEString ) ) ) - // InternalRos.g:16569:2: ( ( ruleEString ) ) + // InternalRosParser.g:13651:1: ( ( ( ruleEString ) ) ) + // InternalRosParser.g:13652:2: ( ( ruleEString ) ) { - // InternalRos.g:16569:2: ( ( ruleEString ) ) - // InternalRos.g:16570:3: ( ruleEString ) + // InternalRosParser.g:13652:2: ( ( ruleEString ) ) + // InternalRosParser.g:13653:3: ( ruleEString ) { before(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); - // InternalRos.g:16571:3: ( ruleEString ) - // InternalRos.g:16572:4: ruleEString + // InternalRosParser.g:13654:3: ( ruleEString ) + // InternalRosParser.g:13655:4: ruleEString { before(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_1()); pushFollow(FOLLOW_2); @@ -49086,21 +40187,21 @@ public final void rule__TopicSpecRef__TopicSpecAssignment() throws RecognitionEx // $ANTLR start "rule__ArrayTopicSpecRef__TopicSpecAssignment_0" - // InternalRos.g:16583:1: rule__ArrayTopicSpecRef__TopicSpecAssignment_0 : ( ( ruleEString ) ) ; + // InternalRosParser.g:13666:1: rule__ArrayTopicSpecRef__TopicSpecAssignment_0 : ( ( ruleEString ) ) ; public final void rule__ArrayTopicSpecRef__TopicSpecAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalRos.g:16587:1: ( ( ( ruleEString ) ) ) - // InternalRos.g:16588:2: ( ( ruleEString ) ) + // InternalRosParser.g:13670:1: ( ( ( ruleEString ) ) ) + // InternalRosParser.g:13671:2: ( ( ruleEString ) ) { - // InternalRos.g:16588:2: ( ( ruleEString ) ) - // InternalRos.g:16589:3: ( ruleEString ) + // InternalRosParser.g:13671:2: ( ( ruleEString ) ) + // InternalRosParser.g:13672:3: ( ruleEString ) { before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); - // InternalRos.g:16590:3: ( ruleEString ) - // InternalRos.g:16591:4: ruleEString + // InternalRosParser.g:13673:3: ( ruleEString ) + // InternalRosParser.g:13674:4: ruleEString { before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_0_1()); pushFollow(FOLLOW_2); @@ -49138,13 +40239,13 @@ public final void rule__ArrayTopicSpecRef__TopicSpecAssignment_0() throws Recogn protected DFA11 dfa11 = new DFA11(this); static final String dfa_1s = "\42\uffff"; - static final String dfa_2s = "\36\uffff\2\41\2\uffff"; - static final String dfa_3s = "\1\11\35\uffff\2\11\2\uffff"; - static final String dfa_4s = "\1\160\35\uffff\2\161\2\uffff"; - static final String dfa_5s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\2\uffff\1\37\1\36"; + static final String dfa_2s = "\36\uffff\2\40\2\uffff"; + static final String dfa_3s = "\1\27\35\uffff\2\32\2\uffff"; + static final String dfa_4s = "\1\140\35\uffff\2\156\2\uffff"; + static final String dfa_5s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\2\uffff\1\36\1\37"; static final String dfa_6s = "\42\uffff}>"; static final String[] dfa_7s = { - "\1\36\1\37\20\uffff\1\20\12\uffff\1\17\1\16\57\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35", + "\1\32\1\33\1\uffff\1\17\3\uffff\1\34\1\25\1\27\1\31\4\uffff\1\12\1\13\1\24\1\26\1\30\3\uffff\1\23\3\uffff\1\20\3\uffff\1\21\1\35\1\22\2\uffff\1\14\1\5\1\7\1\11\1\uffff\1\4\1\6\1\10\2\uffff\1\3\3\uffff\1\1\1\15\1\uffff\1\2\4\uffff\1\16\14\uffff\1\37\1\uffff\1\36", "", "", "", @@ -49174,8 +40275,8 @@ public final void rule__ArrayTopicSpecRef__TopicSpecAssignment_0() throws Recogn "", "", "", - "\2\41\1\uffff\1\41\20\uffff\13\41\111\uffff\1\40", - "\2\41\1\uffff\1\41\20\uffff\13\41\111\uffff\1\40", + "\2\40\17\uffff\1\40\1\uffff\1\40\7\uffff\1\40\3\uffff\1\40\14\uffff\1\40\4\uffff\1\40\2\uffff\1\40\2\uffff\2\40\2\uffff\1\41\10\uffff\1\40\1\uffff\1\40\15\uffff\1\40", + "\2\40\17\uffff\1\40\1\uffff\1\40\7\uffff\1\40\3\uffff\1\40\14\uffff\1\40\4\uffff\1\40\2\uffff\1\40\2\uffff\2\40\2\uffff\1\41\10\uffff\1\40\1\uffff\1\40\15\uffff\1\40", "", "" }; @@ -49202,109 +40303,101 @@ public DFA11(BaseRecognizer recognizer) { this.transition = dfa_7; } public String getDescription() { - return "2589:1: rule__AbstractType__Alternatives : ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) );"; + return "2627:1: rule__AbstractType__Alternatives : ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) );"; } } 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[]{0x0000010000000000L}); - public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000020000000000L}); - public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0005140000000000L}); - public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000080000000000L}); - public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000080000000002L}); - public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0005100000000000L}); - public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000100000000000L}); - public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000600L}); - public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000E40000000000L}); - public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x00C8000000000000L}); - public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x00000C0000000000L}); - public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000800000000000L}); - public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000004000C00L}); - public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0100040000000000L}); - public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0001000000000000L}); - public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0002E40000000000L}); - public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000000600L,0x0000000000000080L}); - public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0008000000000000L}); - public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0030040000000000L}); - public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0040000000000000L}); - public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000018000600L}); - public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000040040000000L}); - public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x00000401A0000000L}); - public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x000004C008000600L,0x0001FFFFFF800000L}); - public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x000000C008000600L,0x0001FFFFFF800000L}); - public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x000000C008000602L,0x0001FFFFFF800000L}); - public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000200000000L}); - public static final BitSet FOLLOW_30 = new BitSet(new long[]{0xFE00040000000000L}); - public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); - public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); - public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); + public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000000L,0x00000000C0008000L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000002L,0x00000000C0008000L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0400000000012000L,0x0000000010000000L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000000L,0x0000000140000000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000001000000000L,0x0000000010012000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000001000000002L,0x0000000000012000L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000020L,0x0000000140000000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000000L,0x0000000002400000L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000008L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x00000000000E1E00L,0x0000000010000000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x00000000000E1E02L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000000000L,0x0000000150000000L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000000002L,0x0000000140000000L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x000C000000000000L,0x0000000140000000L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000010000000L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000000000L,0x0000000018000000L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x79C447C3C5800000L,0x0000000140021627L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000020000000L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000002000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000001000000000L,0x0000000000012000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x8000000000000000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000100000000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000400000L,0x0000000008000000L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x79C447C3C5800002L,0x0000000140021627L}); public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); - public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L}); - public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); - public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); - public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000800000000L}); - public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000040000000000L,0x0000000000000002L}); - public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000D00L}); - public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000040000000L}); - public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000002000000000L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x00000000000001C0L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000100L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000200000L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000040L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x001B800C00000000L,0x0000000000000100L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); - public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000040000000000L,0x0000000000000200L}); - public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000002000000L}); - public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); - public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000001000000000L,0x0000000000000002L}); - public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000010000000L,0x00000000001EE000L}); - public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000040000000000L}); - public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); - public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); - public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); - public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); - public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000080L}); - public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000010000000L}); - public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); - public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000000040L}); - public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); - public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000020L}); - public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); - public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000001000000000L}); - public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000040000000000L,0x0000000000010000L}); - public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x00000200000006F0L}); - public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); - public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000040400000000L}); - public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); - public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000000400000000L}); - public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x000000FFE0001600L}); - public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L}); - public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); - public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L}); - public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); - public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L}); - public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); - public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L}); - public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L}); - public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L}); - public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L}); - public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L}); - public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L}); - public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L}); - public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000008000000000L}); - public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000004000000000L}); - public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); - public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000000L}); - public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000000000000L,0x0000004000000000L}); - public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000000000L,0x0000008000000000L}); - public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000000000000L,0x0000010000000000L}); - public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L}); - public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L}); - public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0000000000000000L,0x0000080000000000L}); - public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000000000000000L,0x0000100000000000L}); - public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L}); - public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L}); - public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0000000000000000L,0x0000800000000000L}); - public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0000000000000000L,0x0001000000000000L}); - public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0000000008000000L}); - public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000000000000000L,0x0002000000000000L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0010000000000000L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000800000000L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000002000000000L}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000000L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0008000000000000L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0002000000000000L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000000L,0x0000004000000000L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000400000000L}); + public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); + public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0001000000000000L}); + public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L}); + public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000002000000000L,0x0000000010000000L}); + public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000000000L,0x0000007941000000L}); + public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000008000L}); + public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L}); + public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x022028000C000000L,0x0000400140064840L}); + public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); + public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); + public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L}); + public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x1000000000000000L}); + public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); + public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x2000000000000000L}); + public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); + public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x4000000000000000L}); + public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000004000000000L}); + public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000008000000000L}); + public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0800000000000000L}); + public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); + public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); + public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000000004000000L}); + public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0040000000000000L}); + public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0100000000000000L}); + public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000400000000000L}); + public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000010000000000L}); + public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000000080000000L}); + public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000020000000000L}); + public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000100000000L}); + public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000040000000000L}); + public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000200000000L}); + public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000000000800000L}); + public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000001000000L}); + public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000040000000L}); + public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0080000000000000L}); + public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0004000000000000L}); + public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); } \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosParser.tokens b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosParser.tokens new file mode 100644 index 000000000..7a07c1570 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRosParser.tokens @@ -0,0 +1,110 @@ +','=86 +':'=87 +'AmentPackage'=14 +'Any'=83 +'Array:'=47 +'Base64'=48 +'Boolean'=34 +'Date'=71 +'Double'=49 +'ExternalDependency'=5 +'GlobalNamespace'=8 +'GraphName'=21 +'Header'=50 +'Integer'=35 +'List'=72 +'ParameterAny'=15 +'ParameterStructMember'=4 +'PrivateNamespace'=7 +'RelativeNamespace'=6 +'String'=51 +'Struct'=52 +'['=88 +'[]'=85 +']'=89 +'action'=53 +'action:'=36 +'actionclient:'=11 +'actionserver:'=12 +'artifacts:'=20 +'bool'=73 +'bool[]'=54 +'byte'=74 +'byte[]'=55 +'default'=37 +'dependencies:'=13 +'duration'=26 +'feedback'=27 +'feedback:'=22 +'float32'=38 +'float32[]'=23 +'float64'=39 +'float64[]'=24 +'fromGitRepo:'=16 +'goal'=75 +'goal:'=63 +'int16'=64 +'int16[]'=40 +'int32'=65 +'int32[]'=41 +'int64'=66 +'int64[]'=42 +'int8'=76 +'int8[]'=56 +'message'=43 +'message:'=28 +'msg:'=77 +'name'=78 +'node'=79 +'node:'=67 +'ns:'=84 +'parameters:'=18 +'publishers:'=19 +'request:'=29 +'response:'=25 +'result'=57 +'result:'=44 +'service'=45 +'serviceclient:'=9 +'serviceserver:'=10 +'specs:'=58 +'srv:'=80 +'string'=59 +'string[]'=30 +'subscribers:'=17 +'time'=81 +'type'=82 +'type:'=68 +'uint16'=60 +'uint16[]'=31 +'uint32'=61 +'uint32[]'=32 +'uint64'=62 +'uint64[]'=33 +'uint8'=69 +'uint8[]'=46 +'value'=70 +'}'=90 +RULE_ANY_OTHER=113 +RULE_BEGIN=91 +RULE_BINARY=99 +RULE_BOOLEAN=100 +RULE_DATE_TIME=108 +RULE_DAY=103 +RULE_DECINT=101 +RULE_DIGIT=98 +RULE_DOUBLE=102 +RULE_END=92 +RULE_HOUR=106 +RULE_ID=94 +RULE_INT=109 +RULE_MESSAGE_ASIGMENT=110 +RULE_MIN_SEC=107 +RULE_ML_COMMENT=111 +RULE_MONTH=104 +RULE_ROS_CONVENTION_A=95 +RULE_ROS_CONVENTION_PARAM=97 +RULE_SL_COMMENT=93 +RULE_STRING=96 +RULE_WS=112 +RULE_YEAR=105 diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/lexer/InternalRosLexer.g b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/lexer/InternalRosLexer.g new file mode 100644 index 000000000..3f955b9c0 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/lexer/InternalRosLexer.g @@ -0,0 +1,232 @@ +/* + * generated by Xtext 2.25.0 + */ +lexer grammar InternalRosLexer; + +@header { +package de.fraunhofer.ipa.ros.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; +} + +ParameterStructMember : 'ParameterStructMember'; + +ExternalDependency : 'ExternalDependency'; + +RelativeNamespace : 'RelativeNamespace'; + +PrivateNamespace : 'PrivateNamespace'; + +GlobalNamespace : 'GlobalNamespace'; + +Serviceclient : 'serviceclient:'; + +Serviceserver : 'serviceserver:'; + +Actionclient : 'actionclient:'; + +Actionserver : 'actionserver:'; + +Dependencies : 'dependencies:'; + +AmentPackage : 'AmentPackage'; + +ParameterAny : 'ParameterAny'; + +FromGitRepo : 'fromGitRepo:'; + +Subscribers : 'subscribers:'; + +Parameters : 'parameters:'; + +Publishers : 'publishers:'; + +Artifacts : 'artifacts:'; + +GraphName : 'GraphName'; + +Feedback_1 : 'feedback:'; + +Float32_1 : 'float32[]'; + +Float64_1 : 'float64[]'; + +Response : 'response:'; + +Duration : 'duration'; + +Feedback : 'feedback'; + +Message_1 : 'message:'; + +Request : 'request:'; + +String_2 : 'string[]'; + +Uint16_1 : 'uint16[]'; + +Uint32_1 : 'uint32[]'; + +Uint64_1 : 'uint64[]'; + +Boolean : 'Boolean'; + +Integer : 'Integer'; + +Action_1 : 'action:'; + +Default : 'default'; + +Float32 : 'float32'; + +Float64 : 'float64'; + +Int16_1 : 'int16[]'; + +Int32_1 : 'int32[]'; + +Int64_1 : 'int64[]'; + +Message : 'message'; + +Result_1 : 'result:'; + +Service : 'service'; + +Uint8_1 : 'uint8[]'; + +Array : 'Array:'; + +Base64 : 'Base64'; + +Double : 'Double'; + +Header : 'Header'; + +String : 'String'; + +Struct : 'Struct'; + +Action : 'action'; + +Bool_1 : 'bool[]'; + +Byte_1 : 'byte[]'; + +Int8_1 : 'int8[]'; + +Result : 'result'; + +Specs : 'specs:'; + +String_1 : 'string'; + +Uint16 : 'uint16'; + +Uint32 : 'uint32'; + +Uint64 : 'uint64'; + +Goal_1 : 'goal:'; + +Int16 : 'int16'; + +Int32 : 'int32'; + +Int64 : 'int64'; + +Node_1 : 'node:'; + +Type_1 : 'type:'; + +Uint8 : 'uint8'; + +Value : 'value'; + +Date : 'Date'; + +List : 'List'; + +Bool : 'bool'; + +Byte : 'byte'; + +Goal : 'goal'; + +Int8 : 'int8'; + +Msg : 'msg:'; + +Name : 'name'; + +Node : 'node'; + +Srv : 'srv:'; + +Time : 'time'; + +Type : 'type'; + +Any : 'Any'; + +Ns : 'ns:'; + +LeftSquareBracketRightSquareBracket : '[]'; + +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)*; + +fragment RULE_DIGIT : '0'..'9'; + +RULE_BINARY : ('0b'|'0B') ('0'|'1')+; + +RULE_BOOLEAN : ('true'|'false'); + +RULE_DOUBLE : RULE_DIGIT ('.' RULE_DECINT*|('.' RULE_DIGIT*)? ('E'|'e') ('-'|'+')? RULE_DIGIT); + +RULE_DECINT : ('0'|'1'..'9' RULE_DIGIT*|'-' '0'..'9' RULE_DIGIT*); + +fragment RULE_DAY : ('1'..'9'|'1'..'3' '0'..'9'); + +fragment RULE_MONTH : ('1'..'9'|'1' '0'..'2'); + +fragment RULE_YEAR : '0'..'2' '0'..'9' '0'..'9' '0'..'9'; + +fragment RULE_HOUR : ('0'..'1' '0'..'9'|'2' '0'..'3'); + +fragment RULE_MIN_SEC : '0'..'5' '0'..'9'; + +RULE_DATE_TIME : RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC; + +RULE_MESSAGE_ASIGMENT : (RULE_ID|RULE_STRING) '=' (RULE_ID|RULE_STRING|RULE_INT|'-' RULE_INT); + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + +fragment 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.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/lexer/InternalRosLexer.java b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/lexer/InternalRosLexer.java new file mode 100644 index 000000000..71893ee05 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/lexer/InternalRosLexer.java @@ -0,0 +1,4967 @@ +package de.fraunhofer.ipa.ros.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 InternalRosLexer extends Lexer { + public static final int Float32_1=23; + public static final int Node=79; + public static final int RULE_DATE_TIME=108; + public static final int Uint64_1=33; + public static final int String=51; + public static final int Int16=64; + public static final int Float32=38; + public static final int Goal=75; + public static final int Bool=73; + public static final int Uint16=60; + public static final int Boolean=34; + public static final int ExternalDependency=5; + public static final int Uint8=69; + public static final int Parameters=18; + public static final int RULE_ID=94; + public static final int AmentPackage=14; + public static final int Actionclient=11; + public static final int RULE_DIGIT=98; + public static final int GlobalNamespace=8; + public static final int Artifacts=20; + public static final int Node_1=67; + public static final int Int16_1=40; + public static final int Header=50; + public static final int RULE_INT=109; + public static final int Byte=74; + public static final int RULE_ML_COMMENT=111; + public static final int LeftSquareBracket=88; + public static final int Specs=58; + public static final int Base64=48; + public static final int Message_1=28; + public static final int Comma=86; + public static final int RULE_MESSAGE_ASIGMENT=110; + public static final int Goal_1=63; + public static final int LeftSquareBracketRightSquareBracket=85; + public static final int Int32=65; + public static final int Publishers=19; + public static final int Serviceserver=10; + public static final int RightCurlyBracket=90; + public static final int RULE_DECINT=101; + public static final int Uint32=61; + public static final int FromGitRepo=16; + public static final int Msg=77; + public static final int RULE_HOUR=106; + public static final int Int8=76; + public static final int Default=37; + public static final int Actionserver=12; + public static final int Int8_1=56; + public static final int Uint16_1=31; + public static final int Type=82; + public static final int Float64=39; + public static final int Int32_1=41; + public static final int Result_1=44; + public static final int RULE_BINARY=99; + public static final int String_1=59; + public static final int Subscribers=17; + public static final int String_2=30; + public static final int RULE_BEGIN=91; + public static final int RULE_DAY=103; + public static final int RULE_BOOLEAN=100; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=105; + public static final int Feedback_1=22; + public static final int Result=57; + public static final int Name=78; + public static final int RULE_MIN_SEC=107; + public static final int ParameterAny=15; + public static final int List=72; + public static final int Dependencies=13; + public static final int RightSquareBracket=89; + public static final int PrivateNamespace=7; + public static final int GraphName=21; + public static final int Byte_1=55; + public static final int Float64_1=24; + public static final int Duration=26; + public static final int Uint32_1=32; + public static final int Action_1=36; + public static final int Double=49; + public static final int Type_1=68; + public static final int Value=70; + public static final int Uint64=62; + public static final int Action=53; + public static final int RULE_END=92; + public static final int Message=43; + public static final int Time=81; + public static final int RULE_STRING=96; + public static final int Bool_1=54; + public static final int Any=83; + public static final int Struct=52; + public static final int RULE_SL_COMMENT=93; + public static final int Uint8_1=46; + public static final int RULE_DOUBLE=102; + public static final int Feedback=27; + public static final int ParameterStructMember=4; + public static final int Srv=80; + public static final int RULE_ROS_CONVENTION_A=95; + public static final int RULE_ROS_CONVENTION_PARAM=97; + public static final int Colon=87; + public static final int EOF=-1; + public static final int Ns=84; + public static final int RULE_WS=112; + public static final int Request=29; + public static final int Int64_1=42; + public static final int Service=45; + public static final int RULE_ANY_OTHER=113; + public static final int Date=71; + public static final int Response=25; + public static final int Integer=35; + public static final int Array=47; + public static final int Serviceclient=9; + public static final int Int64=66; + public static final int RULE_MONTH=104; + + // delegates + // delegators + + public InternalRosLexer() {;} + public InternalRosLexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public InternalRosLexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "InternalRosLexer.g"; } + + // $ANTLR start "ParameterStructMember" + public final void mParameterStructMember() throws RecognitionException { + try { + int _type = ParameterStructMember; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:14:23: ( 'ParameterStructMember' ) + // InternalRosLexer.g:14:25: 'ParameterStructMember' + { + match("ParameterStructMember"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterStructMember" + + // $ANTLR start "ExternalDependency" + public final void mExternalDependency() throws RecognitionException { + try { + int _type = ExternalDependency; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:16:20: ( 'ExternalDependency' ) + // InternalRosLexer.g:16:22: 'ExternalDependency' + { + match("ExternalDependency"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ExternalDependency" + + // $ANTLR start "RelativeNamespace" + public final void mRelativeNamespace() throws RecognitionException { + try { + int _type = RelativeNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:18:19: ( 'RelativeNamespace' ) + // InternalRosLexer.g:18:21: 'RelativeNamespace' + { + match("RelativeNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RelativeNamespace" + + // $ANTLR start "PrivateNamespace" + public final void mPrivateNamespace() throws RecognitionException { + try { + int _type = PrivateNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:20:18: ( 'PrivateNamespace' ) + // InternalRosLexer.g:20:20: 'PrivateNamespace' + { + match("PrivateNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PrivateNamespace" + + // $ANTLR start "GlobalNamespace" + public final void mGlobalNamespace() throws RecognitionException { + try { + int _type = GlobalNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:22:17: ( 'GlobalNamespace' ) + // InternalRosLexer.g:22:19: 'GlobalNamespace' + { + match("GlobalNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GlobalNamespace" + + // $ANTLR start "Serviceclient" + public final void mServiceclient() throws RecognitionException { + try { + int _type = Serviceclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:24:15: ( 'serviceclient:' ) + // InternalRosLexer.g:24:17: 'serviceclient:' + { + match("serviceclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceclient" + + // $ANTLR start "Serviceserver" + public final void mServiceserver() throws RecognitionException { + try { + int _type = Serviceserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:26:15: ( 'serviceserver:' ) + // InternalRosLexer.g:26:17: 'serviceserver:' + { + match("serviceserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceserver" + + // $ANTLR start "Actionclient" + public final void mActionclient() throws RecognitionException { + try { + int _type = Actionclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:28:14: ( 'actionclient:' ) + // InternalRosLexer.g:28:16: 'actionclient:' + { + match("actionclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionclient" + + // $ANTLR start "Actionserver" + public final void mActionserver() throws RecognitionException { + try { + int _type = Actionserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:30:14: ( 'actionserver:' ) + // InternalRosLexer.g:30:16: 'actionserver:' + { + match("actionserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionserver" + + // $ANTLR start "Dependencies" + public final void mDependencies() throws RecognitionException { + try { + int _type = Dependencies; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:32:14: ( 'dependencies:' ) + // InternalRosLexer.g:32:16: 'dependencies:' + { + match("dependencies:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Dependencies" + + // $ANTLR start "AmentPackage" + public final void mAmentPackage() throws RecognitionException { + try { + int _type = AmentPackage; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:34:14: ( 'AmentPackage' ) + // InternalRosLexer.g:34:16: 'AmentPackage' + { + match("AmentPackage"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AmentPackage" + + // $ANTLR start "ParameterAny" + public final void mParameterAny() throws RecognitionException { + try { + int _type = ParameterAny; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:36:14: ( 'ParameterAny' ) + // InternalRosLexer.g:36:16: 'ParameterAny' + { + match("ParameterAny"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterAny" + + // $ANTLR start "FromGitRepo" + public final void mFromGitRepo() throws RecognitionException { + try { + int _type = FromGitRepo; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:38:13: ( 'fromGitRepo:' ) + // InternalRosLexer.g:38: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; + // InternalRosLexer.g:40:13: ( 'subscribers:' ) + // InternalRosLexer.g:40: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; + // InternalRosLexer.g:42:12: ( 'parameters:' ) + // InternalRosLexer.g:42: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; + // InternalRosLexer.g:44:12: ( 'publishers:' ) + // InternalRosLexer.g:44: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; + // InternalRosLexer.g:46:11: ( 'artifacts:' ) + // InternalRosLexer.g:46:13: 'artifacts:' + { + match("artifacts:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Artifacts" + + // $ANTLR start "GraphName" + public final void mGraphName() throws RecognitionException { + try { + int _type = GraphName; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:48:11: ( 'GraphName' ) + // InternalRosLexer.g:48:13: 'GraphName' + { + match("GraphName"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GraphName" + + // $ANTLR start "Feedback_1" + public final void mFeedback_1() throws RecognitionException { + try { + int _type = Feedback_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:50:12: ( 'feedback:' ) + // InternalRosLexer.g:50:14: 'feedback:' + { + match("feedback:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback_1" + + // $ANTLR start "Float32_1" + public final void mFloat32_1() throws RecognitionException { + try { + int _type = Float32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:52:11: ( 'float32[]' ) + // InternalRosLexer.g:52:13: 'float32[]' + { + match("float32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32_1" + + // $ANTLR start "Float64_1" + public final void mFloat64_1() throws RecognitionException { + try { + int _type = Float64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:54:11: ( 'float64[]' ) + // InternalRosLexer.g:54:13: 'float64[]' + { + match("float64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64_1" + + // $ANTLR start "Response" + public final void mResponse() throws RecognitionException { + try { + int _type = Response; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:56:10: ( 'response:' ) + // InternalRosLexer.g:56:12: 'response:' + { + match("response:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Response" + + // $ANTLR start "Duration" + public final void mDuration() throws RecognitionException { + try { + int _type = Duration; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:58:10: ( 'duration' ) + // InternalRosLexer.g:58:12: 'duration' + { + match("duration"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Duration" + + // $ANTLR start "Feedback" + public final void mFeedback() throws RecognitionException { + try { + int _type = Feedback; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:60:10: ( 'feedback' ) + // InternalRosLexer.g:60:12: 'feedback' + { + match("feedback"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback" + + // $ANTLR start "Message_1" + public final void mMessage_1() throws RecognitionException { + try { + int _type = Message_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:62:11: ( 'message:' ) + // InternalRosLexer.g:62:13: 'message:' + { + match("message:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message_1" + + // $ANTLR start "Request" + public final void mRequest() throws RecognitionException { + try { + int _type = Request; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:64:9: ( 'request:' ) + // InternalRosLexer.g:64:11: 'request:' + { + match("request:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Request" + + // $ANTLR start "String_2" + public final void mString_2() throws RecognitionException { + try { + int _type = String_2; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:66:10: ( 'string[]' ) + // InternalRosLexer.g:66:12: 'string[]' + { + match("string[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_2" + + // $ANTLR start "Uint16_1" + public final void mUint16_1() throws RecognitionException { + try { + int _type = Uint16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:68:10: ( 'uint16[]' ) + // InternalRosLexer.g:68:12: 'uint16[]' + { + match("uint16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16_1" + + // $ANTLR start "Uint32_1" + public final void mUint32_1() throws RecognitionException { + try { + int _type = Uint32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:70:10: ( 'uint32[]' ) + // InternalRosLexer.g:70:12: 'uint32[]' + { + match("uint32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32_1" + + // $ANTLR start "Uint64_1" + public final void mUint64_1() throws RecognitionException { + try { + int _type = Uint64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:72:10: ( 'uint64[]' ) + // InternalRosLexer.g:72:12: 'uint64[]' + { + match("uint64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64_1" + + // $ANTLR start "Boolean" + public final void mBoolean() throws RecognitionException { + try { + int _type = Boolean; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:74:9: ( 'Boolean' ) + // InternalRosLexer.g:74:11: 'Boolean' + { + match("Boolean"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Boolean" + + // $ANTLR start "Integer" + public final void mInteger() throws RecognitionException { + try { + int _type = Integer; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:76:9: ( 'Integer' ) + // InternalRosLexer.g:76:11: 'Integer' + { + match("Integer"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Integer" + + // $ANTLR start "Action_1" + public final void mAction_1() throws RecognitionException { + try { + int _type = Action_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:78:10: ( 'action:' ) + // InternalRosLexer.g:78:12: 'action:' + { + match("action:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action_1" + + // $ANTLR start "Default" + public final void mDefault() throws RecognitionException { + try { + int _type = Default; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:80:9: ( 'default' ) + // InternalRosLexer.g:80:11: 'default' + { + match("default"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Default" + + // $ANTLR start "Float32" + public final void mFloat32() throws RecognitionException { + try { + int _type = Float32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:82:9: ( 'float32' ) + // InternalRosLexer.g:82:11: 'float32' + { + match("float32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32" + + // $ANTLR start "Float64" + public final void mFloat64() throws RecognitionException { + try { + int _type = Float64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:84:9: ( 'float64' ) + // InternalRosLexer.g:84:11: 'float64' + { + match("float64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64" + + // $ANTLR start "Int16_1" + public final void mInt16_1() throws RecognitionException { + try { + int _type = Int16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:86:9: ( 'int16[]' ) + // InternalRosLexer.g:86:11: 'int16[]' + { + match("int16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16_1" + + // $ANTLR start "Int32_1" + public final void mInt32_1() throws RecognitionException { + try { + int _type = Int32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:88:9: ( 'int32[]' ) + // InternalRosLexer.g:88:11: 'int32[]' + { + match("int32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32_1" + + // $ANTLR start "Int64_1" + public final void mInt64_1() throws RecognitionException { + try { + int _type = Int64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:90:9: ( 'int64[]' ) + // InternalRosLexer.g:90:11: 'int64[]' + { + match("int64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64_1" + + // $ANTLR start "Message" + public final void mMessage() throws RecognitionException { + try { + int _type = Message; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:92:9: ( 'message' ) + // InternalRosLexer.g:92:11: 'message' + { + match("message"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message" + + // $ANTLR start "Result_1" + public final void mResult_1() throws RecognitionException { + try { + int _type = Result_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:94:10: ( 'result:' ) + // InternalRosLexer.g:94:12: 'result:' + { + match("result:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result_1" + + // $ANTLR start "Service" + public final void mService() throws RecognitionException { + try { + int _type = Service; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:96:9: ( 'service' ) + // InternalRosLexer.g:96:11: 'service' + { + match("service"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Service" + + // $ANTLR start "Uint8_1" + public final void mUint8_1() throws RecognitionException { + try { + int _type = Uint8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:98:9: ( 'uint8[]' ) + // InternalRosLexer.g:98:11: 'uint8[]' + { + match("uint8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8_1" + + // $ANTLR start "Array" + public final void mArray() throws RecognitionException { + try { + int _type = Array; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:100:7: ( 'Array:' ) + // InternalRosLexer.g:100:9: 'Array:' + { + match("Array:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Array" + + // $ANTLR start "Base64" + public final void mBase64() throws RecognitionException { + try { + int _type = Base64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:102:8: ( 'Base64' ) + // InternalRosLexer.g:102:10: 'Base64' + { + match("Base64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Base64" + + // $ANTLR start "Double" + public final void mDouble() throws RecognitionException { + try { + int _type = Double; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:104:8: ( 'Double' ) + // InternalRosLexer.g:104:10: 'Double' + { + match("Double"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Double" + + // $ANTLR start "Header" + public final void mHeader() throws RecognitionException { + try { + int _type = Header; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:106:8: ( 'Header' ) + // InternalRosLexer.g:106:10: 'Header' + { + match("Header"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Header" + + // $ANTLR start "String" + public final void mString() throws RecognitionException { + try { + int _type = String; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:108:8: ( 'String' ) + // InternalRosLexer.g:108:10: 'String' + { + match("String"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String" + + // $ANTLR start "Struct" + public final void mStruct() throws RecognitionException { + try { + int _type = Struct; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:110:8: ( 'Struct' ) + // InternalRosLexer.g:110:10: 'Struct' + { + match("Struct"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Struct" + + // $ANTLR start "Action" + public final void mAction() throws RecognitionException { + try { + int _type = Action; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:112:8: ( 'action' ) + // InternalRosLexer.g:112:10: 'action' + { + match("action"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action" + + // $ANTLR start "Bool_1" + public final void mBool_1() throws RecognitionException { + try { + int _type = Bool_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:114:8: ( 'bool[]' ) + // InternalRosLexer.g:114:10: 'bool[]' + { + match("bool[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool_1" + + // $ANTLR start "Byte_1" + public final void mByte_1() throws RecognitionException { + try { + int _type = Byte_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:116:8: ( 'byte[]' ) + // InternalRosLexer.g:116:10: 'byte[]' + { + match("byte[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte_1" + + // $ANTLR start "Int8_1" + public final void mInt8_1() throws RecognitionException { + try { + int _type = Int8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:118:8: ( 'int8[]' ) + // InternalRosLexer.g:118:10: 'int8[]' + { + match("int8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8_1" + + // $ANTLR start "Result" + public final void mResult() throws RecognitionException { + try { + int _type = Result; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:120:8: ( 'result' ) + // InternalRosLexer.g:120:10: 'result' + { + match("result"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result" + + // $ANTLR start "Specs" + public final void mSpecs() throws RecognitionException { + try { + int _type = Specs; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:122:7: ( 'specs:' ) + // InternalRosLexer.g:122:9: 'specs:' + { + match("specs:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Specs" + + // $ANTLR start "String_1" + public final void mString_1() throws RecognitionException { + try { + int _type = String_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:124:10: ( 'string' ) + // InternalRosLexer.g:124:12: 'string' + { + match("string"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_1" + + // $ANTLR start "Uint16" + public final void mUint16() throws RecognitionException { + try { + int _type = Uint16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:126:8: ( 'uint16' ) + // InternalRosLexer.g:126:10: 'uint16' + { + match("uint16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16" + + // $ANTLR start "Uint32" + public final void mUint32() throws RecognitionException { + try { + int _type = Uint32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:128:8: ( 'uint32' ) + // InternalRosLexer.g:128:10: 'uint32' + { + match("uint32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32" + + // $ANTLR start "Uint64" + public final void mUint64() throws RecognitionException { + try { + int _type = Uint64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:130:8: ( 'uint64' ) + // InternalRosLexer.g:130:10: 'uint64' + { + match("uint64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64" + + // $ANTLR start "Goal_1" + public final void mGoal_1() throws RecognitionException { + try { + int _type = Goal_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:132:8: ( 'goal:' ) + // InternalRosLexer.g:132:10: 'goal:' + { + match("goal:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal_1" + + // $ANTLR start "Int16" + public final void mInt16() throws RecognitionException { + try { + int _type = Int16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:134:7: ( 'int16' ) + // InternalRosLexer.g:134:9: 'int16' + { + match("int16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16" + + // $ANTLR start "Int32" + public final void mInt32() throws RecognitionException { + try { + int _type = Int32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:136:7: ( 'int32' ) + // InternalRosLexer.g:136:9: 'int32' + { + match("int32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32" + + // $ANTLR start "Int64" + public final void mInt64() throws RecognitionException { + try { + int _type = Int64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:138:7: ( 'int64' ) + // InternalRosLexer.g:138:9: 'int64' + { + match("int64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64" + + // $ANTLR start "Node_1" + public final void mNode_1() throws RecognitionException { + try { + int _type = Node_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:140:8: ( 'node:' ) + // InternalRosLexer.g:140:10: 'node:' + { + match("node:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node_1" + + // $ANTLR start "Type_1" + public final void mType_1() throws RecognitionException { + try { + int _type = Type_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:142:8: ( 'type:' ) + // InternalRosLexer.g:142:10: 'type:' + { + match("type:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type_1" + + // $ANTLR start "Uint8" + public final void mUint8() throws RecognitionException { + try { + int _type = Uint8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:144:7: ( 'uint8' ) + // InternalRosLexer.g:144:9: 'uint8' + { + match("uint8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8" + + // $ANTLR start "Value" + public final void mValue() throws RecognitionException { + try { + int _type = Value; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:146:7: ( 'value' ) + // InternalRosLexer.g:146:9: 'value' + { + match("value"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Value" + + // $ANTLR start "Date" + public final void mDate() throws RecognitionException { + try { + int _type = Date; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:148:6: ( 'Date' ) + // InternalRosLexer.g:148:8: 'Date' + { + match("Date"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Date" + + // $ANTLR start "List" + public final void mList() throws RecognitionException { + try { + int _type = List; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:150:6: ( 'List' ) + // InternalRosLexer.g:150:8: 'List' + { + match("List"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "List" + + // $ANTLR start "Bool" + public final void mBool() throws RecognitionException { + try { + int _type = Bool; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:152:6: ( 'bool' ) + // InternalRosLexer.g:152:8: 'bool' + { + match("bool"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool" + + // $ANTLR start "Byte" + public final void mByte() throws RecognitionException { + try { + int _type = Byte; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:154:6: ( 'byte' ) + // InternalRosLexer.g:154:8: 'byte' + { + match("byte"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte" + + // $ANTLR start "Goal" + public final void mGoal() throws RecognitionException { + try { + int _type = Goal; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:156:6: ( 'goal' ) + // InternalRosLexer.g:156:8: 'goal' + { + match("goal"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal" + + // $ANTLR start "Int8" + public final void mInt8() throws RecognitionException { + try { + int _type = Int8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:158:6: ( 'int8' ) + // InternalRosLexer.g:158:8: 'int8' + { + match("int8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8" + + // $ANTLR start "Msg" + public final void mMsg() throws RecognitionException { + try { + int _type = Msg; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:160:5: ( 'msg:' ) + // InternalRosLexer.g:160:7: 'msg:' + { + match("msg:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Msg" + + // $ANTLR start "Name" + public final void mName() throws RecognitionException { + try { + int _type = Name; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:162:6: ( 'name' ) + // InternalRosLexer.g:162:8: 'name' + { + match("name"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Name" + + // $ANTLR start "Node" + public final void mNode() throws RecognitionException { + try { + int _type = Node; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:164:6: ( 'node' ) + // InternalRosLexer.g:164:8: 'node' + { + match("node"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node" + + // $ANTLR start "Srv" + public final void mSrv() throws RecognitionException { + try { + int _type = Srv; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:166:5: ( 'srv:' ) + // InternalRosLexer.g:166:7: 'srv:' + { + match("srv:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Srv" + + // $ANTLR start "Time" + public final void mTime() throws RecognitionException { + try { + int _type = Time; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:168:6: ( 'time' ) + // InternalRosLexer.g:168:8: 'time' + { + match("time"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Time" + + // $ANTLR start "Type" + public final void mType() throws RecognitionException { + try { + int _type = Type; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:170:6: ( 'type' ) + // InternalRosLexer.g:170:8: 'type' + { + match("type"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type" + + // $ANTLR start "Any" + public final void mAny() throws RecognitionException { + try { + int _type = Any; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:172:5: ( 'Any' ) + // InternalRosLexer.g:172:7: 'Any' + { + match("Any"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Any" + + // $ANTLR start "Ns" + public final void mNs() throws RecognitionException { + try { + int _type = Ns; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:174:4: ( 'ns:' ) + // InternalRosLexer.g:174:6: 'ns:' + { + match("ns:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Ns" + + // $ANTLR start "LeftSquareBracketRightSquareBracket" + public final void mLeftSquareBracketRightSquareBracket() throws RecognitionException { + try { + int _type = LeftSquareBracketRightSquareBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:176:37: ( '[]' ) + // InternalRosLexer.g:176:39: '[]' + { + match("[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LeftSquareBracketRightSquareBracket" + + // $ANTLR start "Comma" + public final void mComma() throws RecognitionException { + try { + int _type = Comma; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:178:7: ( ',' ) + // InternalRosLexer.g:178: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; + // InternalRosLexer.g:180:7: ( ':' ) + // InternalRosLexer.g:180: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; + // InternalRosLexer.g:182:19: ( '[' ) + // InternalRosLexer.g:182: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; + // InternalRosLexer.g:184:20: ( ']' ) + // InternalRosLexer.g:184: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; + // InternalRosLexer.g:186:19: ( '}' ) + // InternalRosLexer.g:186:21: '}' + { + match('}'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RightCurlyBracket" + + // $ANTLR start "RULE_BEGIN" + public final void mRULE_BEGIN() throws RecognitionException { + try { + // InternalRosLexer.g:188:21: () + // InternalRosLexer.g:188:23: + { + } + + } + finally { + } + } + // $ANTLR end "RULE_BEGIN" + + // $ANTLR start "RULE_END" + public final void mRULE_END() throws RecognitionException { + try { + // InternalRosLexer.g:190:19: () + // InternalRosLexer.g:190: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; + // InternalRosLexer.g:192:17: ( '#' (~ ( ( '\\n' | '\\r' ) ) )* ) + // InternalRosLexer.g:192:19: '#' (~ ( ( '\\n' | '\\r' ) ) )* + { + match('#'); + // InternalRosLexer.g:192: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 : + // InternalRosLexer.g:192: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; + // InternalRosLexer.g:194:23: ( ( '/' RULE_ID | RULE_ID '/' )* ) + // InternalRosLexer.g:194:25: ( '/' RULE_ID | RULE_ID '/' )* + { + // InternalRosLexer.g:194: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 : + // InternalRosLexer.g:194:26: '/' RULE_ID + { + match('/'); + mRULE_ID(); + + } + break; + case 2 : + // InternalRosLexer.g:194: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; + // InternalRosLexer.g:196:27: ( ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* ) + // InternalRosLexer.g:196:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* + { + // InternalRosLexer.g:196: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 : + // InternalRosLexer.g:196:30: '/' RULE_STRING + { + match('/'); + mRULE_STRING(); + + } + break; + case 2 : + // InternalRosLexer.g:196:46: RULE_STRING '/' + { + mRULE_STRING(); + match('/'); + + } + break; + case 3 : + // InternalRosLexer.g:196: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_DIGIT" + public final void mRULE_DIGIT() throws RecognitionException { + try { + // InternalRosLexer.g:198:21: ( '0' .. '9' ) + // InternalRosLexer.g:198:23: '0' .. '9' + { + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_DIGIT" + + // $ANTLR start "RULE_BINARY" + public final void mRULE_BINARY() throws RecognitionException { + try { + int _type = RULE_BINARY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:200:13: ( ( '0b' | '0B' ) ( '0' | '1' )+ ) + // InternalRosLexer.g:200:15: ( '0b' | '0B' ) ( '0' | '1' )+ + { + // InternalRosLexer.g:200:15: ( '0b' | '0B' ) + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0=='0') ) { + int LA4_1 = input.LA(2); + + if ( (LA4_1=='b') ) { + alt4=1; + } + else if ( (LA4_1=='B') ) { + alt4=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + switch (alt4) { + case 1 : + // InternalRosLexer.g:200:16: '0b' + { + match("0b"); + + + } + break; + case 2 : + // InternalRosLexer.g:200:21: '0B' + { + match("0B"); + + + } + break; + + } + + // InternalRosLexer.g:200:27: ( '0' | '1' )+ + int cnt5=0; + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( ((LA5_0>='0' && LA5_0<='1')) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalRosLexer.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='1') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt5 >= 1 ) break loop5; + EarlyExitException eee = + new EarlyExitException(5, input); + throw eee; + } + cnt5++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BINARY" + + // $ANTLR start "RULE_BOOLEAN" + public final void mRULE_BOOLEAN() throws RecognitionException { + try { + int _type = RULE_BOOLEAN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:202:14: ( ( 'true' | 'false' ) ) + // InternalRosLexer.g:202:16: ( 'true' | 'false' ) + { + // InternalRosLexer.g:202:16: ( 'true' | 'false' ) + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='t') ) { + alt6=1; + } + else if ( (LA6_0=='f') ) { + alt6=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + switch (alt6) { + case 1 : + // InternalRosLexer.g:202:17: 'true' + { + match("true"); + + + } + break; + case 2 : + // InternalRosLexer.g:202:24: 'false' + { + match("false"); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BOOLEAN" + + // $ANTLR start "RULE_DOUBLE" + public final void mRULE_DOUBLE() throws RecognitionException { + try { + int _type = RULE_DOUBLE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:204:13: ( RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) ) + // InternalRosLexer.g:204:15: RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + { + mRULE_DIGIT(); + // InternalRosLexer.g:204:26: ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + int alt11=2; + alt11 = dfa11.predict(input); + switch (alt11) { + case 1 : + // InternalRosLexer.g:204:27: '.' ( RULE_DECINT )* + { + match('.'); + // InternalRosLexer.g:204:31: ( RULE_DECINT )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0=='-'||(LA7_0>='0' && LA7_0<='9')) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalRosLexer.g:204:31: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + + default : + break loop7; + } + } while (true); + + + } + break; + case 2 : + // InternalRosLexer.g:204:44: ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT + { + // InternalRosLexer.g:204:44: ( '.' ( RULE_DIGIT )* )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='.') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalRosLexer.g:204:45: '.' ( RULE_DIGIT )* + { + match('.'); + // InternalRosLexer.g:204:49: ( RULE_DIGIT )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( ((LA8_0>='0' && LA8_0<='9')) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // InternalRosLexer.g:204:49: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop8; + } + } while (true); + + + } + break; + + } + + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalRosLexer.g:204:73: ( '-' | '+' )? + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='+'||LA10_0=='-') ) { + alt10=1; + } + switch (alt10) { + case 1 : + // InternalRosLexer.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_DIGIT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DOUBLE" + + // $ANTLR start "RULE_DECINT" + public final void mRULE_DECINT() throws RecognitionException { + try { + int _type = RULE_DECINT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:206:13: ( ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) ) + // InternalRosLexer.g:206:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + { + // InternalRosLexer.g:206:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + int alt14=3; + switch ( input.LA(1) ) { + case '0': + { + alt14=1; + } + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt14=2; + } + break; + case '-': + { + alt14=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + + throw nvae; + } + + switch (alt14) { + case 1 : + // InternalRosLexer.g:206:16: '0' + { + match('0'); + + } + break; + case 2 : + // InternalRosLexer.g:206:20: '1' .. '9' ( RULE_DIGIT )* + { + matchRange('1','9'); + // InternalRosLexer.g:206:29: ( RULE_DIGIT )* + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( ((LA12_0>='0' && LA12_0<='9')) ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalRosLexer.g:206:29: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop12; + } + } while (true); + + + } + break; + case 3 : + // InternalRosLexer.g:206:41: '-' '0' .. '9' ( RULE_DIGIT )* + { + match('-'); + matchRange('0','9'); + // InternalRosLexer.g:206:54: ( RULE_DIGIT )* + loop13: + do { + int alt13=2; + int LA13_0 = input.LA(1); + + if ( ((LA13_0>='0' && LA13_0<='9')) ) { + alt13=1; + } + + + switch (alt13) { + case 1 : + // InternalRosLexer.g:206:54: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop13; + } + } while (true); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DECINT" + + // $ANTLR start "RULE_DAY" + public final void mRULE_DAY() throws RecognitionException { + try { + // InternalRosLexer.g:208:19: ( ( '1' .. '9' | '1' .. '3' '0' .. '9' ) ) + // InternalRosLexer.g:208:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + { + // InternalRosLexer.g:208:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + int alt15=2; + int LA15_0 = input.LA(1); + + if ( ((LA15_0>='1' && LA15_0<='3')) ) { + int LA15_1 = input.LA(2); + + if ( ((LA15_1>='0' && LA15_1<='9')) ) { + alt15=2; + } + else { + alt15=1;} + } + else if ( ((LA15_0>='4' && LA15_0<='9')) ) { + alt15=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + + throw nvae; + } + switch (alt15) { + case 1 : + // InternalRosLexer.g:208:22: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRosLexer.g:208:31: '1' .. '3' '0' .. '9' + { + matchRange('1','3'); + matchRange('0','9'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_DAY" + + // $ANTLR start "RULE_MONTH" + public final void mRULE_MONTH() throws RecognitionException { + try { + // InternalRosLexer.g:210:21: ( ( '1' .. '9' | '1' '0' .. '2' ) ) + // InternalRosLexer.g:210:23: ( '1' .. '9' | '1' '0' .. '2' ) + { + // InternalRosLexer.g:210:23: ( '1' .. '9' | '1' '0' .. '2' ) + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='1') ) { + int LA16_1 = input.LA(2); + + if ( ((LA16_1>='0' && LA16_1<='2')) ) { + alt16=2; + } + else { + alt16=1;} + } + else if ( ((LA16_0>='2' && LA16_0<='9')) ) { + alt16=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + + throw nvae; + } + switch (alt16) { + case 1 : + // InternalRosLexer.g:210:24: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRosLexer.g:210:33: '1' '0' .. '2' + { + match('1'); + matchRange('0','2'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_MONTH" + + // $ANTLR start "RULE_YEAR" + public final void mRULE_YEAR() throws RecognitionException { + try { + // InternalRosLexer.g:212:20: ( '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' ) + // InternalRosLexer.g:212:22: '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' + { + matchRange('0','2'); + matchRange('0','9'); + matchRange('0','9'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_YEAR" + + // $ANTLR start "RULE_HOUR" + public final void mRULE_HOUR() throws RecognitionException { + try { + // InternalRosLexer.g:214:20: ( ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) ) + // InternalRosLexer.g:214:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + { + // InternalRosLexer.g:214:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + int alt17=2; + int LA17_0 = input.LA(1); + + if ( ((LA17_0>='0' && LA17_0<='1')) ) { + alt17=1; + } + else if ( (LA17_0=='2') ) { + alt17=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); + + throw nvae; + } + switch (alt17) { + case 1 : + // InternalRosLexer.g:214:23: '0' .. '1' '0' .. '9' + { + matchRange('0','1'); + matchRange('0','9'); + + } + break; + case 2 : + // InternalRosLexer.g:214:41: '2' '0' .. '3' + { + match('2'); + matchRange('0','3'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_HOUR" + + // $ANTLR start "RULE_MIN_SEC" + public final void mRULE_MIN_SEC() throws RecognitionException { + try { + // InternalRosLexer.g:216:23: ( '0' .. '5' '0' .. '9' ) + // InternalRosLexer.g:216:25: '0' .. '5' '0' .. '9' + { + matchRange('0','5'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_MIN_SEC" + + // $ANTLR start "RULE_DATE_TIME" + public final void mRULE_DATE_TIME() throws RecognitionException { + try { + int _type = RULE_DATE_TIME; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:218:16: ( RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC ) + // InternalRosLexer.g:218:18: RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC + { + mRULE_YEAR(); + match('-'); + mRULE_MONTH(); + match('-'); + mRULE_DAY(); + match('T'); + mRULE_HOUR(); + match(':'); + mRULE_MIN_SEC(); + match(':'); + mRULE_MIN_SEC(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DATE_TIME" + + // $ANTLR start "RULE_MESSAGE_ASIGMENT" + public final void mRULE_MESSAGE_ASIGMENT() throws RecognitionException { + try { + int _type = RULE_MESSAGE_ASIGMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:220:23: ( ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) ) + // InternalRosLexer.g:220:25: ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + { + // InternalRosLexer.g:220:25: ( RULE_ID | RULE_STRING ) + int alt18=2; + int LA18_0 = input.LA(1); + + if ( ((LA18_0>='A' && LA18_0<='Z')||(LA18_0>='^' && LA18_0<='_')||(LA18_0>='a' && LA18_0<='z')) ) { + alt18=1; + } + else if ( (LA18_0=='\"'||LA18_0=='\'') ) { + alt18=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + + throw nvae; + } + switch (alt18) { + case 1 : + // InternalRosLexer.g:220:26: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRosLexer.g:220:34: RULE_STRING + { + mRULE_STRING(); + + } + break; + + } + + match('='); + // InternalRosLexer.g:220:51: ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + int alt19=4; + switch ( input.LA(1) ) { + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + case 'G': + case 'H': + case 'I': + case 'J': + case 'K': + case 'L': + case 'M': + case 'N': + case 'O': + case 'P': + case 'Q': + case 'R': + case 'S': + case 'T': + case 'U': + case 'V': + case 'W': + case 'X': + case 'Y': + case 'Z': + case '^': + case '_': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'g': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': + { + alt19=1; + } + break; + case '\"': + case '\'': + { + alt19=2; + } + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt19=3; + } + break; + case '-': + { + alt19=4; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 19, 0, input); + + throw nvae; + } + + switch (alt19) { + case 1 : + // InternalRosLexer.g:220:52: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRosLexer.g:220:60: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 3 : + // InternalRosLexer.g:220:72: RULE_INT + { + mRULE_INT(); + + } + break; + case 4 : + // InternalRosLexer.g:220:81: '-' RULE_INT + { + match('-'); + mRULE_INT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_MESSAGE_ASIGMENT" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:222:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // InternalRosLexer.g:222:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + // InternalRosLexer.g:222:11: ( '^' )? + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0=='^') ) { + alt20=1; + } + switch (alt20) { + case 1 : + // InternalRosLexer.g:222: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;} + + // InternalRosLexer.g:222:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop21: + do { + int alt21=2; + int LA21_0 = input.LA(1); + + if ( ((LA21_0>='0' && LA21_0<='9')||(LA21_0>='A' && LA21_0<='Z')||LA21_0=='_'||(LA21_0>='a' && LA21_0<='z')) ) { + alt21=1; + } + + + switch (alt21) { + case 1 : + // InternalRosLexer.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 loop21; + } + } 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 { + // InternalRosLexer.g:224:19: ( ( '0' .. '9' )+ ) + // InternalRosLexer.g:224:21: ( '0' .. '9' )+ + { + // InternalRosLexer.g:224:21: ( '0' .. '9' )+ + int cnt22=0; + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( ((LA22_0>='0' && LA22_0<='9')) ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalRosLexer.g:224:22: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt22 >= 1 ) break loop22; + EarlyExitException eee = + new EarlyExitException(22, input); + throw eee; + } + cnt22++; + } while (true); + + + } + + } + 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; + // InternalRosLexer.g:226:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) + // InternalRosLexer.g:226:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + { + // InternalRosLexer.g:226:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0=='\"') ) { + alt25=1; + } + else if ( (LA25_0=='\'') ) { + alt25=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); + + throw nvae; + } + switch (alt25) { + case 1 : + // InternalRosLexer.g:226:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + { + match('\"'); + // InternalRosLexer.g:226:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop23: + do { + int alt23=3; + int LA23_0 = input.LA(1); + + if ( (LA23_0=='\\') ) { + alt23=1; + } + else if ( ((LA23_0>='\u0000' && LA23_0<='!')||(LA23_0>='#' && LA23_0<='[')||(LA23_0>=']' && LA23_0<='\uFFFF')) ) { + alt23=2; + } + + + switch (alt23) { + case 1 : + // InternalRosLexer.g:226:21: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRosLexer.g:226: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 loop23; + } + } while (true); + + match('\"'); + + } + break; + case 2 : + // InternalRosLexer.g:226:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + { + match('\''); + // InternalRosLexer.g:226:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop24: + do { + int alt24=3; + int LA24_0 = input.LA(1); + + if ( (LA24_0=='\\') ) { + alt24=1; + } + else if ( ((LA24_0>='\u0000' && LA24_0<='&')||(LA24_0>='(' && LA24_0<='[')||(LA24_0>=']' && LA24_0<='\uFFFF')) ) { + alt24=2; + } + + + switch (alt24) { + case 1 : + // InternalRosLexer.g:226:54: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRosLexer.g:226: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 loop24; + } + } 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; + // InternalRosLexer.g:228:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalRosLexer.g:228:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalRosLexer.g:228:24: ( options {greedy=false; } : . )* + loop26: + do { + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0=='*') ) { + int LA26_1 = input.LA(2); + + if ( (LA26_1=='/') ) { + alt26=2; + } + else if ( ((LA26_1>='\u0000' && LA26_1<='.')||(LA26_1>='0' && LA26_1<='\uFFFF')) ) { + alt26=1; + } + + + } + else if ( ((LA26_0>='\u0000' && LA26_0<=')')||(LA26_0>='+' && LA26_0<='\uFFFF')) ) { + alt26=1; + } + + + switch (alt26) { + case 1 : + // InternalRosLexer.g:228:52: . + { + matchAny(); + + } + break; + + default : + break loop26; + } + } 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; + // InternalRosLexer.g:230:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalRosLexer.g:230:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalRosLexer.g:230:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt27=0; + loop27: + do { + int alt27=2; + int LA27_0 = input.LA(1); + + if ( ((LA27_0>='\t' && LA27_0<='\n')||LA27_0=='\r'||LA27_0==' ') ) { + alt27=1; + } + + + switch (alt27) { + case 1 : + // InternalRosLexer.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 ( cnt27 >= 1 ) break loop27; + EarlyExitException eee = + new EarlyExitException(27, input); + throw eee; + } + cnt27++; + } 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; + // InternalRosLexer.g:232:16: ( . ) + // InternalRosLexer.g:232:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalRosLexer.g:1:8: ( ParameterStructMember | ExternalDependency | RelativeNamespace | PrivateNamespace | GlobalNamespace | Serviceclient | Serviceserver | Actionclient | Actionserver | Dependencies | AmentPackage | ParameterAny | FromGitRepo | Subscribers | Parameters | Publishers | Artifacts | GraphName | Feedback_1 | Float32_1 | Float64_1 | Response | Duration | Feedback | Message_1 | Request | String_2 | Uint16_1 | Uint32_1 | Uint64_1 | Boolean | Integer | Action_1 | Default | Float32 | Float64 | Int16_1 | Int32_1 | Int64_1 | Message | Result_1 | Service | Uint8_1 | Array | Base64 | Double | Header | String | Struct | Action | Bool_1 | Byte_1 | Int8_1 | Result | Specs | String_1 | Uint16 | Uint32 | Uint64 | Goal_1 | Int16 | Int32 | Int64 | Node_1 | Type_1 | Uint8 | Value | Date | List | Bool | Byte | Goal | Int8 | Msg | Name | Node | Srv | Time | Type | Any | Ns | LeftSquareBracketRightSquareBracket | Comma | Colon | LeftSquareBracket | RightSquareBracket | RightCurlyBracket | RULE_SL_COMMENT | RULE_ROS_CONVENTION_A | RULE_ROS_CONVENTION_PARAM | RULE_BINARY | RULE_BOOLEAN | RULE_DOUBLE | RULE_DECINT | RULE_DATE_TIME | RULE_MESSAGE_ASIGMENT | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt28=101; + alt28 = dfa28.predict(input); + switch (alt28) { + case 1 : + // InternalRosLexer.g:1:10: ParameterStructMember + { + mParameterStructMember(); + + } + break; + case 2 : + // InternalRosLexer.g:1:32: ExternalDependency + { + mExternalDependency(); + + } + break; + case 3 : + // InternalRosLexer.g:1:51: RelativeNamespace + { + mRelativeNamespace(); + + } + break; + case 4 : + // InternalRosLexer.g:1:69: PrivateNamespace + { + mPrivateNamespace(); + + } + break; + case 5 : + // InternalRosLexer.g:1:86: GlobalNamespace + { + mGlobalNamespace(); + + } + break; + case 6 : + // InternalRosLexer.g:1:102: Serviceclient + { + mServiceclient(); + + } + break; + case 7 : + // InternalRosLexer.g:1:116: Serviceserver + { + mServiceserver(); + + } + break; + case 8 : + // InternalRosLexer.g:1:130: Actionclient + { + mActionclient(); + + } + break; + case 9 : + // InternalRosLexer.g:1:143: Actionserver + { + mActionserver(); + + } + break; + case 10 : + // InternalRosLexer.g:1:156: Dependencies + { + mDependencies(); + + } + break; + case 11 : + // InternalRosLexer.g:1:169: AmentPackage + { + mAmentPackage(); + + } + break; + case 12 : + // InternalRosLexer.g:1:182: ParameterAny + { + mParameterAny(); + + } + break; + case 13 : + // InternalRosLexer.g:1:195: FromGitRepo + { + mFromGitRepo(); + + } + break; + case 14 : + // InternalRosLexer.g:1:207: Subscribers + { + mSubscribers(); + + } + break; + case 15 : + // InternalRosLexer.g:1:219: Parameters + { + mParameters(); + + } + break; + case 16 : + // InternalRosLexer.g:1:230: Publishers + { + mPublishers(); + + } + break; + case 17 : + // InternalRosLexer.g:1:241: Artifacts + { + mArtifacts(); + + } + break; + case 18 : + // InternalRosLexer.g:1:251: GraphName + { + mGraphName(); + + } + break; + case 19 : + // InternalRosLexer.g:1:261: Feedback_1 + { + mFeedback_1(); + + } + break; + case 20 : + // InternalRosLexer.g:1:272: Float32_1 + { + mFloat32_1(); + + } + break; + case 21 : + // InternalRosLexer.g:1:282: Float64_1 + { + mFloat64_1(); + + } + break; + case 22 : + // InternalRosLexer.g:1:292: Response + { + mResponse(); + + } + break; + case 23 : + // InternalRosLexer.g:1:301: Duration + { + mDuration(); + + } + break; + case 24 : + // InternalRosLexer.g:1:310: Feedback + { + mFeedback(); + + } + break; + case 25 : + // InternalRosLexer.g:1:319: Message_1 + { + mMessage_1(); + + } + break; + case 26 : + // InternalRosLexer.g:1:329: Request + { + mRequest(); + + } + break; + case 27 : + // InternalRosLexer.g:1:337: String_2 + { + mString_2(); + + } + break; + case 28 : + // InternalRosLexer.g:1:346: Uint16_1 + { + mUint16_1(); + + } + break; + case 29 : + // InternalRosLexer.g:1:355: Uint32_1 + { + mUint32_1(); + + } + break; + case 30 : + // InternalRosLexer.g:1:364: Uint64_1 + { + mUint64_1(); + + } + break; + case 31 : + // InternalRosLexer.g:1:373: Boolean + { + mBoolean(); + + } + break; + case 32 : + // InternalRosLexer.g:1:381: Integer + { + mInteger(); + + } + break; + case 33 : + // InternalRosLexer.g:1:389: Action_1 + { + mAction_1(); + + } + break; + case 34 : + // InternalRosLexer.g:1:398: Default + { + mDefault(); + + } + break; + case 35 : + // InternalRosLexer.g:1:406: Float32 + { + mFloat32(); + + } + break; + case 36 : + // InternalRosLexer.g:1:414: Float64 + { + mFloat64(); + + } + break; + case 37 : + // InternalRosLexer.g:1:422: Int16_1 + { + mInt16_1(); + + } + break; + case 38 : + // InternalRosLexer.g:1:430: Int32_1 + { + mInt32_1(); + + } + break; + case 39 : + // InternalRosLexer.g:1:438: Int64_1 + { + mInt64_1(); + + } + break; + case 40 : + // InternalRosLexer.g:1:446: Message + { + mMessage(); + + } + break; + case 41 : + // InternalRosLexer.g:1:454: Result_1 + { + mResult_1(); + + } + break; + case 42 : + // InternalRosLexer.g:1:463: Service + { + mService(); + + } + break; + case 43 : + // InternalRosLexer.g:1:471: Uint8_1 + { + mUint8_1(); + + } + break; + case 44 : + // InternalRosLexer.g:1:479: Array + { + mArray(); + + } + break; + case 45 : + // InternalRosLexer.g:1:485: Base64 + { + mBase64(); + + } + break; + case 46 : + // InternalRosLexer.g:1:492: Double + { + mDouble(); + + } + break; + case 47 : + // InternalRosLexer.g:1:499: Header + { + mHeader(); + + } + break; + case 48 : + // InternalRosLexer.g:1:506: String + { + mString(); + + } + break; + case 49 : + // InternalRosLexer.g:1:513: Struct + { + mStruct(); + + } + break; + case 50 : + // InternalRosLexer.g:1:520: Action + { + mAction(); + + } + break; + case 51 : + // InternalRosLexer.g:1:527: Bool_1 + { + mBool_1(); + + } + break; + case 52 : + // InternalRosLexer.g:1:534: Byte_1 + { + mByte_1(); + + } + break; + case 53 : + // InternalRosLexer.g:1:541: Int8_1 + { + mInt8_1(); + + } + break; + case 54 : + // InternalRosLexer.g:1:548: Result + { + mResult(); + + } + break; + case 55 : + // InternalRosLexer.g:1:555: Specs + { + mSpecs(); + + } + break; + case 56 : + // InternalRosLexer.g:1:561: String_1 + { + mString_1(); + + } + break; + case 57 : + // InternalRosLexer.g:1:570: Uint16 + { + mUint16(); + + } + break; + case 58 : + // InternalRosLexer.g:1:577: Uint32 + { + mUint32(); + + } + break; + case 59 : + // InternalRosLexer.g:1:584: Uint64 + { + mUint64(); + + } + break; + case 60 : + // InternalRosLexer.g:1:591: Goal_1 + { + mGoal_1(); + + } + break; + case 61 : + // InternalRosLexer.g:1:598: Int16 + { + mInt16(); + + } + break; + case 62 : + // InternalRosLexer.g:1:604: Int32 + { + mInt32(); + + } + break; + case 63 : + // InternalRosLexer.g:1:610: Int64 + { + mInt64(); + + } + break; + case 64 : + // InternalRosLexer.g:1:616: Node_1 + { + mNode_1(); + + } + break; + case 65 : + // InternalRosLexer.g:1:623: Type_1 + { + mType_1(); + + } + break; + case 66 : + // InternalRosLexer.g:1:630: Uint8 + { + mUint8(); + + } + break; + case 67 : + // InternalRosLexer.g:1:636: Value + { + mValue(); + + } + break; + case 68 : + // InternalRosLexer.g:1:642: Date + { + mDate(); + + } + break; + case 69 : + // InternalRosLexer.g:1:647: List + { + mList(); + + } + break; + case 70 : + // InternalRosLexer.g:1:652: Bool + { + mBool(); + + } + break; + case 71 : + // InternalRosLexer.g:1:657: Byte + { + mByte(); + + } + break; + case 72 : + // InternalRosLexer.g:1:662: Goal + { + mGoal(); + + } + break; + case 73 : + // InternalRosLexer.g:1:667: Int8 + { + mInt8(); + + } + break; + case 74 : + // InternalRosLexer.g:1:672: Msg + { + mMsg(); + + } + break; + case 75 : + // InternalRosLexer.g:1:676: Name + { + mName(); + + } + break; + case 76 : + // InternalRosLexer.g:1:681: Node + { + mNode(); + + } + break; + case 77 : + // InternalRosLexer.g:1:686: Srv + { + mSrv(); + + } + break; + case 78 : + // InternalRosLexer.g:1:690: Time + { + mTime(); + + } + break; + case 79 : + // InternalRosLexer.g:1:695: Type + { + mType(); + + } + break; + case 80 : + // InternalRosLexer.g:1:700: Any + { + mAny(); + + } + break; + case 81 : + // InternalRosLexer.g:1:704: Ns + { + mNs(); + + } + break; + case 82 : + // InternalRosLexer.g:1:707: LeftSquareBracketRightSquareBracket + { + mLeftSquareBracketRightSquareBracket(); + + } + break; + case 83 : + // InternalRosLexer.g:1:743: Comma + { + mComma(); + + } + break; + case 84 : + // InternalRosLexer.g:1:749: Colon + { + mColon(); + + } + break; + case 85 : + // InternalRosLexer.g:1:755: LeftSquareBracket + { + mLeftSquareBracket(); + + } + break; + case 86 : + // InternalRosLexer.g:1:773: RightSquareBracket + { + mRightSquareBracket(); + + } + break; + case 87 : + // InternalRosLexer.g:1:792: RightCurlyBracket + { + mRightCurlyBracket(); + + } + break; + case 88 : + // InternalRosLexer.g:1:810: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 89 : + // InternalRosLexer.g:1:826: RULE_ROS_CONVENTION_A + { + mRULE_ROS_CONVENTION_A(); + + } + break; + case 90 : + // InternalRosLexer.g:1:848: RULE_ROS_CONVENTION_PARAM + { + mRULE_ROS_CONVENTION_PARAM(); + + } + break; + case 91 : + // InternalRosLexer.g:1:874: RULE_BINARY + { + mRULE_BINARY(); + + } + break; + case 92 : + // InternalRosLexer.g:1:886: RULE_BOOLEAN + { + mRULE_BOOLEAN(); + + } + break; + case 93 : + // InternalRosLexer.g:1:899: RULE_DOUBLE + { + mRULE_DOUBLE(); + + } + break; + case 94 : + // InternalRosLexer.g:1:911: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + case 95 : + // InternalRosLexer.g:1:923: RULE_DATE_TIME + { + mRULE_DATE_TIME(); + + } + break; + case 96 : + // InternalRosLexer.g:1:938: RULE_MESSAGE_ASIGMENT + { + mRULE_MESSAGE_ASIGMENT(); + + } + break; + case 97 : + // InternalRosLexer.g:1:960: RULE_ID + { + mRULE_ID(); + + } + break; + case 98 : + // InternalRosLexer.g:1:968: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 99 : + // InternalRosLexer.g:1:980: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 100 : + // InternalRosLexer.g:1:996: RULE_WS + { + mRULE_WS(); + + } + break; + case 101 : + // InternalRosLexer.g:1:1004: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA11 dfa11 = new DFA11(this); + protected DFA28 dfa28 = new DFA28(this); + static final String DFA11_eotS = + "\1\uffff\1\5\1\uffff\2\5\1\uffff\2\5"; + static final String DFA11_eofS = + "\10\uffff"; + static final String DFA11_minS = + "\1\56\1\60\1\uffff\2\60\1\uffff\2\60"; + static final String DFA11_maxS = + "\2\145\1\uffff\2\145\1\uffff\2\145"; + static final String DFA11_acceptS = + "\2\uffff\1\2\2\uffff\1\1\2\uffff"; + static final String DFA11_specialS = + "\10\uffff}>"; + static final String[] DFA11_transitionS = { + "\1\1\26\uffff\1\2\37\uffff\1\2", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2" + }; + + static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); + static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); + static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); + static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); + static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); + static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); + static final short[][] DFA11_transition; + + static { + int numStates = DFA11_transitionS.length; + DFA11_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA28_transitionS = { + "\11\54\2\53\2\54\1\53\22\54\1\53\1\54\1\44\1\37\3\54\1\45\4\54\1\33\1\51\1\54\1\40\1\47\2\50\7\52\1\34\6\54\1\10\1\16\1\42\1\21\1\2\1\42\1\4\1\22\1\17\2\42\1\31\3\42\1\1\1\42\1\3\1\23\7\42\1\32\1\54\1\35\1\41\1\42\1\54\1\6\1\24\1\42\1\7\1\42\1\11\1\25\1\42\1\20\3\42\1\14\1\26\1\42\1\12\1\42\1\13\1\5\1\27\1\15\1\30\4\42\2\54\1\36\1\46\uff81\54", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\55\20\57\1\56\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\27\57\1\62\2\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\63\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\64\5\57\1\65\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\66\12\57\1\71\1\57\1\72\1\57\1\70\1\67\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\73\16\57\1\74\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\75\17\57\1\76\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\77\1\101\3\57\1\100\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\105\3\57\1\103\6\57\1\104\5\57\1\102\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\106\23\57\1\107\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\110\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\111\15\57\1\112\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\113\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\115\15\57\1\114\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\116\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\117\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\121\15\57\1\120\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\122\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\123\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\124\11\57\1\125\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\126\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\130\15\57\1\127\3\57\1\131\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\133\10\57\1\134\6\57\1\132\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\135\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\136\21\57", + "\1\137", + "", + "", + "", + "", + "", + "\1\147\4\uffff\1\147\2\uffff\1\146\26\uffff\32\43\3\uffff\2\43\1\uffff\32\43", + "\32\150\4\uffff\1\150\1\uffff\32\150", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\42\152\1\153\71\152\1\151\uffa3\152", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\1\147\4\uffff\1\147", + "\1\162\1\uffff\12\160\10\uffff\1\157\2\uffff\1\162\34\uffff\1\157\2\uffff\1\162", + "\1\162\1\uffff\12\163\13\uffff\1\162\37\uffff\1\162", + "\12\161", + "\1\162\26\uffff\1\162\37\uffff\1\162", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\165\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\166\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\167\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\170\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\171\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\172\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\173\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\174\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\175\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\176\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\177\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0080\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0081\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\5\57\1\u0083\11\57\1\u0082\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0084\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0085\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0086\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u0087\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u0088\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0089\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u008a\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u008b\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u008c\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u008d\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\20\57\1\u008f\1\57\1\u008e\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0090\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0091\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0092\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u0093\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0094\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0095\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0096\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u0097\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0098\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0099\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u009a\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u009b\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u009c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u009d\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u009e\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u009f\15\57", + "\1\43\12\57\1\u00a0\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00a1\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00a2\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00a3\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00a4\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00a5\7\57", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\0\u00a6", + "\42\152\1\153\71\152\1\151\uffa3\152", + "\1\147\15\uffff\1\61", + "\0\u00a8", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\1\147\15\uffff\1\61", + "", + "", + "", + "", + "\12\u00a9", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00aa\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u00ab\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ac\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00ad\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00ae\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00af\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u00b0\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00b1\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b2\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u00b3\27\57", + "\1\43\12\57\1\u00b4\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b5\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00b7\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00b8\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00b9\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00ba\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00bb\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00bd\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u00be\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00bf\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00c0\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00c1\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00c2\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00c3\4\57\1\u00c4\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00c5\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00c6\7\57", + "\1\43\12\57\1\u00c7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00c8\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00c9\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ca\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00cb\25\57", + "\1\43\1\57\1\u00cc\1\57\1\u00cd\2\57\1\u00ce\1\57\1\u00cf\1\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00d0\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d1\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u00d2\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00d3\13\57\1\u00d4\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00d5\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d6\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00d7\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d8\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d9\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00da\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00db\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00dc\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00dd\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00de\6\57", + "\42\152\1\153\71\152\1\151\uffa3\152", + "", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\12\u00df", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00e0\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00e1\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u00e2\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00e3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00e4\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\7\57\1\u00e5\22\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00e6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u00e7\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00e8\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00e9\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u00ea\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\5\57\1\u00eb\24\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00ec\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00ed\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00ee\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00ef\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u00f0\1\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\6\57\1\u00f1\23\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00f2\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00f3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00f4\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00f5\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00f6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u00f7\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00f8\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00f9\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00fa\31\57", + "", + "\1\43\1\57\1\u00fb\1\57\1\u00fc\2\57\1\u00fd\1\57\1\u00fe\1\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ff\25\57", + "\1\43\6\57\1\u0100\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0101\23\57", + "\1\43\6\57\1\u0102\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\2\57\1\u0103\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u0104\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0105\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0107\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0109\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u010a\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u010b\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u010c\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u010e\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0110\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0112\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0115\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0119\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\160", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u011b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u011c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u011d\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u011e\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u011f\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0120\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0121\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0122\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0123\23\57", + "\1\43\12\57\1\u0124\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0125\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0126\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u0127\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0128\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u0129\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\17\57\1\u012a\12\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u012b\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u012c\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u012d\31\57", + "\1\43\3\57\1\u012e\2\57\1\u012f\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0130\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0131\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0132\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0133\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0134\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0135\23\57", + "\1\43\6\57\1\u0136\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\2\57\1\u0137\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u0138\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0139\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u013b\31\57", + "\1\43\4\57\1\u013c\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u013d\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u013e\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0140\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0142\3\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0144\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0145\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0146\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0147\6\57", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0149\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u014a\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u014b\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u014c\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u014d\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u014e\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u014f\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u0150\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0151\3\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\1\u0155\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0153\17\57\1\u0154\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0157\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0158\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0159\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u015a\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u015b\31\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u015c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u015d\27\57", + "\1\43\2\57\1\u015e\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u015f\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0160\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\7\57\1\u0161\22\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0162\7\57", + "\1\43\12\57\1\u0163\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0165\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0166\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0167\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0169\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u016b\3\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u016d\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u016f\10\57", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0174\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0175\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0176\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0177\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0178\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u0179\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u017a\17\57\1\u017b\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u017d\30\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u017e\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u017f\25\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0180\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0181\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0183\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0184\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\21\57\1\u0185\10\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\12\57\1\u0186\17\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0187\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0189\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018c\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018d\25\57", + "", + "", + "\1\43\12\57\1\u018e\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u018f\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0193\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0194\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\3\57\1\u0195\26\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0196\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u0197\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0198\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0199\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u019a\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u019b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u019c\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u019d\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u019e\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u019f\27\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\12\57\1\u01a1\17\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01a2\25\57", + "\1\43\12\57\1\u01a3\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01a5\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01a6\10\57", + "\1\43\12\57\1\u01a7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\1\u01a9\21\57\1\u01a8\7\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01aa\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ab\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01ac\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ad\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u01af\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01b0\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01b1\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01b2\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u01b3\4\57", + "\1\43\12\57\1\u01b4\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u01b5\21\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01b6\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01b7\12\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01b8\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01b9\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01ba\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01bb\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01bc\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01bd\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01be\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01bf\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c0\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u01c1\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01c2\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01c3\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c4\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c5\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u01c6\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u01c7\13\57", + "\1\43\12\57\1\u01c8\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01c9\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01ca\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u01cb\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01cc\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01cd\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ce\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01cf\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01d0\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01d1\25\57", + "\1\43\12\57\1\u01d2\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01d3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01d4\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01d5\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01d6\25\57", + "\1\43\12\57\1\u01d7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u01d8\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01da\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01db\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01dc\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01dd\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01de\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01df\10\57", + "", + "\1\43\12\57\1\u01e0\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01e1\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01e2\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01e4\27\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01e5\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u01e6\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01e7\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01e8\27\57", + "\1\43\12\57\1\u01e9\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01ea\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01eb\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01ec\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ed\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01ee\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ef\25\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\14\57\1\u01f0\15\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f1\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01f2\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01f3\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f5\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01f7\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f8\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01f9\15\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u01fa\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u01fc\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01fe\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01ff\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "" + }; + + static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS); + static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS); + static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS); + static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS); + static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS); + static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS); + static final short[][] DFA28_transition; + + static { + int numStates = DFA28_transitionS.length; + DFA28_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA28_105<='\uFFFF')) ) {s = 166;} + + if ( s>=0 ) return s; + break; + case 1 : + int LA28_108 = input.LA(1); + + s = -1; + if ( ((LA28_108>='\u0000' && LA28_108<='\uFFFF')) ) {s = 168;} + + if ( s>=0 ) return s; + break; + case 2 : + int LA28_37 = input.LA(1); + + s = -1; + if ( (LA28_37=='\\') ) {s = 108;} + + else if ( ((LA28_37>='\u0000' && LA28_37<='&')||(LA28_37>='(' && LA28_37<='[')||(LA28_37>=']' && LA28_37<='\uFFFF')) ) {s = 109;} + + else if ( (LA28_37=='\'') ) {s = 110;} + + else s = 44; + + if ( s>=0 ) return s; + break; + case 3 : + int LA28_0 = input.LA(1); + + s = -1; + if ( (LA28_0=='P') ) {s = 1;} + + else if ( (LA28_0=='E') ) {s = 2;} + + else if ( (LA28_0=='R') ) {s = 3;} + + else if ( (LA28_0=='G') ) {s = 4;} + + else if ( (LA28_0=='s') ) {s = 5;} + + else if ( (LA28_0=='a') ) {s = 6;} + + else if ( (LA28_0=='d') ) {s = 7;} + + else if ( (LA28_0=='A') ) {s = 8;} + + else if ( (LA28_0=='f') ) {s = 9;} + + else if ( (LA28_0=='p') ) {s = 10;} + + else if ( (LA28_0=='r') ) {s = 11;} + + else if ( (LA28_0=='m') ) {s = 12;} + + else if ( (LA28_0=='u') ) {s = 13;} + + else if ( (LA28_0=='B') ) {s = 14;} + + else if ( (LA28_0=='I') ) {s = 15;} + + else if ( (LA28_0=='i') ) {s = 16;} + + else if ( (LA28_0=='D') ) {s = 17;} + + else if ( (LA28_0=='H') ) {s = 18;} + + else if ( (LA28_0=='S') ) {s = 19;} + + else if ( (LA28_0=='b') ) {s = 20;} + + else if ( (LA28_0=='g') ) {s = 21;} + + else if ( (LA28_0=='n') ) {s = 22;} + + else if ( (LA28_0=='t') ) {s = 23;} + + else if ( (LA28_0=='v') ) {s = 24;} + + else if ( (LA28_0=='L') ) {s = 25;} + + else if ( (LA28_0=='[') ) {s = 26;} + + else if ( (LA28_0==',') ) {s = 27;} + + else if ( (LA28_0==':') ) {s = 28;} + + else if ( (LA28_0==']') ) {s = 29;} + + else if ( (LA28_0=='}') ) {s = 30;} + + else if ( (LA28_0=='#') ) {s = 31;} + + else if ( (LA28_0=='/') ) {s = 32;} + + else if ( (LA28_0=='^') ) {s = 33;} + + else if ( (LA28_0=='C'||LA28_0=='F'||(LA28_0>='J' && LA28_0<='K')||(LA28_0>='M' && LA28_0<='O')||LA28_0=='Q'||(LA28_0>='T' && LA28_0<='Z')||LA28_0=='_'||LA28_0=='c'||LA28_0=='e'||LA28_0=='h'||(LA28_0>='j' && LA28_0<='l')||LA28_0=='o'||LA28_0=='q'||(LA28_0>='w' && LA28_0<='z')) ) {s = 34;} + + else if ( (LA28_0=='\"') ) {s = 36;} + + else if ( (LA28_0=='\'') ) {s = 37;} + + else if ( (LA28_0=='~') ) {s = 38;} + + else if ( (LA28_0=='0') ) {s = 39;} + + else if ( ((LA28_0>='1' && LA28_0<='2')) ) {s = 40;} + + else if ( (LA28_0=='-') ) {s = 41;} + + else if ( ((LA28_0>='3' && LA28_0<='9')) ) {s = 42;} + + else if ( ((LA28_0>='\t' && LA28_0<='\n')||LA28_0=='\r'||LA28_0==' ') ) {s = 43;} + + else if ( ((LA28_0>='\u0000' && LA28_0<='\b')||(LA28_0>='\u000B' && LA28_0<='\f')||(LA28_0>='\u000E' && LA28_0<='\u001F')||LA28_0=='!'||(LA28_0>='$' && LA28_0<='&')||(LA28_0>='(' && LA28_0<='+')||LA28_0=='.'||(LA28_0>=';' && LA28_0<='@')||LA28_0=='\\'||LA28_0=='`'||(LA28_0>='{' && LA28_0<='|')||(LA28_0>='\u007F' && LA28_0<='\uFFFF')) ) {s = 44;} + + else s = 35; + + if ( s>=0 ) return s; + break; + case 4 : + int LA28_166 = input.LA(1); + + s = -1; + if ( (LA28_166=='\"') ) {s = 107;} + + else if ( (LA28_166=='\\') ) {s = 105;} + + else if ( ((LA28_166>='\u0000' && LA28_166<='!')||(LA28_166>='#' && LA28_166<='[')||(LA28_166>=']' && LA28_166<='\uFFFF')) ) {s = 106;} + + if ( s>=0 ) return s; + break; + case 5 : + int LA28_106 = input.LA(1); + + s = -1; + if ( (LA28_106=='\"') ) {s = 107;} + + else if ( (LA28_106=='\\') ) {s = 105;} + + else if ( ((LA28_106>='\u0000' && LA28_106<='!')||(LA28_106>='#' && LA28_106<='[')||(LA28_106>=']' && LA28_106<='\uFFFF')) ) {s = 106;} + + if ( s>=0 ) return s; + break; + case 6 : + int LA28_36 = input.LA(1); + + s = -1; + if ( (LA28_36=='\\') ) {s = 105;} + + else if ( ((LA28_36>='\u0000' && LA28_36<='!')||(LA28_36>='#' && LA28_36<='[')||(LA28_36>=']' && LA28_36<='\uFFFF')) ) {s = 106;} + + else if ( (LA28_36=='\"') ) {s = 107;} + + else s = 44; + + if ( s>=0 ) return s; + break; + case 7 : + int LA28_168 = input.LA(1); + + s = -1; + if ( (LA28_168=='\'') ) {s = 110;} + + else if ( (LA28_168=='\\') ) {s = 108;} + + else if ( ((LA28_168>='\u0000' && LA28_168<='&')||(LA28_168>='(' && LA28_168<='[')||(LA28_168>=']' && LA28_168<='\uFFFF')) ) {s = 109;} + + if ( s>=0 ) return s; + break; + case 8 : + int LA28_109 = input.LA(1); + + s = -1; + if ( (LA28_109=='\'') ) {s = 110;} + + else if ( (LA28_109=='\\') ) {s = 108;} + + else if ( ((LA28_109>='\u0000' && LA28_109<='&')||(LA28_109>='(' && LA28_109<='[')||(LA28_109>=']' && LA28_109<='\uFFFF')) ) {s = 109;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 28, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/lexer/InternalRosLexer.tokens b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/lexer/InternalRosLexer.tokens new file mode 100644 index 000000000..135670e45 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/lexer/InternalRosLexer.tokens @@ -0,0 +1,110 @@ +Action=53 +Action_1=36 +Actionclient=11 +Actionserver=12 +AmentPackage=14 +Any=83 +Array=47 +Artifacts=20 +Base64=48 +Bool=73 +Bool_1=54 +Boolean=34 +Byte=74 +Byte_1=55 +Colon=87 +Comma=86 +Date=71 +Default=37 +Dependencies=13 +Double=49 +Duration=26 +ExternalDependency=5 +Feedback=27 +Feedback_1=22 +Float32=38 +Float32_1=23 +Float64=39 +Float64_1=24 +FromGitRepo=16 +GlobalNamespace=8 +Goal=75 +Goal_1=63 +GraphName=21 +Header=50 +Int16=64 +Int16_1=40 +Int32=65 +Int32_1=41 +Int64=66 +Int64_1=42 +Int8=76 +Int8_1=56 +Integer=35 +LeftSquareBracket=88 +LeftSquareBracketRightSquareBracket=85 +List=72 +Message=43 +Message_1=28 +Msg=77 +Name=78 +Node=79 +Node_1=67 +Ns=84 +ParameterAny=15 +ParameterStructMember=4 +Parameters=18 +PrivateNamespace=7 +Publishers=19 +RULE_ANY_OTHER=113 +RULE_BEGIN=91 +RULE_BINARY=99 +RULE_BOOLEAN=100 +RULE_DATE_TIME=108 +RULE_DAY=103 +RULE_DECINT=101 +RULE_DIGIT=98 +RULE_DOUBLE=102 +RULE_END=92 +RULE_HOUR=106 +RULE_ID=94 +RULE_INT=109 +RULE_MESSAGE_ASIGMENT=110 +RULE_MIN_SEC=107 +RULE_ML_COMMENT=111 +RULE_MONTH=104 +RULE_ROS_CONVENTION_A=95 +RULE_ROS_CONVENTION_PARAM=97 +RULE_SL_COMMENT=93 +RULE_STRING=96 +RULE_WS=112 +RULE_YEAR=105 +RelativeNamespace=6 +Request=29 +Response=25 +Result=57 +Result_1=44 +RightCurlyBracket=90 +RightSquareBracket=89 +Service=45 +Serviceclient=9 +Serviceserver=10 +Specs=58 +Srv=80 +String=51 +String_1=59 +String_2=30 +Struct=52 +Subscribers=17 +Time=81 +Type=82 +Type_1=68 +Uint16=60 +Uint16_1=31 +Uint32=61 +Uint32_1=32 +Uint64=62 +Uint64_1=33 +Uint8=69 +Uint8_1=46 +Value=70 diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src/de/fraunhofer/ipa/ros/ide/RosIdeModule.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src/de/fraunhofer/ipa/ros/ide/RosIdeModule.xtend index 7c3d82a8a..3aa7b87cb 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src/de/fraunhofer/ipa/ros/ide/RosIdeModule.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src/de/fraunhofer/ipa/ros/ide/RosIdeModule.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.ide diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src/de/fraunhofer/ipa/ros/ide/RosIdeSetup.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src/de/fraunhofer/ipa/ros/ide/RosIdeSetup.xtend index 08c2d3f2f..c66d6680c 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src/de/fraunhofer/ipa/ros/ide/RosIdeSetup.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src/de/fraunhofer/ipa/ros/ide/RosIdeSetup.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.ide diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src/de/fraunhofer/ipa/ros/ide/contentassist/antlr/RosTokenSource.java b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src/de/fraunhofer/ipa/ros/ide/contentassist/antlr/RosTokenSource.java new file mode 100644 index 000000000..14d93a1b4 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ide/src/de/fraunhofer/ipa/ros/ide/contentassist/antlr/RosTokenSource.java @@ -0,0 +1,39 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros.ide.contentassist.antlr; + +import de.fraunhofer.ipa.ros.ide.contentassist.antlr.internal.InternalRosParser; +import org.antlr.runtime.Token; +import org.antlr.runtime.TokenSource; +import org.eclipse.xtext.parser.antlr.AbstractIndentationTokenSource; + +public class RosTokenSource extends AbstractIndentationTokenSource { + + public RosTokenSource(TokenSource delegate) { + super(delegate); + } + + @Override + protected boolean shouldSplitTokenImpl(Token token) { + // TODO Review assumption + return token.getType() == InternalRosParser.RULE_WS; + } + + @Override + protected boolean shouldEmitPendingEndTokens() { + return false; + } + + @Override + protected int getEndTokenType() { + // TODO Auto-generated method stub + return 0; + } + + @Override + protected int getBeginTokenType() { + // TODO Auto-generated method stub + return 0; + } +} diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/basic_msgs/common_msgs.ros b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/basic_msgs/common_msgs.ros index 583c69171..7e975e656 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/basic_msgs/common_msgs.ros +++ b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/basic_msgs/common_msgs.ros @@ -1,119 +1,337 @@ -PackageSet{ - Package geometry_msgs{ Specs { - TopicSpec Accel{ message { Vector3 linear Vector3 angular }}, - TopicSpec AccelStamped{ message { Header header Accel accel }}, - TopicSpec AccelWithCovariance{ message { Accel accel float64[] covariance }}, - TopicSpec AccelWithCovarianceStamped{ message { Header header AccelWithCovariance accel }}, - TopicSpec Inertia{ message { float64 m "geometry_msgs.Vector3" com float64 ixx float64 ixy float64 ixz float64 iyy float64 iyz float64 izz }}, - TopicSpec InertiaStamped{ message { Header header Inertia inertia }}, - TopicSpec Point{ message { float64 x float64 y float64 z }}, - TopicSpec Point32{ message { float32 x float32 y float32 z }}, - TopicSpec PointStamped{ message { Header header Point point }}, - TopicSpec Polygon{ message { Point32[] points }}, - TopicSpec PolygonStamped{ message { Header header Polygon polygon }}, - TopicSpec Pose{ message { Point position Quaternion orientation }}, - TopicSpec Pose2D{ message { float64 x float64 y float64 theta }}, - TopicSpec PoseArray{ message { Header header Pose[] poses }}, - TopicSpec PoseStamped{ message { Header header Pose pose }}, - TopicSpec PoseWithCovariance{ message { Pose pose float64[] covariance }}, - TopicSpec PoseWithCovarianceStamped{ message { Header header PoseWithCovariance pose }}, - TopicSpec Quaternion{ message { float64 x float64 y float64 z float64 w }}, - TopicSpec QuaternionStamped{ message { Header header Quaternion quaternion }}, - TopicSpec Transform{ message { Vector3 translation Quaternion rotation }}, - TopicSpec TransformStamped{ message { Header header string child_frame_id Transform transform }}, - TopicSpec Twist{ message { Vector3 linear Vector3 angular }}, - TopicSpec TwistStamped{ message { Header header Twist twist }}, - TopicSpec TwistWithCovariance{ message { Twist twist float64[] covariance }}, - TopicSpec TwistWithCovarianceStamped{ message { Header header TwistWithCovariance twist }}, - TopicSpec Vector3{ message { float64 x float64 y float64 z }}, - TopicSpec Vector3Stamped{ message { Header header Vector3 vector }}, - TopicSpec Wrench{ message { Vector3 force Vector3 torque }}, - TopicSpec WrenchStamped{ message { Header header Wrench wrench }} - }}, - Package actionlib_msgs{ Specs { - TopicSpec GoalID{ message { time stamp string id }}, - TopicSpec GoalStatus{ message { GoalID goal_id uint8 status uint8 PENDING=0 uint8 ACTIVE=1 uint8 PREEMPTED=2 uint8 SUCCEEDED=3 uint8 ABORTED=4 uint8 REJECTED=5 uint8 PREEMPTING=6 uint8 RECALLING=7 uint8 RECALLED=8 uint8 LOST=9 string text }}, - TopicSpec GoalStatusArray{ message { Header header GoalStatus[] status_list }} - }}, - Package diagnostic_msgs{ Specs { - TopicSpec DiagnosticArray{ message { Header header DiagnosticStatus[] status }}, - TopicSpec DiagnosticStatus{ message { byte OK=0 byte WARN=1 byte ERROR=2 byte STALE=3 byte level string name string message string hardware_id KeyValue[] values }}, - TopicSpec KeyValue{ message { string key string value }}, - ServiceSpec AddDiagnostics{ request { string load_namespace } response { bool success string message } }, - ServiceSpec SelfTest{ request { } response { string id byte passed DiagnosticStatus[] status } } - }}, - Package nav_msgs{ Specs { - TopicSpec GetMapAction{ message { GetMapActionGoal action_goal GetMapActionResult action_result GetMapActionFeedback action_feedback }}, - TopicSpec GetMapActionFeedback{ message { Header header "actionlib_msgs.GoalStatus" status GetMapFeedback feedback }}, - TopicSpec GetMapActionGoal{ message { Header header "actionlib_msgs.GoalID" goal_id GetMapGoal goal }}, - TopicSpec GetMapActionResult{ message { Header header "actionlib_msgs.GoalStatus" status GetMapResult result }}, - TopicSpec GetMapFeedback{ message { }}, - TopicSpec GetMapGoal{ message { }}, - TopicSpec GetMapResult{ message { "nav_msgs.OccupancyGrid" map }}, - TopicSpec GridCells{ message { Header header float32 cell_width float32 cell_height "geometry_msgs.Point"[] cells }}, - TopicSpec MapMetaData{ message { time map_load_time float32 resolution uint32 width uint32 height "geometry_msgs.Pose" origin }}, - TopicSpec OccupancyGrid{ message { Header header MapMetaData info int8[] data }}, - TopicSpec Odometry{ message { Header header string child_frame_id "geometry_msgs.PoseWithCovariance" pose "geometry_msgs.TwistWithCovariance" twist }}, - TopicSpec Path{ message { Header header "geometry_msgs.PoseStamped"[] poses }}, - ServiceSpec GetMap{ request { } response { "nav_msgs.OccupancyGrid" map } }, - ServiceSpec GetPlan{ request { "geometry_msgs.PoseStamped" start "geometry_msgs.PoseStamped" goal float32 tolerance } response { "nav_msgs.Path" plan } }, - ServiceSpec SetMap{ request { "nav_msgs.OccupancyGrid" map "geometry_msgs.PoseWithCovarianceStamped" initial_pose } response { bool success } } - }}, - Package sensor_msgs{ Specs { - TopicSpec BatteryState{ message { uint8 POWER_SUPPLY_STATUS_UNKNOWN=0 uint8 POWER_SUPPLY_STATUS_CHARGING=1 uint8 POWER_SUPPLY_STATUS_DISCHARGING=2 uint8 POWER_SUPPLY_STATUS_NOT_CHARGING=3 uint8 POWER_SUPPLY_STATUS_FULL=4 uint8 POWER_SUPPLY_HEALTH_UNKNOWN=0 uint8 POWER_SUPPLY_HEALTH_GOOD=1 uint8 POWER_SUPPLY_HEALTH_OVERHEAT=2 uint8 POWER_SUPPLY_HEALTH_DEAD=3 uint8 POWER_SUPPLY_HEALTH_OVERVOLTAGE=4 uint8 POWER_SUPPLY_HEALTH_UNSPEC_FAILURE=5 uint8 POWER_SUPPLY_HEALTH_COLD=6 uint8 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE=7 uint8 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE=8 uint8 POWER_SUPPLY_TECHNOLOGY_UNKNOWN=0 uint8 POWER_SUPPLY_TECHNOLOGY_NIMH=1 uint8 POWER_SUPPLY_TECHNOLOGY_LION=2 uint8 POWER_SUPPLY_TECHNOLOGY_LIPO=3 uint8 POWER_SUPPLY_TECHNOLOGY_LIFE=4 uint8 POWER_SUPPLY_TECHNOLOGY_NICD=5 uint8 POWER_SUPPLY_TECHNOLOGY_LIMN=6 Header header float32 voltage float32 current float32 charge float32 capacity float32 design_capacity float32 percentage uint8 power_supply_status uint8 power_supply_health uint8 power_supply_technology bool present float32[] cell_voltage string location string serial_number }}, - TopicSpec CameraInfo{ message { Header header uint32 height uint32 width string distortion_model float64[] D float64[] K float64[] R float64[] P uint32 binning_x uint32 binning_y RegionOfInterest roi }}, - TopicSpec ChannelFloat32{ message { string name float32[] values }}, - TopicSpec CompressedImage{ message { Header header string format uint8[] data }}, - TopicSpec FluidPressure{ message { Header header float64 fluid_pressure float64 variance }}, - TopicSpec Illuminance{ message { Header header float64 illuminance float64 variance }}, - TopicSpec Image{ message { Header header uint32 height uint32 width string encoding uint8 is_bigendian uint32 step uint8[] data }}, - TopicSpec Imu{ message { Header header "geometry_msgs.Quaternion" orientation float64[] orientation_covariance "geometry_msgs.Vector3" angular_velocity float64[] angular_velocity_covariance "geometry_msgs.Vector3" linear_acceleration float64[] linear_acceleration_covariance }}, - TopicSpec JointState{ message { Header header string[] name float64[] position float64[] velocity float64[] effort }}, - TopicSpec Joy{ message { Header header float32[] axes int32[] buttons }}, - TopicSpec JoyFeedback{ message { uint8 TYPE_LED=0 uint8 TYPE_RUMBLE=1 uint8 TYPE_BUZZER=2 uint8 type uint8 id float32 intensity }}, - TopicSpec JoyFeedbackArray{ message { JoyFeedback[] array }}, - TopicSpec LaserEcho{ message { float32[] echoes }}, - TopicSpec LaserScan{ message { Header header float32 angle_min float32 angle_max float32 angle_increment float32 time_increment float32 scan_time float32 range_min float32 range_max float32[] ranges float32[] intensities }}, - TopicSpec MagneticField{ message { Header header "geometry_msgs.Vector3" magnetic_field float64[] magnetic_field_covariance }}, - TopicSpec MultiDOFJointState{ message { Header header string[] joint_names "geometry_msgs.Transform"[] transforms "geometry_msgs.Twist"[] twist "geometry_msgs.Wrench"[] wrench }}, - TopicSpec MultiEchoLaserScan{ message { Header header float32 angle_min float32 angle_max float32 angle_increment float32 time_increment float32 scan_time float32 range_min float32 range_max LaserEcho[] ranges LaserEcho[] intensities }}, - TopicSpec NavSatFix{ message { Header header NavSatStatus status float64 latitude float64 longitude float64 altitude float64[] position_covariance uint8 COVARIANCE_TYPE_UNKNOWN=0 uint8 COVARIANCE_TYPE_APPROXIMATED=1 uint8 COVARIANCE_TYPE_DIAGONAL_KNOWN=2 uint8 COVARIANCE_TYPE_KNOWN=3 uint8 position_covariance_type }}, - TopicSpec NavSatStatus{ message { int8 STATUS_NO_FIX=-1 int8 STATUS_FIX=0 int8 STATUS_SBAS_FIX=1 int8 STATUS_GBAS_FIX=2 int8 status uint16 SERVICE_GPS=1 uint16 SERVICE_GLONASS=2 uint16 SERVICE_COMPASS=4 uint16 SERVICE_GALILEO=8 uint16 service }}, - TopicSpec PointCloud{ message { Header header "geometry_msgs.Point32"[] points ChannelFloat32[] channels }}, - TopicSpec PointCloud2{ message { Header header uint32 height uint32 width PointField[] fields bool is_bigendian uint32 point_step uint32 row_step uint8[] data bool is_dense }}, - TopicSpec PointField{ message { uint8 INT8=1 uint8 UINT8=2 uint8 INT16=3 uint8 UINT16=4 uint8 INT32=5 uint8 UINT32=6 uint8 FLOAT32=7 uint8 FLOAT64=8 string name uint32 offset uint8 datatype uint32 count }}, - TopicSpec Range{ message { Header header uint8 ULTRASOUND=0 uint8 INFRARED=1 uint8 radiation_type float32 field_of_view float32 min_range float32 max_range float32 range }}, - TopicSpec RegionOfInterest{ message { uint32 x_offset uint32 y_offset uint32 height uint32 width bool do_rectify }}, - TopicSpec RelativeHumidity{ message { Header header float64 relative_humidity float64 variance }}, - TopicSpec Temperature{ message { Header header float64 temperature float64 variance }}, - TopicSpec TimeReference{ message { Header header time time_ref string source }}, - ServiceSpec SetCameraInfo{ request { "sensor_msgs.CameraInfo" camera_info } response { bool success string status_message } } - }}, - Package shape_msgs{ Specs { - TopicSpec Mesh{ message { MeshTriangle[] triangles "geometry_msgs.Point"[] vertices }}, - TopicSpec MeshTriangle{ message { uint32[] vertex_indices }}, - TopicSpec Plane{ message { float64[] coef }}, - TopicSpec SolidPrimitive{ message { uint8 BOX=1 uint8 SPHERE=2 uint8 CYLINDER=3 uint8 CONE=4 uint8 type float64[] dimensions uint8 BOX_X=0 uint8 BOX_Y=1 uint8 BOX_Z=2 uint8 SPHERE_RADIUS=0 uint8 CYLINDER_HEIGHT=0 uint8 CYLINDER_RADIUS=1 uint8 CONE_HEIGHT=0 uint8 CONE_RADIUS=1 }} - }}, - Package stereo_msgs{ Specs { - TopicSpec DisparityImage{ message { Header header "sensor_msgs.Image" image float32 f float32 T "sensor_msgs.RegionOfInterest" valid_window float32 min_disparity float32 max_disparity float32 delta_d }} - }}, - Package trajectory_msgs{ Specs { - TopicSpec JointTrajectory{ message { Header header string[] joint_names JointTrajectoryPoint[] points }}, - TopicSpec JointTrajectoryPoint{ message { float64[] positions float64[] velocities float64[] accelerations float64[] effort duration time_from_start }}, - TopicSpec MultiDOFJointTrajectory{ message { Header header string[] joint_names MultiDOFJointTrajectoryPoint[] points }}, - TopicSpec MultiDOFJointTrajectoryPoint{ message { "geometry_msgs.Transform"[] transforms "geometry_msgs.Twist"[] velocities "geometry_msgs.Twist"[] accelerations duration time_from_start }} - }}, - Package visualization_msgs{ Specs { - TopicSpec ImageMarker{ message { uint8 CIRCLE=0 uint8 LINE_STRIP=1 uint8 LINE_LIST=2 uint8 POLYGON=3 uint8 POINTS=4 uint8 ADD=0 uint8 REMOVE=1 Header header string ns int32 id int32 type int32 action "geometry_msgs.Point" position float32 scale "std_msgs.ColorRGBA" outline_color uint8 filled "std_msgs.ColorRGBA" fill_color duration lifetime "geometry_msgs.Point"[] points "std_msgs.ColorRGBA"[] outline_colors }}, - TopicSpec InteractiveMarker{ message { Header header "geometry_msgs.Pose" pose string name string description float32 scale MenuEntry[] menu_entries InteractiveMarkerControl[] controls }}, - TopicSpec InteractiveMarkerControl{ message { string name "geometry_msgs.Quaternion" orientation uint8 INHERIT=0 uint8 FIXED=1 uint8 VIEW_FACING=2 uint8 orientation_mode uint8 NONE=0 uint8 MENU=1 uint8 BUTTON=2 uint8 MOVE_AXIS=3 uint8 MOVE_PLANE=4 uint8 ROTATE_AXIS=5 uint8 MOVE_ROTATE=6 uint8 MOVE_3D=7 uint8 ROTATE_3D=8 uint8 MOVE_ROTATE_3D=9 uint8 interaction_mode bool always_visible Marker[] markers bool independent_marker_orientation string description }}, - TopicSpec InteractiveMarkerFeedback{ message { Header header string client_id string marker_name string control_name uint8 KEEP_ALIVE=0 uint8 POSE_UPDATE=1 uint8 MENU_SELECT=2 uint8 BUTTON_CLICK=3 uint8 MOUSE_DOWN=4 uint8 MOUSE_UP=5 uint8 event_type "geometry_msgs.Pose" pose uint32 menu_entry_id "geometry_msgs.Point" mouse_point bool mouse_point_valid }}, - TopicSpec InteractiveMarkerInit{ message { string server_id uint64 seq_num InteractiveMarker[] markers }}, - TopicSpec InteractiveMarkerPose{ message { Header header "geometry_msgs.Pose" pose string name }}, - TopicSpec InteractiveMarkerUpdate{ message { string server_id uint64 seq_num uint8 KEEP_ALIVE=0 uint8 UPDATE=1 uint8 type InteractiveMarker[] markers InteractiveMarkerPose[] poses string[] erases }}, - TopicSpec Marker{ message { uint8 ARROW=0 uint8 CUBE=1 uint8 SPHERE=2 uint8 CYLINDER=3 uint8 LINE_STRIP=4 uint8 LINE_LIST=5 uint8 CUBE_LIST=6 uint8 SPHERE_LIST=7 uint8 POINTS=8 uint8 TEXT_VIEW_FACING=9 uint8 MESH_RESOURCE=10 uint8 TRIANGLE_LIST=11 uint8 ADD=0 uint8 MODIFY=0 uint8 DELETE=2 uint8 DELETEALL=3 Header header string ns int32 id int32 type int32 action "geometry_msgs.Pose" pose "geometry_msgs.Vector3" scale "std_msgs.ColorRGBA" color duration lifetime bool frame_locked "geometry_msgs.Point"[] points "std_msgs.ColorRGBA"[] colors string text string mesh_resource bool mesh_use_embedded_materials }}, - TopicSpec MarkerArray{ message { Marker[] markers }}, - TopicSpec MenuEntry{ message { uint32 id uint32 parent_id string title string command uint8 FEEDBACK=0 uint8 ROSRUN=1 uint8 ROSLAUNCH=2 uint8 command_type }} - }} -} \ No newline at end of file +actionlib_msgs: + specs: + msg: GoalID + message: + time stamp string id + msg: GoalStatus + message: + GoalID goal_id uint8 status uint8 PENDING=0 uint8 ACTIVE=1 uint8 PREEMPTED=2 uint8 SUCCEEDED=3 uint8 ABORTED=4 uint8 REJECTED=5 uint8 PREEMPTING=6 uint8 RECALLING=7 uint8 RECALLED=8 uint8 LOST=9 string text + msg: GoalStatusArray + message: + Header header GoalStatus[] status_list +diagnostic_msgs: + specs: + msg: DiagnosticArray + message: + Header header DiagnosticStatus[] status + msg: DiagnosticStatus + message: + byte OK=0 byte WARN=1 byte ERROR=2 byte STALE=3 byte level string name string message string hardware_id KeyValue[] values + msg: KeyValue + message: + string key string value + srv: AddDiagnostics + request: + string load_namespace + + response: + bool success string message + srv: SelfTest + request: + + response: + string id byte passed DiagnosticStatus[] status +geometry_msgs: + specs: + msg: Accel + message: + Vector3 linear Vector3 angular + msg: AccelStamped + message: + Header header Accel accel + msg: AccelWithCovariance + message: + Accel accel float64[] covariance + msg: AccelWithCovarianceStamped + message: + Header header AccelWithCovariance accel + msg: Inertia + message: + float64 m "geometry_msgs.Vector3" com float64 ixx float64 ixy float64 ixz float64 iyy float64 iyz float64 izz + msg: InertiaStamped + message: + Header header Inertia inertia + msg: Point + message: + float64 x float64 y float64 z + msg: Point32 + message: + float32 x float32 y float32 z + msg: PointStamped + message: + Header header Point point + msg: Polygon + message: + Point32[] points + msg: PolygonStamped + message: + Header header Polygon polygon + msg: Pose + message: + Point position Quaternion orientation + msg: Pose2D + message: + float64 x float64 y float64 theta + msg: PoseArray + message: + Header header Pose[] poses + msg: PoseStamped + message: + Header header Pose pose + msg: PoseWithCovariance + message: + Pose pose float64[] covariance + msg: PoseWithCovarianceStamped + message: + Header header PoseWithCovariance pose + msg: Quaternion + message: + float64 x float64 y float64 z float64 w + msg: QuaternionStamped + message: + Header header Quaternion quaternion + msg: Transform + message: + Vector3 translation Quaternion rotation + msg: TransformStamped + message: + Header header string child_frame_id Transform transform + msg: Twist + message: + Vector3 linear Vector3 angular + msg: TwistStamped + message: + Header header Twist twist + msg: TwistWithCovariance + message: + Twist twist float64[] covariance + msg: TwistWithCovarianceStamped + message: + Header header TwistWithCovariance twist + msg: Vector3 + message: + float64 x float64 y float64 z + msg: Vector3Stamped + message: + Header header Vector3 vector + msg: Wrench + message: + Vector3 force Vector3 torque + msg: WrenchStamped + message: + Header header Wrench wrench +nav_msgs: + specs: + msg: GetMapAction + message: + GetMapActionGoal action_goal GetMapActionResult action_result GetMapActionFeedback action_feedback + msg: GetMapActionFeedback + message: + Header header "actionlib_msgs.GoalStatus" status GetMapFeedback feedback + msg: GetMapActionGoal + message: + Header header "actionlib_msgs.GoalID" goal_id GetMapGoal goal + msg: GetMapActionResult + message: + Header header "actionlib_msgs.GoalStatus" status GetMapResult result + msg: GetMapFeedback + message: + + msg: GetMapGoal + message: + + msg: GetMapResult + message: + "nav_msgs.OccupancyGrid" map + msg: GridCells + message: + Header header float32 cell_width float32 cell_height "geometry_msgs.Point"[] cells + msg: MapMetaData + message: + time map_load_time float32 resolution uint32 width uint32 height "geometry_msgs.Pose" origin + msg: OccupancyGrid + message: + Header header MapMetaData info int8[] data + msg: Odometry + message: + Header header string child_frame_id "geometry_msgs.PoseWithCovariance" pose "geometry_msgs.TwistWithCovariance" twist + msg: Path + message: + Header header "geometry_msgs.PoseStamped"[] poses + srv: GetMap + request: + + response: + "nav_msgs.OccupancyGrid" map + srv: GetPlan + request: + "geometry_msgs.PoseStamped" start "geometry_msgs.PoseStamped" goal float32 tolerance + + response: + "nav_msgs.Path" plan + srv: LoadMap + request: + string map_url + + response: + uint8 RESULT_SUCCESS=0 uint8 RESULT_MAP_DOES_NOT_EXIST=1 uint8 RESULT_INVALID_MAP_DATA=2 uint8 RESULT_INVALID_MAP_METADATA=3 uint8 RESULT_UNDEFINED_FAILURE=255 "nav_msgs.OccupancyGrid" map uint8 result + srv: SetMap + request: + "nav_msgs.OccupancyGrid" map "geometry_msgs.PoseWithCovarianceStamped" initial_pose + + response: + bool success +sensor_msgs: + specs: + msg: BatteryState + message: + uint8 POWER_SUPPLY_STATUS_UNKNOWN=0 uint8 POWER_SUPPLY_STATUS_CHARGING=1 uint8 POWER_SUPPLY_STATUS_DISCHARGING=2 uint8 POWER_SUPPLY_STATUS_NOT_CHARGING=3 uint8 POWER_SUPPLY_STATUS_FULL=4 uint8 POWER_SUPPLY_HEALTH_UNKNOWN=0 uint8 POWER_SUPPLY_HEALTH_GOOD=1 uint8 POWER_SUPPLY_HEALTH_OVERHEAT=2 uint8 POWER_SUPPLY_HEALTH_DEAD=3 uint8 POWER_SUPPLY_HEALTH_OVERVOLTAGE=4 uint8 POWER_SUPPLY_HEALTH_UNSPEC_FAILURE=5 uint8 POWER_SUPPLY_HEALTH_COLD=6 uint8 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE=7 uint8 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE=8 uint8 POWER_SUPPLY_TECHNOLOGY_UNKNOWN=0 uint8 POWER_SUPPLY_TECHNOLOGY_NIMH=1 uint8 POWER_SUPPLY_TECHNOLOGY_LION=2 uint8 POWER_SUPPLY_TECHNOLOGY_LIPO=3 uint8 POWER_SUPPLY_TECHNOLOGY_LIFE=4 uint8 POWER_SUPPLY_TECHNOLOGY_NICD=5 uint8 POWER_SUPPLY_TECHNOLOGY_LIMN=6 Header header float32 voltage float32 temperature float32 current float32 charge float32 capacity float32 design_capacity float32 percentage uint8 power_supply_status uint8 power_supply_health uint8 power_supply_technology bool present float32[] cell_voltage float32[] cell_temperature string location string serial_number + msg: CameraInfo + message: + Header header uint32 height uint32 width string distortion_model float64[] D float64[] K float64[] R float64[] P uint32 binning_x uint32 binning_y RegionOfInterest roi + msg: ChannelFloat32 + message: + string name float32[] values + msg: CompressedImage + message: + Header header string format uint8[] data + msg: FluidPressure + message: + Header header float64 fluid_pressure float64 variance + msg: Illuminance + message: + Header header float64 illuminance float64 variance + msg: Image + message: + Header header uint32 height uint32 width string encoding uint8 is_bigendian uint32 step uint8[] data + msg: Imu + message: + Header header "geometry_msgs.Quaternion" orientation float64[] orientation_covariance "geometry_msgs.Vector3" angular_velocity float64[] angular_velocity_covariance "geometry_msgs.Vector3" linear_acceleration float64[] linear_acceleration_covariance + msg: JointState + message: + Header header string[] name float64[] position float64[] velocity float64[] effort + msg: Joy + message: + Header header float32[] axes int32[] buttons + msg: JoyFeedback + message: + uint8 TYPE_LED=0 uint8 TYPE_RUMBLE=1 uint8 TYPE_BUZZER=2 uint8 type uint8 id float32 intensity + msg: JoyFeedbackArray + message: + JoyFeedback[] array + msg: LaserEcho + message: + float32[] echoes + msg: LaserScan + message: + Header header float32 angle_min float32 angle_max float32 angle_increment float32 time_increment float32 scan_time float32 range_min float32 range_max float32[] ranges float32[] intensities + msg: MagneticField + message: + Header header "geometry_msgs.Vector3" magnetic_field float64[] magnetic_field_covariance + msg: MultiDOFJointState + message: + Header header string[] joint_names "geometry_msgs.Transform"[] transforms "geometry_msgs.Twist"[] twist "geometry_msgs.Wrench"[] wrench + msg: MultiEchoLaserScan + message: + Header header float32 angle_min float32 angle_max float32 angle_increment float32 time_increment float32 scan_time float32 range_min float32 range_max LaserEcho[] ranges LaserEcho[] intensities + msg: NavSatFix + message: + Header header NavSatStatus status float64 latitude float64 longitude float64 altitude float64[] position_covariance uint8 COVARIANCE_TYPE_UNKNOWN=0 uint8 COVARIANCE_TYPE_APPROXIMATED=1 uint8 COVARIANCE_TYPE_DIAGONAL_KNOWN=2 uint8 COVARIANCE_TYPE_KNOWN=3 uint8 position_covariance_type + msg: NavSatStatus + message: + int8 STATUS_NO_FIX=-1 int8 STATUS_FIX=0 int8 STATUS_SBAS_FIX=1 int8 STATUS_GBAS_FIX=2 int8 status uint16 SERVICE_GPS=1 uint16 SERVICE_GLONASS=2 uint16 SERVICE_COMPASS=4 uint16 SERVICE_GALILEO=8 uint16 service + msg: PointCloud + message: + Header header "geometry_msgs.Point32"[] points ChannelFloat32[] channels + msg: PointCloud2 + message: + Header header uint32 height uint32 width PointField[] fields bool is_bigendian uint32 point_step uint32 row_step uint8[] data bool is_dense + msg: PointField + message: + uint8 INT8=1 uint8 UINT8=2 uint8 INT16=3 uint8 UINT16=4 uint8 INT32=5 uint8 UINT32=6 uint8 FLOAT32=7 uint8 FLOAT64=8 string name uint32 offset uint8 datatype uint32 count + msg: Range + message: + Header header uint8 ULTRASOUND=0 uint8 INFRARED=1 uint8 radiation_type float32 field_of_view float32 min_range float32 max_range float32 range + msg: RegionOfInterest + message: + uint32 x_offset uint32 y_offset uint32 height uint32 width bool do_rectify + msg: RelativeHumidity + message: + Header header float64 relative_humidity float64 variance + msg: Temperature + message: + Header header float64 temperature float64 variance + msg: TimeReference + message: + Header header time time_ref string source + srv: SetCameraInfo + request: + "sensor_msgs.CameraInfo" camera_info + + response: + bool success string status_message +shape_msgs: + specs: + msg: Mesh + message: + MeshTriangle[] triangles "geometry_msgs.Point"[] vertices + msg: MeshTriangle + message: + uint32[] vertex_indices + msg: Plane + message: + float64[] coef + msg: SolidPrimitive + message: + uint8 BOX=1 uint8 SPHERE=2 uint8 CYLINDER=3 uint8 CONE=4 uint8 type float64[] dimensions uint8 BOX_X=0 uint8 BOX_Y=1 uint8 BOX_Z=2 uint8 SPHERE_RADIUS=0 uint8 CYLINDER_HEIGHT=0 uint8 CYLINDER_RADIUS=1 uint8 CONE_HEIGHT=0 uint8 CONE_RADIUS=1 +stereo_msgs: + specs: + msg: DisparityImage + message: + Header header "sensor_msgs.Image" image float32 f float32 T "sensor_msgs.RegionOfInterest" valid_window float32 min_disparity float32 max_disparity float32 delta_d +trajectory_msgs: + specs: + msg: JointTrajectory + message: + Header header string[] joint_names JointTrajectoryPoint[] points + msg: JointTrajectoryPoint + message: + float64[] positions float64[] velocities float64[] accelerations float64[] effort duration time_from_start + msg: MultiDOFJointTrajectory + message: + Header header string[] joint_names MultiDOFJointTrajectoryPoint[] points + msg: MultiDOFJointTrajectoryPoint + message: + "geometry_msgs.Transform"[] transforms "geometry_msgs.Twist"[] velocities "geometry_msgs.Twist"[] accelerations duration time_from_start +visualization_msgs: + specs: + msg: ImageMarker + message: + uint8 CIRCLE=0 uint8 LINE_STRIP=1 uint8 LINE_LIST=2 uint8 POLYGON=3 uint8 POINTS=4 uint8 ADD=0 uint8 REMOVE=1 Header header string ns int32 id int32 type int32 action "geometry_msgs.Point" position float32 scale "std_msgs.ColorRGBA" outline_color uint8 filled "std_msgs.ColorRGBA" fill_color duration lifetime "geometry_msgs.Point"[] points "std_msgs.ColorRGBA"[] outline_colors + msg: InteractiveMarker + message: + Header header "geometry_msgs.Pose" pose string name string description float32 scale MenuEntry[] menu_entries InteractiveMarkerControl[] controls + msg: InteractiveMarkerControl + message: + string name "geometry_msgs.Quaternion" orientation uint8 INHERIT=0 uint8 FIXED=1 uint8 VIEW_FACING=2 uint8 orientation_mode uint8 NONE=0 uint8 MENU=1 uint8 BUTTON=2 uint8 MOVE_AXIS=3 uint8 MOVE_PLANE=4 uint8 ROTATE_AXIS=5 uint8 MOVE_ROTATE=6 uint8 MOVE_3D=7 uint8 ROTATE_3D=8 uint8 MOVE_ROTATE_3D=9 uint8 interaction_mode bool always_visible Marker[] markers bool independent_marker_orientation string description + msg: InteractiveMarkerFeedback + message: + Header header string client_id string marker_name string control_name uint8 KEEP_ALIVE=0 uint8 POSE_UPDATE=1 uint8 MENU_SELECT=2 uint8 BUTTON_CLICK=3 uint8 MOUSE_DOWN=4 uint8 MOUSE_UP=5 uint8 event_type "geometry_msgs.Pose" pose uint32 menu_entry_id "geometry_msgs.Point" mouse_point bool mouse_point_valid + msg: InteractiveMarkerInit + message: + string server_id uint64 seq_num InteractiveMarker[] markers + msg: InteractiveMarkerPose + message: + Header header "geometry_msgs.Pose" pose string name + msg: InteractiveMarkerUpdate + message: + string server_id uint64 seq_num uint8 KEEP_ALIVE=0 uint8 UPDATE=1 uint8 type InteractiveMarker[] markers InteractiveMarkerPose[] poses string[] erases + msg: Marker + message: + uint8 ARROW=0 uint8 CUBE=1 uint8 SPHERE=2 uint8 CYLINDER=3 uint8 LINE_STRIP=4 uint8 LINE_LIST=5 uint8 CUBE_LIST=6 uint8 SPHERE_LIST=7 uint8 POINTS=8 uint8 TEXT_VIEW_FACING=9 uint8 MESH_RESOURCE=10 uint8 TRIANGLE_LIST=11 uint8 ADD=0 uint8 MODIFY=0 uint8 DELETE=2 uint8 DELETEALL=3 Header header string ns int32 id int32 type int32 action "geometry_msgs.Pose" pose "geometry_msgs.Vector3" scale "std_msgs.ColorRGBA" color duration lifetime bool frame_locked "geometry_msgs.Point"[] points "std_msgs.ColorRGBA"[] colors string text string mesh_resource bool mesh_use_embedded_materials + msg: MarkerArray + message: + Marker[] markers + msg: MenuEntry + message: + uint32 id uint32 parent_id string title string command uint8 FEEDBACK=0 uint8 ROSRUN=1 uint8 ROSLAUNCH=2 uint8 command_type diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/basic_msgs/ros_core.ros b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/basic_msgs/ros_core.ros index d12d3dc9d..1d29410ce 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/basic_msgs/ros_core.ros +++ b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/basic_msgs/ros_core.ros @@ -1,40 +1,112 @@ -PackageSet{ - Package std_msgs{ Specs { - TopicSpec Bool{ message { bool data }}, - TopicSpec Byte{ message { byte data }}, - TopicSpec ByteMultiArray{ message { MultiArrayLayout layout byte[] data }}, - TopicSpec ColorRGBA{ message { float32 r float32 g float32 b float32 a }}, - TopicSpec Duration{ message { duration data }}, - TopicSpec Empty{ message { }}, - TopicSpec Float32{ message { float32 data }}, - TopicSpec Float32MultiArray{ message { MultiArrayLayout layout float32[] data }}, - TopicSpec Float64{ message { float64 data }}, - TopicSpec Float64MultiArray{ message { MultiArrayLayout layout float64[] data }}, - TopicSpec Header{ message { uint32 seq time stamp string frame_id }}, - TopicSpec Int16{ message { int16 data }}, - TopicSpec Int16MultiArray{ message { MultiArrayLayout layout int16[] data }}, - TopicSpec Int32{ message { int32 data }}, - TopicSpec Int32MultiArray{ message { MultiArrayLayout layout int32[] data }}, - TopicSpec Int64{ message { int64 data }}, - TopicSpec Int64MultiArray{ message { MultiArrayLayout layout int64[] data }}, - TopicSpec Int8{ message { int8 data }}, - TopicSpec Int8MultiArray{ message { MultiArrayLayout layout int8[] data }}, - TopicSpec MultiArrayDimension{ message { string label uint32 size uint32 stride }}, - TopicSpec MultiArrayLayout{ message { MultiArrayDimension[] dim uint32 data_offset }}, - TopicSpec String{ message { string data }}, - TopicSpec Time{ message { time data }}, - TopicSpec UInt16{ message { uint16 data }}, - TopicSpec UInt16MultiArray{ message { MultiArrayLayout layout uint16[] data }}, - TopicSpec UInt32{ message { uint32 data }}, - TopicSpec UInt32MultiArray{ message { MultiArrayLayout layout uint32[] data }}, - TopicSpec UInt64{ message { uint64 data }}, - TopicSpec UInt64MultiArray{ message { MultiArrayLayout layout uint64[] data }}, - TopicSpec UInt8{ message { uint8 data }}, - TopicSpec UInt8MultiArray{ message { MultiArrayLayout layout uint8[] data }} - }}, - Package std_srvs{ Specs { - ServiceSpec Empty{ request { } response { } }, - ServiceSpec SetBool{ request { bool data } response { bool success string message } }, - ServiceSpec Trigger{ request { } response { bool success string message } } - }} -} \ No newline at end of file +std_msgs: + specs: + msg: Bool + message: + bool data + msg: Byte + message: + byte data + msg: ByteMultiArray + message: + MultiArrayLayout layout byte[] data + msg: ColorRGBA + message: + float32 r float32 g float32 b float32 a + msg: Duration + message: + duration data + msg: Empty + message: + + msg: Float32 + message: + float32 data + msg: Float32MultiArray + message: + MultiArrayLayout layout float32[] data + msg: Float64 + message: + float64 data + msg: Float64MultiArray + message: + MultiArrayLayout layout float64[] data + msg: Header + message: + uint32 seq time stamp string frame_id + msg: Int16 + message: + int16 data + msg: Int16MultiArray + message: + MultiArrayLayout layout int16[] data + msg: Int32 + message: + int32 data + msg: Int32MultiArray + message: + MultiArrayLayout layout int32[] data + msg: Int64 + message: + int64 data + msg: Int64MultiArray + message: + MultiArrayLayout layout int64[] data + msg: Int8 + message: + int8 data + msg: Int8MultiArray + message: + MultiArrayLayout layout int8[] data + msg: MultiArrayDimension + message: + string label uint32 size uint32 stride + msg: MultiArrayLayout + message: + MultiArrayDimension[] dim uint32 data_offset + msg: String + message: + string data + msg: Time + message: + time data + msg: UInt16 + message: + uint16 data + msg: UInt16MultiArray + message: + MultiArrayLayout layout uint16[] data + msg: UInt32 + message: + uint32 data + msg: UInt32MultiArray + message: + MultiArrayLayout layout uint32[] data + msg: UInt64 + message: + uint64 data + msg: UInt64MultiArray + message: + MultiArrayLayout layout uint64[] data + msg: UInt8 + message: + uint8 data + msg: UInt8MultiArray + message: + MultiArrayLayout layout uint8[] data +std_srvs: + specs: + srv: Empty + request: + + response: + srv: SetBool + request: + bool data + + response: + bool success string message + srv: Trigger + request: + + response: + bool success string message diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/components/test_node.componentinterface b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/components/test_node.componentinterface deleted file mode 100644 index cfa66f732..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/components/test_node.componentinterface +++ /dev/null @@ -1,26 +0,0 @@ -ComponentInterface { name test_node - FromRosNode "test_pkg.test_node.test_node" - RosPublishers{ - RosPublisher "scan" { RefPublisher "test_pkg.test_node.test_node.scan"} - } - RosSubscribers{ - RosSubscriber "power_state" { RefSubscriber "test_pkg.test_node.test_node.power_state"} - } - RosSrvServers{ - RosServiceServer "setBool" { RefServer "test_pkg.test_node.test_node.setBool"} - } - RosSrvClients{ - RosServiceClient "init" { RefClient "test_pkg.test_node.test_node.init"} - } - - RosParameters{ - RosParameter "string_test" { RefParameter "test_pkg.test_node.test_node.string_test"}, - RosParameter "bool_tets" { RefParameter "test_pkg.test_node.test_node.bool_tets"}, - RosParameter "array_tets" { RefParameter "test_pkg.test_node.test_node.array_tets"}, - RosParameter "base64_test" { RefParameter "test_pkg.test_node.test_node.base64_test"}, - RosParameter "double_test" { RefParameter "test_pkg.test_node.test_node.double_test"}, - RosParameter "int_test" { RefParameter "test_pkg.test_node.test_node.int_test"}, - RosParameter "list_test" { RefParameter "test_pkg.test_node.test_node.list_test"}, - RosParameter "struc_test" { RefParameter "test_pkg.test_node.test_node.struc_test"} - } -} diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/ros2generator/test_pkg/CMakeLists.txt b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/ros2generator/test_pkg/CMakeLists.txt deleted file mode 100644 index 7a508095f..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/ros2generator/test_pkg/CMakeLists.txt +++ /dev/null @@ -1,26 +0,0 @@ -cmake_minimum_required(VERSION 3.5) -project(test_pkg) - -# Default to C++14 -if(NOT CMAKE_CXX_STANDARD) - set(CMAKE_CXX_STANDARD 14) -endif() - -if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang") - add_compile_options(-Wall -Wextra -Wpedantic) -endif() - -find_package(ament_cmake REQUIRED) -find_package(Boost REQUIRED) -find_package(rclcpp REQUIRED) -find_package(std_srvs REQUIRED) -find_package(sensor_msgs REQUIRED) - -add_executable(test_node src/test_node.cpp) -ament_target_dependencies(test_node rclcpp std_srvs sensor_msgs ) - -install(TARGETS - test_node - DESTINATION lib/${PROJECT_NAME}) - -ament_package() diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/ros2generator/test_pkg/package.xml b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/ros2generator/test_pkg/package.xml deleted file mode 100644 index fdc193692..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/ros2generator/test_pkg/package.xml +++ /dev/null @@ -1,26 +0,0 @@ - - - - test_pkg - 0.0.0 - This package contains the implementation of the node test_node - Jane Doe - Jane Doe - Apache 2.0 - - ament_cmake - - boost - rclcpp - std_srvs - sensor_msgs - - ament_lint_auto - ament_lint_common - - - ament_cmake - - diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/ros2generator/test_pkg/src/test_node.cpp b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/ros2generator/test_pkg/src/test_node.cpp deleted file mode 100644 index 756054129..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/ros2generator/test_pkg/src/test_node.cpp +++ /dev/null @@ -1,121 +0,0 @@ -#include -#include -#include -#include -#include - -#include "rclcpp/rclcpp.hpp" -#include "rcutils/cmdline_parser.h" -#include -#include -#include -#include - -using namespace std::chrono_literals; -using std::placeholders::_1; -using std::placeholders::_2; -using std::placeholders::_3; - -void print_usage() -{ - printf("Usage for test_node app:\n"); - printf("..... \n"); - printf("..... \n"); - printf("..... \n"); -} - -class test_node : public rclcpp::Node { - public: - test_node() : Node("test_node") { - this->declare_parameter("string_test", "test"); - this->get_parameter("string_test", string_test_); - this->declare_parameter("bool_tets"); - this->get_parameter("bool_tets", bool_tets_); - this->declare_parameter("array_tets"); - this->get_parameter("array_tets", array_tets_); - this->declare_parameter("double_test"); - this->get_parameter("double_test", double_test_); - this->declare_parameter("int_test"); - this->get_parameter("int_test", int_test_); - this->declare_parameter("struc_test.first_element"); - this->get_parameter("struc_test.first_element", struc_test_first_element_); - - this->declare_parameter("struc_test.second_element"); - this->get_parameter("struc_test.second_element", struc_test_second_element_); - - this->declare_parameter("struc_test.third_element"); - this->get_parameter("struc_test.third_element", struc_test_third_element_); - - this->declare_parameter("struc_test.last_element.hola"); - this->get_parameter("struc_test.last_element.hola", struc_test_last_element_hola_); - - this->declare_parameter("struc_test.last_element.what"); - this->get_parameter("struc_test.last_element.what", struc_test_last_element_what_); - - scan_ = this->create_publisher("scan",10); - power_state_ = this->create_subscription("power_state", 10, std::bind(&test_node::power_state_callback, this, _1)); - init_ = this->create_client("init"); - setBool_ = this->create_service("setBool", std::bind(&test_node::setBool_handle, this, _1, _2, _3)); - - timer_ = this->create_wall_timer(500ms, std::bind(&test_node::timer_callback, this)); - - // Service client - while (!init_->wait_for_service(std::chrono::seconds(10))){ - RCLCPP_ERROR(this->get_logger(), "Client interrupted while waiting for service '%s' to appear.", "init"); - } - auto request = std::make_shared(); - // request-> ... = ....; - auto result_future = init_->async_send_request(request); - auto result = result_future.get(); - RCLCPP_INFO(this->get_logger(), "Service called, service: '%s'", "init"); - } - - private: - std::string string_test_; - bool bool_tets_; - std::vector array_tets_; - double double_test_; - int int_test_; - int struc_test_first_element_; - std::vector struc_test_second_element_; - std::string struc_test_third_element_; - int struc_test_last_element_hola_; - std::string struc_test_last_element_what_; - - // Subscriber callback - void power_state_callback(const sensor_msgs::msg::BatteryState::SharedPtr msg) const { - RCLCPP_INFO(this->get_logger(), "power_state topic got a message", msg); - } - - rclcpp::Subscription::SharedPtr power_state_ ; - rclcpp::Publisher::SharedPtr scan_; - // Timer Callback - void timer_callback(){ - auto scan_msg = sensor_msgs::msg::LaserScan(); - //scan_msg = ... - scan_->publish(scan_msg); - RCLCPP_INFO(this->get_logger(), "scan publisher active"); - } - rclcpp::TimerBase::SharedPtr timer_; - - rclcpp::Client::SharedPtr init_; - - // Service Handler - void setBool_handle( const std::shared_ptr request_header, - const std::shared_ptr request_, - const std::shared_ptr response_){ - (void)request_header; - (void)request_; - (void)response_; - RCLCPP_INFO( this->get_logger(), "trigger service '%s'","setBool"); - } - rclcpp::Service::SharedPtr setBool_; -}; - -int main(int argc, char * argv[]) -{ - rclcpp::init(argc, argv); - rclcpp::spin(std::make_shared()); - rclcpp::shutdown(); - return 0; -} diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/rosgenerator/test_pkg/CMakeLists.txt b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/rosgenerator/test_pkg/CMakeLists.txt deleted file mode 100644 index b9de24ae5..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/rosgenerator/test_pkg/CMakeLists.txt +++ /dev/null @@ -1,23 +0,0 @@ -cmake_minimum_required(VERSION 3.0.2) -project(test_pkg) - -find_package(catkin REQUIRED COMPONENTS roscpp std_srvs sensor_msgs ) - -catkin_package( - CATKIN_DEPENDS roscpp std_srvs sensor_msgs -) - -### Build ### - -include_directories(${catkin_INCLUDE_DIRS}) - -add_executable(test_node src/test_node.cpp) -add_dependencies(test_node ${catkin_EXPORTED_TARGETS}) -target_link_libraries(test_node ${catkin_LIBRARIES}) - -### Install ### -install(TARGETS test_node - ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} - LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} - RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} -) diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/rosgenerator/test_pkg/package.xml b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/rosgenerator/test_pkg/package.xml deleted file mode 100644 index a548026ca..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/rosgenerator/test_pkg/package.xml +++ /dev/null @@ -1,20 +0,0 @@ - - - - test_pkg - 0.0.0 - This package contains the implementation of the node test_node - Jane Doe - Jane Doe - Apache 2.0 - - catkin - - boost - roscpp - std_srvs - sensor_msgs - - diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/rosgenerator/test_pkg/src/test_node.cpp b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/rosgenerator/test_pkg/src/test_node.cpp deleted file mode 100644 index 7a534c048..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/rosgenerator/test_pkg/src/test_node.cpp +++ /dev/null @@ -1,50 +0,0 @@ -#include -#include -#include -#include -#include - -bool setBool_cb (std_srvs::SetBool::Request &req, std_srvs::SetBool::Response &res){ - return true; -} -void power_state_cb (const sensor_msgs::BatteryState msg){} - - -int main(int argc, char **argv) -{ - ros::init(argc, argv, "test_node"); - ros::NodeHandle n; - std::string string_test_; - n.param("string_test", string_test_, "test"); - bool bool_tets_; - n.param("bool_tets", bool_tets_); - std::vector array_tets_; - n.param("array_tets", array_tets_); - double double_test_; - n.param("double_test", double_test_); - int int_test_; - n.param("int_test", int_test_); - int struc_test_first_element_; - n.param("struc_test/first_element", struc_test_first_element_); - - std::vector struc_test_second_element_; - n.param("struc_test/second_element", struc_test_second_element_); - - std::string struc_test_third_element_; - n.param("struc_test/third_element", struc_test_third_element_); - - int struc_test_last_element_hola_; - n.param("struc_test/last_element/hola", struc_test_last_element_hola_); - - std::string struc_test_last_element_what_; - n.param("struc_test/last_element/what", struc_test_last_element_what_); - - ros::Publisher scan_pub = n.advertise("scan", 10); - ros::Subscriber power_state = n.subscribe("power_state", 10, power_state_cb); - ros::ServiceServer setBool = n.advertiseService("setBool", setBool_cb); - ros::ServiceClient init = n.serviceClient("init"); - - ros::spin(); - - return 0; -} diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/test.ros b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/test.ros deleted file mode 100644 index 0920a81e6..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/test.ros +++ /dev/null @@ -1,27 +0,0 @@ -PackageSet { - CatkinPackage test_pkg { - Artifact test_node { Node { name test_node - ServiceServers { - ServiceServer {name setBool service "std_srvs.SetBool"}} - Publishers { - Publisher { name scan message "sensor_msgs.LaserScan" }} - Subscribers { - Subscriber { name power_state message "sensor_msgs.BatteryState"}} - ServiceClients { - ServiceClient { name init service "std_srvs.Trigger"}} - Parameters { - Parameter { name string_test type String default test}, - Parameter { name bool_tets type Boolean }, - Parameter { name array_tets type Array {type String}}, - Parameter { name base64_test type Base64}, - Parameter { name double_test type Double}, - Parameter {name int_test type Integer}, - Parameter {name list_test type List {Integer,Integer,String}}, - Parameter {name struc_test type Struct - {first_element Integer , - second_element List { String, String}, - third_element String , - last_element Struct { hola Integer, what String}} - } - }} -}}} diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/test_error.ros b/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/test_error.ros deleted file mode 100644 index a205f36ea..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/resources/test_error.ros +++ /dev/null @@ -1,27 +0,0 @@ -PackageSet { - CatkinPackage test_pkg { - Artifact testNode { Node { name testNode - ServiceServers { - ServiceServer {name setBool service "std_srvs.SetBool"}} - Publishers { - Publisher { name scan message "sensor_msgs.LaserScan" }} - Subscribers { - Subscriber { name power_state message "sensor_msgs.BatteryState"}} - ServiceClients { - ServiceClient { name init service "std_srvs.Trigger"}} - Parameters { - Parameter { name string_test type String default test}, - Parameter { name bool_tets type Boolean }, - Parameter { name array_tets type Array {type String}}, - Parameter { name base64_test type Base64}, - Parameter { name double_test type Double}, - Parameter {name int_test type Integer}, - Parameter {name list_test type List {Integer,Integer,String}}, - Parameter {name struc_test type Struct - {first_element Integer , - second_element List { Integer, String}, - third_element String , - last_element Struct { hola Integer, what String}} - } - }} -}}} diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosGeneratorTest.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosGeneratorTest.xtend index 202323be3..333709494 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosGeneratorTest.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosGeneratorTest.xtend @@ -1,96 +1,96 @@ -package de.fraunhofer.ipa.ros.tests - -import com.google.inject.Inject -import org.eclipse.xtext.testing.InjectWith -import org.eclipse.xtext.testing.XtextRunner -import org.junit.Assert -import org.junit.Test -import org.junit.runner.RunWith -import de.fraunhofer.ipa.roscode.generator.RosCodeGenerator -import org.eclipse.xtext.testing.util.ParseHelper -import ros.PackageSet -import org.eclipse.xtext.generator.InMemoryFileSystemAccess -import org.eclipse.xtext.generator.GeneratorContext -import de.fraunhofer.ipa.roscode.generator.CustomOutputProvider -import de.fraunhofer.ipa.roscode.generator.Ros2CodeGenerator -import java.nio.file.Files -import java.nio.file.Paths -import de.fraunhofer.ipa.ros.generator.RosGenerator -import de.fraunhofer.ipa.ros.generator.CICustomOutputProvider - -@RunWith(XtextRunner) -@InjectWith(RosInjectorProvider) -class RosGeneratorTest { - @Inject - RosCodeGenerator rosGenerator - - @Inject - Ros2CodeGenerator ros2Generator - - @Inject - RosGenerator CIGenerator - - @Inject - ParseHelper parseHelper - - @Inject - RosTestingUtils rosTestingUtils - - String RESOURCES_BASE_DIR = 'resources' - - @Test - def void testGeneratedRosCode() { - - val resourceSet = rosTestingUtils.getMessagesResourceSet - val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test.ros'))) - val model = parseHelper.parse(fileContent, resourceSet) - - val fsa = new InMemoryFileSystemAccess - rosGenerator.doGenerate(model.eResource, fsa, new GeneratorContext) - Assert.assertTrue(fsa.textFiles.containsKey(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/package.xml")) - Assert.assertEquals( - new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'rosgenerator/test_pkg/src/','test_node.cpp'))).trim, - fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/src/test_node.cpp").toString.trim) - Assert.assertEquals( - new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'rosgenerator/test_pkg/','CMakeLists.txt'))).trim, - fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/CMakeLists.txt").toString.trim) - Assert.assertEquals( - new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'rosgenerator/test_pkg/','package.xml'))).trim, - fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/package.xml").toString.trim) - } - - @Test - def void testGeneratedRos2Code() { - val resourceSet = rosTestingUtils.getMessagesResourceSet - val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test.ros'))) - val model = parseHelper.parse(fileContent, resourceSet) - - val fsa = new InMemoryFileSystemAccess - ros2Generator.doGenerate(model.eResource, fsa, new GeneratorContext) - Assert.assertTrue(fsa.textFiles.containsKey(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/package.xml")) - Assert.assertEquals( - new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'ros2generator/test_pkg/src/','test_node.cpp'))).trim, - fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/src/test_node.cpp").toString.trim) - Assert.assertEquals( - new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'ros2generator/test_pkg/','CMakeLists.txt'))).trim, - fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/CMakeLists.txt").toString.trim) - Assert.assertEquals( - new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'ros2generator/test_pkg/','package.xml'))).trim, - fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/package.xml").toString.trim) - } - - @Test - def void testGeneratedCI() { - val resourceSet = rosTestingUtils.getMessagesResourceSet - val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test.ros'))) - val model = parseHelper.parse(fileContent, resourceSet) - - val fsa = new InMemoryFileSystemAccess - CIGenerator.doGenerate(model.eResource, fsa, new GeneratorContext) - Assert.assertTrue(fsa.textFiles.containsKey(CICustomOutputProvider::COM_OUTPUT + "test_node.componentinterface")) - Assert.assertEquals( - new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'components', 'test_node.componentinterface'))).trim, - fsa.textFiles.get(CICustomOutputProvider::COM_OUTPUT + "test_node.componentinterface").toString.trim) - } - -} +//package de.fraunhofer.ipa.ros.tests +// +//import com.google.inject.Inject +//import org.eclipse.xtext.testing.InjectWith +//import org.eclipse.xtext.testing.XtextRunner +//import org.junit.Assert +//import org.junit.Test +//import org.junit.runner.RunWith +//import de.fraunhofer.ipa.roscode.generator.RosCodeGenerator +//import org.eclipse.xtext.testing.util.ParseHelper +//import ros.PackageSet +//import org.eclipse.xtext.generator.InMemoryFileSystemAccess +//import org.eclipse.xtext.generator.GeneratorContext +//import de.fraunhofer.ipa.roscode.generator.CustomOutputProvider +//import de.fraunhofer.ipa.roscode.generator.Ros2CodeGenerator +//import java.nio.file.Files +//import java.nio.file.Paths +//import de.fraunhofer.ipa.ros.generator.RosGenerator +//import de.fraunhofer.ipa.ros.generator.CICustomOutputProvider +// +//@RunWith(XtextRunner) +//@InjectWith(RosInjectorProvider) +//class RosGeneratorTest { +// @Inject +// RosCodeGenerator rosGenerator +// +// @Inject +// Ros2CodeGenerator ros2Generator +// +// @Inject +// RosGenerator CIGenerator +// +// @Inject +// ParseHelper parseHelper +// +// @Inject +// RosTestingUtils rosTestingUtils +// +// String RESOURCES_BASE_DIR = 'resources' +// +//// @Test +//// def void testGeneratedRosCode() { +//// +//// val resourceSet = rosTestingUtils.getMessagesResourceSet +//// val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test.ros'))) +//// val model = parseHelper.parse(fileContent, resourceSet) +//// +//// val fsa = new InMemoryFileSystemAccess +//// rosGenerator.doGenerate(model.eResource, fsa, new GeneratorContext) +//// Assert.assertTrue(fsa.textFiles.containsKey(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/package.xml")) +//// Assert.assertEquals( +//// new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'rosgenerator/test_pkg/src/','test_node.cpp'))).trim, +//// fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/src/test_node.cpp").toString.trim) +//// Assert.assertEquals( +//// new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'rosgenerator/test_pkg/','CMakeLists.txt'))).trim, +//// fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/CMakeLists.txt").toString.trim) +//// Assert.assertEquals( +//// new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'rosgenerator/test_pkg/','package.xml'))).trim, +//// fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/package.xml").toString.trim) +//// } +//// +//// @Test +//// def void testGeneratedRos2Code() { +//// val resourceSet = rosTestingUtils.getMessagesResourceSet +//// val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test.ros'))) +//// val model = parseHelper.parse(fileContent, resourceSet) +//// +//// val fsa = new InMemoryFileSystemAccess +//// ros2Generator.doGenerate(model.eResource, fsa, new GeneratorContext) +//// Assert.assertTrue(fsa.textFiles.containsKey(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/package.xml")) +//// Assert.assertEquals( +//// new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'ros2generator/test_pkg/src/','test_node.cpp'))).trim, +//// fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/src/test_node.cpp").toString.trim) +//// Assert.assertEquals( +//// new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'ros2generator/test_pkg/','CMakeLists.txt'))).trim, +//// fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/CMakeLists.txt").toString.trim) +//// Assert.assertEquals( +//// new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'ros2generator/test_pkg/','package.xml'))).trim, +//// fsa.textFiles.get(CustomOutputProvider::DEFAULT_OUTPUT + "test_pkg/package.xml").toString.trim) +//// } +//// +//// @Test +//// def void testGeneratedCI() { +//// val resourceSet = rosTestingUtils.getMessagesResourceSet +//// val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test.ros'))) +//// val model = parseHelper.parse(fileContent, resourceSet) +//// +//// val fsa = new InMemoryFileSystemAccess +//// CIGenerator.doGenerate(model.eResource, fsa, new GeneratorContext) +//// Assert.assertTrue(fsa.textFiles.containsKey(CICustomOutputProvider::COM_OUTPUT + "test_node.componentinterface")) +//// Assert.assertEquals( +//// new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'components', 'test_node.componentinterface'))).trim, +//// fsa.textFiles.get(CICustomOutputProvider::COM_OUTPUT + "test_node.componentinterface").toString.trim) +//// } +// +//} diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosParsingTest.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosParsingTest.xtend index d1ee18aac..07f91dfae 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosParsingTest.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosParsingTest.xtend @@ -19,11 +19,11 @@ import ros.PackageSet class RosParsingTest { @Inject ParseHelper parseHelper - String RESOURCES_BASE_DIR = 'resources' + String RESOURCES_BASE_DIR = 'resources/basic_msgs' @Test def void loadModel() { - val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test.ros'))) + val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'common_msgs.ros'))) val result = parseHelper.parse(fileContent) Assert.assertNotNull(result) val errors = result.eResource.errors @@ -32,13 +32,12 @@ class RosParsingTest { @Test def void parseDomainmodel() { - val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test.ros'))) + val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'ros_core.ros'))) val model = parseHelper.parse(fileContent) - val packageName = model.package.get(0).name - val nodeName = model.package.get(0).artifact.get(0).node.name - Assert.assertEquals(packageName, "test_pkg") - Assert.assertEquals(nodeName, "test_node") - + val packageName1 = model.package.get(0).name + Assert.assertEquals(packageName1, "std_msgs") + val packageName2 = model.package.get(1).name + Assert.assertEquals(packageName2, "std_srvs") } } diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosTestingUtils.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosTestingUtils.xtend index 189164925..0581ca26a 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosTestingUtils.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosTestingUtils.xtend @@ -1,46 +1,46 @@ -package de.fraunhofer.ipa.ros.tests - -import com.google.inject.Inject -import com.google.inject.Provider -import org.eclipse.emf.common.util.URI -import org.eclipse.emf.ecore.resource.ResourceSet -import org.eclipse.xtext.resource.XtextResourceSet -import org.eclipse.xtext.testing.InjectWith -import org.eclipse.xtext.util.StringInputStream -import java.nio.file.Files -import java.nio.file.Paths - -@InjectWith(RosInjectorProvider) -class RosTestingUtils { - - @Inject - Provider resourceSetProvider - - String RESOURCES_BASE_DIR = 'resources' - - - def ResourceSet getMessagesResourceSet() { - val resourceSet = resourceSetProvider.get - val fileContent_core_msgs = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'basic_msgs', 'ros_core.ros'))) - val fileContent_common_msgs = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'basic_msgs', 'common_msgs.ros'))) - - val messages = resourceSet.createResource(URI.createURI("msgs.ros")) - messages.load(new StringInputStream('''PackageSet{ - Package sensor_msgs{ Specs { - TopicSpec LaserScan{ message { Header header float32 angle_min float32 angle_max float32 angle_increment float32 time_increment float32 scan_time float32 range_min float32 range_max float32[] ranges float32[] intensities }}, - TopicSpec BatteryState{ message { uint8 POWER_SUPPLY_STATUS_UNKNOWN=0 uint8 POWER_SUPPLY_STATUS_CHARGING=1 uint8 POWER_SUPPLY_STATUS_DISCHARGING=2 uint8 POWER_SUPPLY_STATUS_NOT_CHARGING=3 uint8 POWER_SUPPLY_STATUS_FULL=4 uint8 POWER_SUPPLY_HEALTH_UNKNOWN=0 uint8 POWER_SUPPLY_HEALTH_GOOD=1 uint8 POWER_SUPPLY_HEALTH_OVERHEAT=2 uint8 POWER_SUPPLY_HEALTH_DEAD=3 uint8 POWER_SUPPLY_HEALTH_OVERVOLTAGE=4 uint8 POWER_SUPPLY_HEALTH_UNSPEC_FAILURE=5 uint8 POWER_SUPPLY_HEALTH_COLD=6 uint8 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE=7 uint8 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE=8 uint8 POWER_SUPPLY_TECHNOLOGY_UNKNOWN=0 uint8 POWER_SUPPLY_TECHNOLOGY_NIMH=1 uint8 POWER_SUPPLY_TECHNOLOGY_LION=2 uint8 POWER_SUPPLY_TECHNOLOGY_LIPO=3 uint8 POWER_SUPPLY_TECHNOLOGY_LIFE=4 uint8 POWER_SUPPLY_TECHNOLOGY_NICD=5 uint8 POWER_SUPPLY_TECHNOLOGY_LIMN=6 Header header float32 voltage float32 current float32 charge float32 capacity float32 design_capacity float32 percentage uint8 power_supply_status uint8 power_supply_health uint8 power_supply_technology bool present float32[] cell_voltage string location string serial_number }} - - }}, - Package std_srvs{ Specs { - ServiceSpec SetBool{ request { bool data } response { bool success string message } }, - ServiceSpec Trigger{ request { } response { bool success string message } } - }} - }'''), emptyMap) - messages.load(new StringInputStream(fileContent_common_msgs), emptyMap) - messages.load(new StringInputStream(fileContent_core_msgs), emptyMap) - - - return resourceSet - } - -} \ No newline at end of file +//package de.fraunhofer.ipa.ros.tests +// +//import com.google.inject.Inject +//import com.google.inject.Provider +//import org.eclipse.emf.common.util.URI +//import org.eclipse.emf.ecore.resource.ResourceSet +//import org.eclipse.xtext.resource.XtextResourceSet +//import org.eclipse.xtext.testing.InjectWith +//import org.eclipse.xtext.util.StringInputStream +//import java.nio.file.Files +//import java.nio.file.Paths +// +//@InjectWith(RosInjectorProvider) +//class RosTestingUtils { +// +// @Inject +// Provider resourceSetProvider +// +// String RESOURCES_BASE_DIR = 'resources' +// +// +//// def ResourceSet getMessagesResourceSet() { +//// val resourceSet = resourceSetProvider.get +//// val fileContent_core_msgs = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'basic_msgs', 'ros_core.ros'))) +//// val fileContent_common_msgs = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'basic_msgs', 'common_msgs.ros'))) +//// +//// val messages = resourceSet.createResource(URI.createURI("msgs.ros")) +//// messages.load(new StringInputStream('''PackageSet{ +//// Package sensor_msgs{ Specs { +//// TopicSpec LaserScan{ message { Header header float32 angle_min float32 angle_max float32 angle_increment float32 time_increment float32 scan_time float32 range_min float32 range_max float32[] ranges float32[] intensities }}, +//// TopicSpec BatteryState{ message { uint8 POWER_SUPPLY_STATUS_UNKNOWN=0 uint8 POWER_SUPPLY_STATUS_CHARGING=1 uint8 POWER_SUPPLY_STATUS_DISCHARGING=2 uint8 POWER_SUPPLY_STATUS_NOT_CHARGING=3 uint8 POWER_SUPPLY_STATUS_FULL=4 uint8 POWER_SUPPLY_HEALTH_UNKNOWN=0 uint8 POWER_SUPPLY_HEALTH_GOOD=1 uint8 POWER_SUPPLY_HEALTH_OVERHEAT=2 uint8 POWER_SUPPLY_HEALTH_DEAD=3 uint8 POWER_SUPPLY_HEALTH_OVERVOLTAGE=4 uint8 POWER_SUPPLY_HEALTH_UNSPEC_FAILURE=5 uint8 POWER_SUPPLY_HEALTH_COLD=6 uint8 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE=7 uint8 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE=8 uint8 POWER_SUPPLY_TECHNOLOGY_UNKNOWN=0 uint8 POWER_SUPPLY_TECHNOLOGY_NIMH=1 uint8 POWER_SUPPLY_TECHNOLOGY_LION=2 uint8 POWER_SUPPLY_TECHNOLOGY_LIPO=3 uint8 POWER_SUPPLY_TECHNOLOGY_LIFE=4 uint8 POWER_SUPPLY_TECHNOLOGY_NICD=5 uint8 POWER_SUPPLY_TECHNOLOGY_LIMN=6 Header header float32 voltage float32 current float32 charge float32 capacity float32 design_capacity float32 percentage uint8 power_supply_status uint8 power_supply_health uint8 power_supply_technology bool present float32[] cell_voltage string location string serial_number }} +//// +//// }}, +//// Package std_srvs{ Specs { +//// ServiceSpec SetBool{ request { bool data } response { bool success string message } }, +//// ServiceSpec Trigger{ request { } response { bool success string message } } +//// }} +//// }'''), emptyMap) +//// messages.load(new StringInputStream(fileContent_common_msgs), emptyMap) +//// messages.load(new StringInputStream(fileContent_core_msgs), emptyMap) +//// +//// +//// return resourceSet +//// } +// +//} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosValidationTest.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosValidationTest.xtend index 50fc61c3f..c19f4b5cf 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosValidationTest.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.tests/src/de/fraunhofer/ipa/ros/tests/RosValidationTest.xtend @@ -1,61 +1,61 @@ -package de.fraunhofer.ipa.ros.tests - -import com.google.inject.Inject -import org.eclipse.xtext.testing.InjectWith -import org.eclipse.xtext.testing.XtextRunner -import org.eclipse.xtext.testing.util.ParseHelper -import org.junit.Assert -import org.junit.Test -import org.junit.runner.RunWith -import ros.PackageSet -import org.eclipse.xtext.testing.validation.ValidationTestHelper -import org.eclipse.xtext.diagnostics.Diagnostic -import ros.RosPackage -import de.fraunhofer.ipa.ros.validation.RosValidator -import java.nio.file.Files -import java.nio.file.Paths - -@RunWith(XtextRunner) -@InjectWith(RosInjectorProvider) -class RosValidationTest { - - @Inject - ParseHelper parseHelper - - @Inject - ValidationTestHelper validationTester - - @Inject - RosTestingUtils rosTestingUtils - - String RESOURCES_BASE_DIR = 'resources' - - @Test - def void successfulValidationTest(){ - val resourceSet = rosTestingUtils.getMessagesResourceSet - val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test.ros'))) - val model = parseHelper.parse(fileContent, resourceSet) - Assert.assertNotNull(model) - validationTester.assertNoErrors(model) - } - - @Test - def void validationErrorsTest(){ - //val resourceSet = rosTestingUtils.getMessagesResourceSet - val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test_error.ros'))) - val model = parseHelper.parse(fileContent)//, resourceSet) - - Assert.assertNotNull(model) - - // Assert that the validation fails if the needed messages are not present - validationTester.assertWarning(model, RosPackage.Literals.ARTIFACT, RosValidator::INVALID_NAME) - validationTester.assertWarning(model, RosPackage.Literals.NODE, RosValidator::INVALID_NAME) - - // Assert that the custom validation rules are applied - validationTester.assertError(model, RosPackage.Literals.PUBLISHER, Diagnostic.LINKING_DIAGNOSTIC) - validationTester.assertError(model, RosPackage.Literals.SERVICE_SERVER, Diagnostic.LINKING_DIAGNOSTIC) - } - - - -} \ No newline at end of file +//package de.fraunhofer.ipa.ros.tests +// +//import com.google.inject.Inject +//import org.eclipse.xtext.testing.InjectWith +//import org.eclipse.xtext.testing.XtextRunner +//import org.eclipse.xtext.testing.util.ParseHelper +//import org.junit.Assert +//import org.junit.Test +//import org.junit.runner.RunWith +//import ros.PackageSet +//import org.eclipse.xtext.testing.validation.ValidationTestHelper +//import org.eclipse.xtext.diagnostics.Diagnostic +//import ros.RosPackage +//import de.fraunhofer.ipa.ros.validation.RosValidator +//import java.nio.file.Files +//import java.nio.file.Paths +// +//@RunWith(XtextRunner) +//@InjectWith(RosInjectorProvider) +//class RosValidationTest { +// +// @Inject +// ParseHelper parseHelper +// +// @Inject +// ValidationTestHelper validationTester +// +// @Inject +// RosTestingUtils rosTestingUtils +// +// String RESOURCES_BASE_DIR = 'resources' +// +//// @Test +//// def void successfulValidationTest(){ +//// val resourceSet = rosTestingUtils.getMessagesResourceSet +//// val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test.ros'))) +//// val model = parseHelper.parse(fileContent, resourceSet) +//// Assert.assertNotNull(model) +//// validationTester.assertNoErrors(model) +//// } +//// +//// @Test +//// def void validationErrorsTest(){ +//// //val resourceSet = rosTestingUtils.getMessagesResourceSet +//// val fileContent = new String(Files.readAllBytes(Paths.get(RESOURCES_BASE_DIR, 'test_error.ros'))) +//// val model = parseHelper.parse(fileContent)//, resourceSet) +//// +//// Assert.assertNotNull(model) +//// +//// // Assert that the validation fails if the needed messages are not present +//// validationTester.assertWarning(model, RosPackage.Literals.ARTIFACT, RosValidator::INVALID_NAME) +//// validationTester.assertWarning(model, RosPackage.Literals.NODE, RosValidator::INVALID_NAME) +//// +//// // Assert that the custom validation rules are applied +//// validationTester.assertError(model, RosPackage.Literals.PUBLISHER, Diagnostic.LINKING_DIAGNOSTIC) +//// validationTester.assertError(model, RosPackage.Literals.SERVICE_SERVER, Diagnostic.LINKING_DIAGNOSTIC) +//// } +// +// +// +//} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src-gen/de/fraunhofer/ipa/ros/ui/AbstractRosUiModule.java b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src-gen/de/fraunhofer/ipa/ros/ui/AbstractRosUiModule.java index a8a785760..38bb46966 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src-gen/de/fraunhofer/ipa/ros/ui/AbstractRosUiModule.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src-gen/de/fraunhofer/ipa/ros/ui/AbstractRosUiModule.java @@ -8,7 +8,7 @@ import com.google.inject.name.Names; import de.fraunhofer.ipa.ros.ide.contentassist.antlr.PartialRosContentAssistParser; import de.fraunhofer.ipa.ros.ide.contentassist.antlr.RosParser; -import de.fraunhofer.ipa.ros.ide.contentassist.antlr.internal.InternalRosLexer; +import de.fraunhofer.ipa.ros.ide.contentassist.antlr.lexer.InternalRosLexer; import de.fraunhofer.ipa.ros.ui.contentassist.RosProposalProvider; import de.fraunhofer.ipa.ros.ui.labeling.RosDescriptionLabelProvider; import de.fraunhofer.ipa.ros.ui.labeling.RosLabelProvider; @@ -29,6 +29,8 @@ 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; @@ -110,7 +112,7 @@ public void configureContentAssistLexer(Binder binder) { public void configureHighlightingLexer(Binder binder) { binder.bind(org.eclipse.xtext.parser.antlr.Lexer.class) .annotatedWith(Names.named(LexerIdeBindings.HIGHLIGHTING)) - .to(de.fraunhofer.ipa.ros.parser.antlr.internal.InternalRosLexer.class); + .to(de.fraunhofer.ipa.ros.parser.antlr.lexer.InternalRosLexer.class); } // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 @@ -135,6 +137,11 @@ public void configureContentAssistLexerProvider(Binder binder) { binder.bind(InternalRosLexer.class).toProvider(LexerProvider.create(InternalRosLexer.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 bindPrefixMatcher() { return FQNPrefixMatcher.class; diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src-gen/de/fraunhofer/ipa/ros/ui/contentassist/AbstractRosProposalProvider.java b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src-gen/de/fraunhofer/ipa/ros/ui/contentassist/AbstractRosProposalProvider.java index d95c7a801..0eb1d2f16 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src-gen/de/fraunhofer/ipa/ros/ui/contentassist/AbstractRosProposalProvider.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src-gen/de/fraunhofer/ipa/ros/ui/contentassist/AbstractRosProposalProvider.java @@ -31,13 +31,7 @@ public void completePackage_Impl_FromGitRepo(EObject model, Assignment assignmen public void completePackage_Impl_Spec(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completePackage_Impl_Artifact(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) { + public void completePackage_Impl_Dependency(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } public void completeCatkinPackage_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { @@ -46,13 +40,10 @@ public void completeCatkinPackage_Name(EObject model, Assignment assignment, Con public void completeCatkinPackage_FromGitRepo(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 completeCatkinPackage_Spec(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeCatkinPackage_Artifact(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) { + public void completeCatkinPackage_Dependency(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } public void completeAmentPackage_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { @@ -61,78 +52,72 @@ public void completeAmentPackage_Name(EObject model, Assignment assignment, Cont public void completeAmentPackage_FromGitRepo(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeAmentPackage_Dependency(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeAmentPackage_Artifact(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeAmentPackage_Spec(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeAmentPackage_Dependency(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeAmentPackage_Artifact(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeArtifact_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeServiceSpec_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeArtifact_Node(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeServiceSpec_Request(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeNode_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeServiceSpec_Response(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeNode_Publisher(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeTopicSpec_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { - completeRuleCall(((RuleCall)((Alternatives)assignment.getTerminal()).getElements().get(0)), context, acceptor); - // subclasses may override - // subclasses may override - } - public void completeTopicSpec_Message(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeNode_Subscriber(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeActionSpec_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeNode_Serviceserver(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeActionSpec_Goal(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeNode_Serviceclient(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeActionSpec_Result(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeNode_Actionserver(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeActionSpec_Feedback(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeNode_Actionclient(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeMessageDefinition_MessagePart(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeNode_Parameter(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 completeTopicSpec_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)((Alternatives)assignment.getTerminal()).getElements().get(0)), context, acceptor); + // subclasses may override + // subclasses may override } - public void completeNode_Serviceserver(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeTopicSpec_Message(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) { + public void completeServiceSpec_Name(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) { + public void completeServiceSpec_Request(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeNode_Serviceclient(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeServiceSpec_Response(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeNode_Actionserver(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeActionSpec_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeNode_Actionclient(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeActionSpec_Goal(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) { + public void completeActionSpec_Result(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeServiceServer_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeActionSpec_Feedback(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeServiceServer_Service(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { - lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); - } - public void completeServiceServer_Namespace(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeMessageDefinition_MessagePart(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) { @@ -153,6 +138,15 @@ public void completeSubscriber_Message(EObject model, Assignment assignment, Con public void completeSubscriber_Namespace(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } + public void completeServiceServer_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeServiceServer_Service(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); + } + public void completeServiceServer_Namespace(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } public void completeServiceClient_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } @@ -198,10 +192,10 @@ public void completePrivateNamespace_Parts(EObject model, Assignment assignment, public void completeParameter_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeParameter_Namespace(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeParameter_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeParameter_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeParameter_Namespace(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } public void completeParameterListType_Sequence(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { @@ -294,19 +288,13 @@ public void completeArrayTopicSpecRef_TopicSpec(EObject model, Assignment assign public void complete_PackageSet(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_Package(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { - // subclasses may override - } - public void complete_SpecBase(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { - // subclasses may override - } - public void complete_Dependency(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_BEGIN(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_Namespace(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_END(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_Package_Impl(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_SL_COMMENT(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } public void complete_EString(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { @@ -315,16 +303,16 @@ public void complete_EString(EObject model, RuleCall ruleCall, ContentAssistCont public void complete_RosNames(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 } - public void complete_Artifact(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_Package(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_Package_Impl(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } public void complete_CatkinPackage(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { @@ -333,22 +321,25 @@ public void complete_CatkinPackage(EObject model, RuleCall ruleCall, ContentAssi public void complete_AmentPackage(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_ServiceSpec(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_Artifact(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_TopicSpec(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_Node(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_ActionSpec(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_SpecBase(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_MessageDefinition(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_TopicSpec(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_Node(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_ServiceSpec(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_ServiceServer(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_ActionSpec(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_MessageDefinition(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } public void complete_Publisher(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { @@ -357,6 +348,9 @@ public void complete_Publisher(EObject model, RuleCall ruleCall, ContentAssistCo public void complete_Subscriber(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } + public void complete_ServiceServer(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } public void complete_ServiceClient(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } @@ -366,7 +360,7 @@ public void complete_ActionServer(EObject model, RuleCall ruleCall, ContentAssis public void complete_ActionClient(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_GraphName(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + 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) { @@ -375,6 +369,12 @@ public void complete_PackageDependency(EObject model, RuleCall ruleCall, Content public void complete_ExternalDependency(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } + public void complete_Namespace(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_GraphName(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } public void complete_GlobalNamespace(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } @@ -384,6 +384,9 @@ public void complete_RelativeNamespace_Impl(EObject model, RuleCall ruleCall, Co public void complete_PrivateNamespace(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_Parameter(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/RosUiModule.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/RosUiModule.xtend index 52b533dd1..3a686c984 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/RosUiModule.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/RosUiModule.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.ui diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/contentassist/RosProposalProvider.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/contentassist/RosProposalProvider.xtend index 1fca34458..104a0f5bc 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/contentassist/RosProposalProvider.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/contentassist/RosProposalProvider.xtend @@ -1,11 +1,11 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.ui.contentassist /** - * See https://www.eclipse.org/Xtext/documentation/304_ide_concepts.html#content-assist + * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#content-assist * on how to customize the content assistant. */ class RosProposalProvider extends AbstractRosProposalProvider { diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/labeling/RosDescriptionLabelProvider.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/labeling/RosDescriptionLabelProvider.xtend index e156c888c..3dbe05981 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/labeling/RosDescriptionLabelProvider.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/labeling/RosDescriptionLabelProvider.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.ui.labeling @@ -8,7 +8,7 @@ import org.eclipse.xtext.ui.label.DefaultDescriptionLabelProvider /** * Provides labels for IEObjectDescriptions and IResourceDescriptions. * - * See https://www.eclipse.org/Xtext/documentation/304_ide_concepts.html#label-provider + * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#label-provider */ class RosDescriptionLabelProvider extends DefaultDescriptionLabelProvider { diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/labeling/RosLabelProvider.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/labeling/RosLabelProvider.xtend index 9d4fd5450..fb5ec7558 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/labeling/RosLabelProvider.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/labeling/RosLabelProvider.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.ui.labeling @@ -10,7 +10,7 @@ import org.eclipse.xtext.ui.label.DefaultEObjectLabelProvider /** * Provides labels for EObjects. * - * See https://www.eclipse.org/Xtext/documentation/304_ide_concepts.html#label-provider + * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#label-provider */ class RosLabelProvider extends DefaultEObjectLabelProvider { diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/outline/RosOutlineTreeProvider.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/outline/RosOutlineTreeProvider.xtend index a2bfd1641..573d3e48d 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/outline/RosOutlineTreeProvider.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/outline/RosOutlineTreeProvider.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.ui.outline diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/quickfix/RosQuickfixProvider.xtend b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/quickfix/RosQuickfixProvider.xtend index 249a1cc72..8e85b13be 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/quickfix/RosQuickfixProvider.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext.ui/src/de/fraunhofer/ipa/ros/ui/quickfix/RosQuickfixProvider.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.ui.quickfix diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/.settings/org.eclipse.jdt.core.prefs b/plugins/de.fraunhofer.ipa.ros.xtext/.settings/org.eclipse.jdt.core.prefs index 0c68a61dc..7adc0fb9a 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/.settings/org.eclipse.jdt.core.prefs +++ b/plugins/de.fraunhofer.ipa.ros.xtext/.settings/org.eclipse.jdt.core.prefs @@ -1,7 +1,10 @@ eclipse.preferences.version=1 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled -org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 -org.eclipse.jdt.core.compiler.compliance=1.8 +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.source=1.8 +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.ros.xtext/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.ros.xtext/META-INF/MANIFEST.MF index 3bdee2b42..d1a0545a3 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/META-INF/MANIFEST.MF +++ b/plugins/de.fraunhofer.ipa.ros.xtext/META-INF/MANIFEST.MF @@ -1,4 +1,5 @@ Manifest-Version: 1.0 +Automatic-Module-Name: de.fraunhofer.ipa.ros.xtext Bundle-ManifestVersion: 2 Bundle-Name: de.fraunhofer.ipa.ros.xtext Bundle-Vendor: Fraunhofer IPA @@ -8,19 +9,20 @@ Bundle-ActivationPolicy: lazy Require-Bundle: de.fraunhofer.ipa.ros, org.eclipse.xtext, org.eclipse.xtext.xbase, - org.eclipse.equinox.common, + org.eclipse.equinox.common;bundle-version="3.5.0", org.eclipse.xtext.xbase.lib;bundle-version="2.14.0", - org.antlr.runtime;bundle-version="[3.2.0,3.2.1)", org.eclipse.xtext.util, + org.antlr.runtime;bundle-version="[3.2.0,3.2.1)", org.eclipse.xtend.lib;bundle-version="2.14.0" -Bundle-RequiredExecutionEnvironment: JavaSE-1.8 -Export-Package: de.fraunhofer.ipa.ros.formatting2, +Bundle-RequiredExecutionEnvironment: JavaSE-11 +Export-Package: de.fraunhofer.ipa.ros.validation, + de.fraunhofer.ipa.ros.parser.antlr.lexer, + de.fraunhofer.ipa.ros.formatting2, de.fraunhofer.ipa.ros, de.fraunhofer.ipa.ros.scoping, de.fraunhofer.ipa.ros.parser.antlr.internal, de.fraunhofer.ipa.ros.serializer, de.fraunhofer.ipa.ros.services, - de.fraunhofer.ipa.ros.parser.antlr, - de.fraunhofer.ipa.ros.validation, - de.fraunhofer.ipa.ros.generator + de.fraunhofer.ipa.ros.generator, + de.fraunhofer.ipa.ros.parser.antlr Import-Package: org.apache.log4j diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/AbstractRosRuntimeModule.java b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/AbstractRosRuntimeModule.java index 35b6aa665..601fbebfa 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/AbstractRosRuntimeModule.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/AbstractRosRuntimeModule.java @@ -10,7 +10,7 @@ import de.fraunhofer.ipa.ros.generator.RosGenerator; import de.fraunhofer.ipa.ros.parser.antlr.RosAntlrTokenFileProvider; import de.fraunhofer.ipa.ros.parser.antlr.RosParser; -import de.fraunhofer.ipa.ros.parser.antlr.internal.InternalRosLexer; +import de.fraunhofer.ipa.ros.parser.antlr.lexer.InternalRosLexer; import de.fraunhofer.ipa.ros.scoping.RosScopeProvider; import de.fraunhofer.ipa.ros.serializer.RosSemanticSequencer; import de.fraunhofer.ipa.ros.serializer.RosSyntacticSequencer; diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/Ros.xtextbin b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/Ros.xtextbin index 9e1f0098d..4af7747ef 100644 Binary files a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/Ros.xtextbin and b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/Ros.xtextbin differ diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/RosAntlrTokenFileProvider.java b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/RosAntlrTokenFileProvider.java index 29fc9caa1..049f16e65 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/RosAntlrTokenFileProvider.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/RosAntlrTokenFileProvider.java @@ -11,6 +11,6 @@ public class RosAntlrTokenFileProvider implements IAntlrTokenFileProvider { @Override public InputStream getAntlrTokenFile() { ClassLoader classLoader = getClass().getClassLoader(); - return classLoader.getResourceAsStream("de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRos.tokens"); + return classLoader.getResourceAsStream("de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosParser.tokens"); } } diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/RosParser.java b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/RosParser.java index 563d5665e..ff04ca9f3 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/RosParser.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/RosParser.java @@ -6,6 +6,8 @@ import com.google.inject.Inject; import de.fraunhofer.ipa.ros.parser.antlr.internal.InternalRosParser; import de.fraunhofer.ipa.ros.services.RosGrammarAccess; +import org.antlr.runtime.CharStream; +import org.antlr.runtime.TokenSource; import org.eclipse.xtext.parser.antlr.AbstractAntlrParser; import org.eclipse.xtext.parser.antlr.XtextTokenStream; @@ -19,6 +21,19 @@ protected void setInitialHiddenTokens(XtextTokenStream tokenStream) { tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT"); } + @Override + protected TokenSource createLexer(CharStream stream) { + return new RosTokenSource(super.createLexer(stream)); + } + + /** + * Indentation aware languages do not support partial parsing since the lexer is inherently stateful. + * Override and return {@code true} if your terminal splitting is stateless. + */ + @Override + protected boolean isReparseSupported() { + return false; + } @Override protected InternalRosParser createParser(XtextTokenStream stream) { diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRos.tokens b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRos.tokens deleted file mode 100644 index 2df0c3fe4..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRos.tokens +++ /dev/null @@ -1,199 +0,0 @@ -','=27 -'ActionClient'=65 -'ActionClients'=55 -'ActionServer'=63 -'ActionServers'=54 -'ActionSpec'=44 -'AmentPackage'=36 -'Array'=81 -'Artifact'=33 -'Base64'=80 -'Boolean'=79 -'CatkinPackage'=34 -'Dependencies'=35 -'Double'=78 -'ExternalDependency'=67 -'FromGitRepo'=30 -'GlobalNamespace'=68 -'GraphName'=66 -'Header'=41 -'Integer'=76 -'List'=74 -'Node'=48 -'Package'=29 -'PackageSet'=25 -'Parameter'=72 -'ParameterAny'=82 -'ParameterStructMember'=84 -'Parameters'=56 -'PrivateNamespace'=71 -'Publisher'=60 -'Publishers'=51 -'RelativeNamespace'=70 -'ServiceClient'=62 -'ServiceClients'=53 -'ServiceServer'=57 -'ServiceServers'=50 -'ServiceSpec'=37 -'Specs'=31 -'String'=42 -'Struct'=75 -'Subscriber'=61 -'Subscribers'=52 -'TopicSpec'=40 -'[]'=113 -'action'=64 -'bool'=85 -'bool[]'=100 -'byte'=97 -'byte[]'=112 -'default'=77 -'duration'=99 -'feedback'=47 -'float32'=94 -'float32[]'=109 -'float64'=95 -'float64[]'=110 -'goal'=45 -'int16'=88 -'int16[]'=103 -'int32'=90 -'int32[]'=105 -'int64'=92 -'int64[]'=107 -'int8'=86 -'int8[]'=101 -'message'=43 -'name'=49 -'namespace'=59 -'node'=32 -'parts'=69 -'request'=38 -'response'=39 -'result'=46 -'service'=58 -'string'=96 -'string[]'=111 -'time'=98 -'type'=73 -'uint16'=89 -'uint16[]'=104 -'uint32'=91 -'uint32[]'=106 -'uint64'=93 -'uint64[]'=108 -'uint8'=87 -'uint8[]'=102 -'value'=83 -'{'=26 -'}'=28 -RULE_ANY_OTHER=24 -RULE_BINARY=7 -RULE_BOOLEAN=8 -RULE_DATE_TIME=11 -RULE_DAY=15 -RULE_DECINT=10 -RULE_DIGIT=14 -RULE_DOUBLE=9 -RULE_HOUR=18 -RULE_ID=5 -RULE_INT=20 -RULE_MESSAGE_ASIGMENT=12 -RULE_MIN_SEC=19 -RULE_ML_COMMENT=21 -RULE_MONTH=16 -RULE_ROS_CONVENTION_A=6 -RULE_ROS_CONVENTION_PARAM=13 -RULE_SL_COMMENT=22 -RULE_STRING=4 -RULE_WS=23 -RULE_YEAR=17 -T__100=100 -T__101=101 -T__102=102 -T__103=103 -T__104=104 -T__105=105 -T__106=106 -T__107=107 -T__108=108 -T__109=109 -T__110=110 -T__111=111 -T__112=112 -T__113=113 -T__25=25 -T__26=26 -T__27=27 -T__28=28 -T__29=29 -T__30=30 -T__31=31 -T__32=32 -T__33=33 -T__34=34 -T__35=35 -T__36=36 -T__37=37 -T__38=38 -T__39=39 -T__40=40 -T__41=41 -T__42=42 -T__43=43 -T__44=44 -T__45=45 -T__46=46 -T__47=47 -T__48=48 -T__49=49 -T__50=50 -T__51=51 -T__52=52 -T__53=53 -T__54=54 -T__55=55 -T__56=56 -T__57=57 -T__58=58 -T__59=59 -T__60=60 -T__61=61 -T__62=62 -T__63=63 -T__64=64 -T__65=65 -T__66=66 -T__67=67 -T__68=68 -T__69=69 -T__70=70 -T__71=71 -T__72=72 -T__73=73 -T__74=74 -T__75=75 -T__76=76 -T__77=77 -T__78=78 -T__79=79 -T__80=80 -T__81=81 -T__82=82 -T__83=83 -T__84=84 -T__85=85 -T__86=86 -T__87=87 -T__88=88 -T__89=89 -T__90=90 -T__91=91 -T__92=92 -T__93=93 -T__94=94 -T__95=95 -T__96=96 -T__97=97 -T__98=98 -T__99=99 diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosLexer.java b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosLexer.java deleted file mode 100644 index f8008c921..000000000 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosLexer.java +++ /dev/null @@ -1,5094 +0,0 @@ -package de.fraunhofer.ipa.ros.parser.antlr.internal; - -// Hack: Use our own Lexer superclass by means of import. -// Currently there is no other way to specify the superclass for the lexer. -import org.eclipse.xtext.parser.antlr.Lexer; - - -import org.antlr.runtime.*; -import java.util.Stack; -import java.util.List; -import java.util.ArrayList; - -@SuppressWarnings("all") -public class InternalRosLexer extends Lexer { - public static final int T__50=50; - public static final int RULE_DATE_TIME=11; - public static final int T__59=59; - public static final int T__55=55; - public static final int T__56=56; - public static final int T__57=57; - public static final int T__58=58; - public static final int T__51=51; - public static final int T__52=52; - public static final int T__53=53; - public static final int T__54=54; - public static final int T__60=60; - public static final int T__61=61; - public static final int RULE_ID=5; - public static final int RULE_DIGIT=14; - public static final int RULE_INT=20; - public static final int T__66=66; - public static final int RULE_ML_COMMENT=21; - public static final int T__67=67; - public static final int T__68=68; - public static final int T__69=69; - public static final int T__62=62; - public static final int T__63=63; - public static final int T__64=64; - public static final int T__65=65; - public static final int RULE_MESSAGE_ASIGMENT=12; - public static final int T__37=37; - public static final int T__38=38; - public static final int T__39=39; - public static final int T__33=33; - public static final int T__34=34; - public static final int T__35=35; - public static final int T__36=36; - public static final int RULE_DECINT=10; - public static final int T__30=30; - public static final int T__31=31; - public static final int T__32=32; - public static final int RULE_HOUR=18; - public static final int T__48=48; - public static final int T__49=49; - public static final int T__44=44; - public static final int T__45=45; - public static final int T__46=46; - public static final int RULE_BINARY=7; - public static final int T__47=47; - public static final int T__40=40; - public static final int T__41=41; - public static final int T__42=42; - public static final int T__43=43; - public static final int T__91=91; - public static final int T__100=100; - public static final int T__92=92; - public static final int T__93=93; - public static final int T__102=102; - public static final int T__94=94; - public static final int T__101=101; - public static final int RULE_DAY=15; - public static final int T__90=90; - public static final int RULE_BOOLEAN=8; - public static final int RULE_YEAR=17; - public static final int RULE_MIN_SEC=19; - public static final int T__99=99; - public static final int T__95=95; - public static final int T__96=96; - public static final int T__97=97; - public static final int T__98=98; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; - public static final int T__29=29; - public static final int T__25=25; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=4; - public static final int RULE_SL_COMMENT=22; - public static final int RULE_DOUBLE=9; - public static final int RULE_ROS_CONVENTION_A=6; - public static final int T__77=77; - public static final int T__78=78; - public static final int RULE_ROS_CONVENTION_PARAM=13; - public static final int T__79=79; - public static final int T__73=73; - public static final int EOF=-1; - public static final int T__74=74; - public static final int T__75=75; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__111=111; - public static final int T__81=81; - public static final int T__110=110; - public static final int T__82=82; - public static final int T__113=113; - public static final int T__83=83; - public static final int T__112=112; - public static final int RULE_WS=23; - public static final int RULE_ANY_OTHER=24; - public static final int T__88=88; - public static final int T__108=108; - public static final int T__89=89; - public static final int T__107=107; - public static final int RULE_MONTH=16; - public static final int T__109=109; - public static final int T__84=84; - public static final int T__104=104; - public static final int T__85=85; - public static final int T__103=103; - public static final int T__86=86; - public static final int T__106=106; - public static final int T__87=87; - public static final int T__105=105; - - // delegates - // delegators - - public InternalRosLexer() {;} - public InternalRosLexer(CharStream input) { - this(input, new RecognizerSharedState()); - } - public InternalRosLexer(CharStream input, RecognizerSharedState state) { - super(input,state); - - } - public String getGrammarFileName() { return "InternalRos.g"; } - - // $ANTLR start "T__25" - public final void mT__25() throws RecognitionException { - try { - int _type = T__25; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:11:7: ( 'PackageSet' ) - // InternalRos.g:11:9: 'PackageSet' - { - match("PackageSet"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__25" - - // $ANTLR start "T__26" - public final void mT__26() throws RecognitionException { - try { - int _type = T__26; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:12:7: ( '{' ) - // InternalRos.g:12:9: '{' - { - match('{'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__26" - - // $ANTLR start "T__27" - public final void mT__27() throws RecognitionException { - try { - int _type = T__27; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:13:7: ( ',' ) - // InternalRos.g:13:9: ',' - { - match(','); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__27" - - // $ANTLR start "T__28" - public final void mT__28() throws RecognitionException { - try { - int _type = T__28; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:14:7: ( '}' ) - // InternalRos.g:14:9: '}' - { - match('}'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__28" - - // $ANTLR start "T__29" - public final void mT__29() throws RecognitionException { - try { - int _type = T__29; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:15:7: ( 'Package' ) - // InternalRos.g:15:9: 'Package' - { - match("Package"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__29" - - // $ANTLR start "T__30" - public final void mT__30() throws RecognitionException { - try { - int _type = T__30; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:16:7: ( 'FromGitRepo' ) - // InternalRos.g:16:9: 'FromGitRepo' - { - match("FromGitRepo"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__30" - - // $ANTLR start "T__31" - public final void mT__31() throws RecognitionException { - try { - int _type = T__31; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:17:7: ( 'Specs' ) - // InternalRos.g:17:9: 'Specs' - { - match("Specs"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__31" - - // $ANTLR start "T__32" - public final void mT__32() throws RecognitionException { - try { - int _type = T__32; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:18:7: ( 'node' ) - // InternalRos.g:18:9: 'node' - { - match("node"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__32" - - // $ANTLR start "T__33" - public final void mT__33() throws RecognitionException { - try { - int _type = T__33; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:19:7: ( 'Artifact' ) - // InternalRos.g:19:9: 'Artifact' - { - match("Artifact"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__33" - - // $ANTLR start "T__34" - public final void mT__34() throws RecognitionException { - try { - int _type = T__34; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:20:7: ( 'CatkinPackage' ) - // InternalRos.g:20:9: 'CatkinPackage' - { - match("CatkinPackage"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__34" - - // $ANTLR start "T__35" - public final void mT__35() throws RecognitionException { - try { - int _type = T__35; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:21:7: ( 'Dependencies' ) - // InternalRos.g:21:9: 'Dependencies' - { - match("Dependencies"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__35" - - // $ANTLR start "T__36" - public final void mT__36() throws RecognitionException { - try { - int _type = T__36; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:22:7: ( 'AmentPackage' ) - // InternalRos.g:22:9: 'AmentPackage' - { - match("AmentPackage"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__36" - - // $ANTLR start "T__37" - public final void mT__37() throws RecognitionException { - try { - int _type = T__37; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:23:7: ( 'ServiceSpec' ) - // InternalRos.g:23:9: 'ServiceSpec' - { - match("ServiceSpec"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__37" - - // $ANTLR start "T__38" - public final void mT__38() throws RecognitionException { - try { - int _type = T__38; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:24:7: ( 'request' ) - // InternalRos.g:24:9: 'request' - { - match("request"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__38" - - // $ANTLR start "T__39" - public final void mT__39() throws RecognitionException { - try { - int _type = T__39; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:25:7: ( 'response' ) - // InternalRos.g:25:9: 'response' - { - match("response"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__39" - - // $ANTLR start "T__40" - public final void mT__40() throws RecognitionException { - try { - int _type = T__40; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:26:7: ( 'TopicSpec' ) - // InternalRos.g:26:9: 'TopicSpec' - { - match("TopicSpec"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__40" - - // $ANTLR start "T__41" - public final void mT__41() throws RecognitionException { - try { - int _type = T__41; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:27:7: ( 'Header' ) - // InternalRos.g:27:9: 'Header' - { - match("Header"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__41" - - // $ANTLR start "T__42" - public final void mT__42() throws RecognitionException { - try { - int _type = T__42; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:28:7: ( 'String' ) - // InternalRos.g:28:9: 'String' - { - match("String"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__42" - - // $ANTLR start "T__43" - public final void mT__43() throws RecognitionException { - try { - int _type = T__43; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:29:7: ( 'message' ) - // InternalRos.g:29:9: 'message' - { - match("message"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__43" - - // $ANTLR start "T__44" - public final void mT__44() throws RecognitionException { - try { - int _type = T__44; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:30:7: ( 'ActionSpec' ) - // InternalRos.g:30:9: 'ActionSpec' - { - match("ActionSpec"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__44" - - // $ANTLR start "T__45" - public final void mT__45() throws RecognitionException { - try { - int _type = T__45; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:31:7: ( 'goal' ) - // InternalRos.g:31:9: 'goal' - { - match("goal"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__45" - - // $ANTLR start "T__46" - public final void mT__46() throws RecognitionException { - try { - int _type = T__46; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:32:7: ( 'result' ) - // InternalRos.g:32:9: 'result' - { - match("result"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__46" - - // $ANTLR start "T__47" - public final void mT__47() throws RecognitionException { - try { - int _type = T__47; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:33:7: ( 'feedback' ) - // InternalRos.g:33:9: 'feedback' - { - match("feedback"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__47" - - // $ANTLR start "T__48" - public final void mT__48() throws RecognitionException { - try { - int _type = T__48; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:34:7: ( 'Node' ) - // InternalRos.g:34:9: 'Node' - { - match("Node"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__48" - - // $ANTLR start "T__49" - public final void mT__49() throws RecognitionException { - try { - int _type = T__49; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:35:7: ( 'name' ) - // InternalRos.g:35:9: 'name' - { - match("name"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__49" - - // $ANTLR start "T__50" - public final void mT__50() throws RecognitionException { - try { - int _type = T__50; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:36:7: ( 'ServiceServers' ) - // InternalRos.g:36:9: 'ServiceServers' - { - match("ServiceServers"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__50" - - // $ANTLR start "T__51" - public final void mT__51() throws RecognitionException { - try { - int _type = T__51; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:37:7: ( 'Publishers' ) - // InternalRos.g:37:9: 'Publishers' - { - match("Publishers"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__51" - - // $ANTLR start "T__52" - public final void mT__52() throws RecognitionException { - try { - int _type = T__52; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:38:7: ( 'Subscribers' ) - // InternalRos.g:38:9: 'Subscribers' - { - match("Subscribers"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__52" - - // $ANTLR start "T__53" - public final void mT__53() throws RecognitionException { - try { - int _type = T__53; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:39:7: ( 'ServiceClients' ) - // InternalRos.g:39:9: 'ServiceClients' - { - match("ServiceClients"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__53" - - // $ANTLR start "T__54" - public final void mT__54() throws RecognitionException { - try { - int _type = T__54; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:40:7: ( 'ActionServers' ) - // InternalRos.g:40:9: 'ActionServers' - { - match("ActionServers"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__54" - - // $ANTLR start "T__55" - public final void mT__55() throws RecognitionException { - try { - int _type = T__55; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:41:7: ( 'ActionClients' ) - // InternalRos.g:41:9: 'ActionClients' - { - match("ActionClients"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__55" - - // $ANTLR start "T__56" - public final void mT__56() throws RecognitionException { - try { - int _type = T__56; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:42:7: ( 'Parameters' ) - // InternalRos.g:42:9: 'Parameters' - { - match("Parameters"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__56" - - // $ANTLR start "T__57" - public final void mT__57() throws RecognitionException { - try { - int _type = T__57; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:43:7: ( 'ServiceServer' ) - // InternalRos.g:43:9: 'ServiceServer' - { - match("ServiceServer"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__57" - - // $ANTLR start "T__58" - public final void mT__58() throws RecognitionException { - try { - int _type = T__58; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:44:7: ( 'service' ) - // InternalRos.g:44:9: 'service' - { - match("service"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__58" - - // $ANTLR start "T__59" - public final void mT__59() throws RecognitionException { - try { - int _type = T__59; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:45:7: ( 'namespace' ) - // InternalRos.g:45:9: 'namespace' - { - match("namespace"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__59" - - // $ANTLR start "T__60" - public final void mT__60() throws RecognitionException { - try { - int _type = T__60; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:46:7: ( 'Publisher' ) - // InternalRos.g:46:9: 'Publisher' - { - match("Publisher"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__60" - - // $ANTLR start "T__61" - public final void mT__61() throws RecognitionException { - try { - int _type = T__61; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:47:7: ( 'Subscriber' ) - // InternalRos.g:47:9: 'Subscriber' - { - match("Subscriber"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__61" - - // $ANTLR start "T__62" - public final void mT__62() throws RecognitionException { - try { - int _type = T__62; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:48:7: ( 'ServiceClient' ) - // InternalRos.g:48:9: 'ServiceClient' - { - match("ServiceClient"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__62" - - // $ANTLR start "T__63" - public final void mT__63() throws RecognitionException { - try { - int _type = T__63; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:49:7: ( 'ActionServer' ) - // InternalRos.g:49:9: 'ActionServer' - { - match("ActionServer"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__63" - - // $ANTLR start "T__64" - public final void mT__64() throws RecognitionException { - try { - int _type = T__64; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:50:7: ( 'action' ) - // InternalRos.g:50:9: 'action' - { - match("action"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__64" - - // $ANTLR start "T__65" - public final void mT__65() throws RecognitionException { - try { - int _type = T__65; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:51:7: ( 'ActionClient' ) - // InternalRos.g:51:9: 'ActionClient' - { - match("ActionClient"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__65" - - // $ANTLR start "T__66" - public final void mT__66() throws RecognitionException { - try { - int _type = T__66; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:52:7: ( 'GraphName' ) - // InternalRos.g:52:9: 'GraphName' - { - match("GraphName"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__66" - - // $ANTLR start "T__67" - public final void mT__67() throws RecognitionException { - try { - int _type = T__67; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:53:7: ( 'ExternalDependency' ) - // InternalRos.g:53:9: 'ExternalDependency' - { - match("ExternalDependency"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__67" - - // $ANTLR start "T__68" - public final void mT__68() throws RecognitionException { - try { - int _type = T__68; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:54:7: ( 'GlobalNamespace' ) - // InternalRos.g:54:9: 'GlobalNamespace' - { - match("GlobalNamespace"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__68" - - // $ANTLR start "T__69" - public final void mT__69() throws RecognitionException { - try { - int _type = T__69; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:55:7: ( 'parts' ) - // InternalRos.g:55:9: 'parts' - { - match("parts"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__69" - - // $ANTLR start "T__70" - public final void mT__70() throws RecognitionException { - try { - int _type = T__70; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:56:7: ( 'RelativeNamespace' ) - // InternalRos.g:56:9: 'RelativeNamespace' - { - match("RelativeNamespace"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__70" - - // $ANTLR start "T__71" - public final void mT__71() throws RecognitionException { - try { - int _type = T__71; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:57:7: ( 'PrivateNamespace' ) - // InternalRos.g:57:9: 'PrivateNamespace' - { - match("PrivateNamespace"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__71" - - // $ANTLR start "T__72" - public final void mT__72() throws RecognitionException { - try { - int _type = T__72; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:58:7: ( 'Parameter' ) - // InternalRos.g:58:9: 'Parameter' - { - match("Parameter"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__72" - - // $ANTLR start "T__73" - public final void mT__73() throws RecognitionException { - try { - int _type = T__73; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:59:7: ( 'type' ) - // InternalRos.g:59:9: 'type' - { - match("type"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__73" - - // $ANTLR start "T__74" - public final void mT__74() throws RecognitionException { - try { - int _type = T__74; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:60:7: ( 'List' ) - // InternalRos.g:60:9: 'List' - { - match("List"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__74" - - // $ANTLR start "T__75" - public final void mT__75() throws RecognitionException { - try { - int _type = T__75; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:61:7: ( 'Struct' ) - // InternalRos.g:61:9: 'Struct' - { - match("Struct"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__75" - - // $ANTLR start "T__76" - public final void mT__76() throws RecognitionException { - try { - int _type = T__76; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:62:7: ( 'Integer' ) - // InternalRos.g:62:9: 'Integer' - { - match("Integer"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__76" - - // $ANTLR start "T__77" - public final void mT__77() throws RecognitionException { - try { - int _type = T__77; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:63:7: ( 'default' ) - // InternalRos.g:63:9: 'default' - { - match("default"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__77" - - // $ANTLR start "T__78" - public final void mT__78() throws RecognitionException { - try { - int _type = T__78; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:64:7: ( 'Double' ) - // InternalRos.g:64:9: 'Double' - { - match("Double"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__78" - - // $ANTLR start "T__79" - public final void mT__79() throws RecognitionException { - try { - int _type = T__79; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:65:7: ( 'Boolean' ) - // InternalRos.g:65:9: 'Boolean' - { - match("Boolean"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__79" - - // $ANTLR start "T__80" - public final void mT__80() throws RecognitionException { - try { - int _type = T__80; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:66:7: ( 'Base64' ) - // InternalRos.g:66:9: 'Base64' - { - match("Base64"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__80" - - // $ANTLR start "T__81" - public final void mT__81() throws RecognitionException { - try { - int _type = T__81; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:67:7: ( 'Array' ) - // InternalRos.g:67:9: 'Array' - { - match("Array"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__81" - - // $ANTLR start "T__82" - public final void mT__82() throws RecognitionException { - try { - int _type = T__82; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:68:7: ( 'ParameterAny' ) - // InternalRos.g:68:9: 'ParameterAny' - { - match("ParameterAny"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__82" - - // $ANTLR start "T__83" - public final void mT__83() throws RecognitionException { - try { - int _type = T__83; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:69:7: ( 'value' ) - // InternalRos.g:69:9: 'value' - { - match("value"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__83" - - // $ANTLR start "T__84" - public final void mT__84() throws RecognitionException { - try { - int _type = T__84; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:70:7: ( 'ParameterStructMember' ) - // InternalRos.g:70:9: 'ParameterStructMember' - { - match("ParameterStructMember"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__84" - - // $ANTLR start "T__85" - public final void mT__85() throws RecognitionException { - try { - int _type = T__85; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:71:7: ( 'bool' ) - // InternalRos.g:71:9: 'bool' - { - match("bool"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__85" - - // $ANTLR start "T__86" - public final void mT__86() throws RecognitionException { - try { - int _type = T__86; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:72:7: ( 'int8' ) - // InternalRos.g:72:9: 'int8' - { - match("int8"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__86" - - // $ANTLR start "T__87" - public final void mT__87() throws RecognitionException { - try { - int _type = T__87; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:73:7: ( 'uint8' ) - // InternalRos.g:73:9: 'uint8' - { - match("uint8"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__87" - - // $ANTLR start "T__88" - public final void mT__88() throws RecognitionException { - try { - int _type = T__88; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:74:7: ( 'int16' ) - // InternalRos.g:74:9: 'int16' - { - match("int16"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__88" - - // $ANTLR start "T__89" - public final void mT__89() throws RecognitionException { - try { - int _type = T__89; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:75:7: ( 'uint16' ) - // InternalRos.g:75:9: 'uint16' - { - match("uint16"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__89" - - // $ANTLR start "T__90" - public final void mT__90() throws RecognitionException { - try { - int _type = T__90; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:76:7: ( 'int32' ) - // InternalRos.g:76:9: 'int32' - { - match("int32"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__90" - - // $ANTLR start "T__91" - public final void mT__91() throws RecognitionException { - try { - int _type = T__91; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:77:7: ( 'uint32' ) - // InternalRos.g:77:9: 'uint32' - { - match("uint32"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__91" - - // $ANTLR start "T__92" - public final void mT__92() throws RecognitionException { - try { - int _type = T__92; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:78:7: ( 'int64' ) - // InternalRos.g:78:9: 'int64' - { - match("int64"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__92" - - // $ANTLR start "T__93" - public final void mT__93() throws RecognitionException { - try { - int _type = T__93; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:79:7: ( 'uint64' ) - // InternalRos.g:79:9: 'uint64' - { - match("uint64"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__93" - - // $ANTLR start "T__94" - public final void mT__94() throws RecognitionException { - try { - int _type = T__94; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:80:7: ( 'float32' ) - // InternalRos.g:80:9: 'float32' - { - match("float32"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__94" - - // $ANTLR start "T__95" - public final void mT__95() throws RecognitionException { - try { - int _type = T__95; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:81:7: ( 'float64' ) - // InternalRos.g:81:9: 'float64' - { - match("float64"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__95" - - // $ANTLR start "T__96" - public final void mT__96() throws RecognitionException { - try { - int _type = T__96; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:82:7: ( 'string' ) - // InternalRos.g:82:9: 'string' - { - match("string"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__96" - - // $ANTLR start "T__97" - public final void mT__97() throws RecognitionException { - try { - int _type = T__97; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:83:7: ( 'byte' ) - // InternalRos.g:83:9: 'byte' - { - match("byte"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__97" - - // $ANTLR start "T__98" - public final void mT__98() throws RecognitionException { - try { - int _type = T__98; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:84:7: ( 'time' ) - // InternalRos.g:84:9: 'time' - { - match("time"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__98" - - // $ANTLR start "T__99" - public final void mT__99() throws RecognitionException { - try { - int _type = T__99; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:85:7: ( 'duration' ) - // InternalRos.g:85:9: 'duration' - { - match("duration"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__99" - - // $ANTLR start "T__100" - public final void mT__100() throws RecognitionException { - try { - int _type = T__100; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:86:8: ( 'bool[]' ) - // InternalRos.g:86:10: 'bool[]' - { - match("bool[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__100" - - // $ANTLR start "T__101" - public final void mT__101() throws RecognitionException { - try { - int _type = T__101; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:87:8: ( 'int8[]' ) - // InternalRos.g:87:10: 'int8[]' - { - match("int8[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__101" - - // $ANTLR start "T__102" - public final void mT__102() throws RecognitionException { - try { - int _type = T__102; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:88:8: ( 'uint8[]' ) - // InternalRos.g:88:10: 'uint8[]' - { - match("uint8[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__102" - - // $ANTLR start "T__103" - public final void mT__103() throws RecognitionException { - try { - int _type = T__103; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:89:8: ( 'int16[]' ) - // InternalRos.g:89:10: 'int16[]' - { - match("int16[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__103" - - // $ANTLR start "T__104" - public final void mT__104() throws RecognitionException { - try { - int _type = T__104; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:90:8: ( 'uint16[]' ) - // InternalRos.g:90:10: 'uint16[]' - { - match("uint16[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__104" - - // $ANTLR start "T__105" - public final void mT__105() throws RecognitionException { - try { - int _type = T__105; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:91:8: ( 'int32[]' ) - // InternalRos.g:91:10: 'int32[]' - { - match("int32[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__105" - - // $ANTLR start "T__106" - public final void mT__106() throws RecognitionException { - try { - int _type = T__106; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:92:8: ( 'uint32[]' ) - // InternalRos.g:92:10: 'uint32[]' - { - match("uint32[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__106" - - // $ANTLR start "T__107" - public final void mT__107() throws RecognitionException { - try { - int _type = T__107; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:93:8: ( 'int64[]' ) - // InternalRos.g:93:10: 'int64[]' - { - match("int64[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__107" - - // $ANTLR start "T__108" - public final void mT__108() throws RecognitionException { - try { - int _type = T__108; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:94:8: ( 'uint64[]' ) - // InternalRos.g:94:10: 'uint64[]' - { - match("uint64[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__108" - - // $ANTLR start "T__109" - public final void mT__109() throws RecognitionException { - try { - int _type = T__109; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:95:8: ( 'float32[]' ) - // InternalRos.g:95:10: 'float32[]' - { - match("float32[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__109" - - // $ANTLR start "T__110" - public final void mT__110() throws RecognitionException { - try { - int _type = T__110; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:96:8: ( 'float64[]' ) - // InternalRos.g:96:10: 'float64[]' - { - match("float64[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__110" - - // $ANTLR start "T__111" - public final void mT__111() throws RecognitionException { - try { - int _type = T__111; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:97:8: ( 'string[]' ) - // InternalRos.g:97:10: 'string[]' - { - match("string[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__111" - - // $ANTLR start "T__112" - public final void mT__112() throws RecognitionException { - try { - int _type = T__112; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:98:8: ( 'byte[]' ) - // InternalRos.g:98:10: 'byte[]' - { - match("byte[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__112" - - // $ANTLR start "T__113" - public final void mT__113() throws RecognitionException { - try { - int _type = T__113; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:99:8: ( '[]' ) - // InternalRos.g:99:10: '[]' - { - match("[]"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__113" - - // $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; - // InternalRos.g:5906:23: ( ( '/' RULE_ID | RULE_ID '/' )* ) - // InternalRos.g:5906:25: ( '/' RULE_ID | RULE_ID '/' )* - { - // InternalRos.g:5906:25: ( '/' RULE_ID | RULE_ID '/' )* - loop1: - do { - int alt1=3; - int LA1_0 = input.LA(1); - - if ( (LA1_0=='/') ) { - alt1=1; - } - else if ( ((LA1_0>='A' && LA1_0<='Z')||(LA1_0>='^' && LA1_0<='_')||(LA1_0>='a' && LA1_0<='z')) ) { - alt1=2; - } - - - switch (alt1) { - case 1 : - // InternalRos.g:5906:26: '/' RULE_ID - { - match('/'); - mRULE_ID(); - - } - break; - case 2 : - // InternalRos.g:5906:38: RULE_ID '/' - { - mRULE_ID(); - match('/'); - - } - break; - - default : - break loop1; - } - } 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; - // InternalRos.g:5908:27: ( ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* ) - // InternalRos.g:5908:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* - { - // InternalRos.g:5908:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* - loop2: - do { - int alt2=4; - switch ( input.LA(1) ) { - case '/': - { - alt2=1; - } - break; - case '\"': - case '\'': - { - alt2=2; - } - break; - case '~': - { - alt2=3; - } - break; - - } - - switch (alt2) { - case 1 : - // InternalRos.g:5908:30: '/' RULE_STRING - { - match('/'); - mRULE_STRING(); - - } - break; - case 2 : - // InternalRos.g:5908:46: RULE_STRING '/' - { - mRULE_STRING(); - match('/'); - - } - break; - case 3 : - // InternalRos.g:5908:62: '~' RULE_STRING - { - match('~'); - mRULE_STRING(); - - } - break; - - default : - break loop2; - } - } while (true); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_ROS_CONVENTION_PARAM" - - // $ANTLR start "RULE_DIGIT" - public final void mRULE_DIGIT() throws RecognitionException { - try { - // InternalRos.g:5910:21: ( '0' .. '9' ) - // InternalRos.g:5910:23: '0' .. '9' - { - matchRange('0','9'); - - } - - } - finally { - } - } - // $ANTLR end "RULE_DIGIT" - - // $ANTLR start "RULE_BINARY" - public final void mRULE_BINARY() throws RecognitionException { - try { - int _type = RULE_BINARY; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:5912:13: ( ( '0b' | '0B' ) ( '0' | '1' )+ ) - // InternalRos.g:5912:15: ( '0b' | '0B' ) ( '0' | '1' )+ - { - // InternalRos.g:5912:15: ( '0b' | '0B' ) - int alt3=2; - int LA3_0 = input.LA(1); - - if ( (LA3_0=='0') ) { - int LA3_1 = input.LA(2); - - if ( (LA3_1=='b') ) { - alt3=1; - } - else if ( (LA3_1=='B') ) { - alt3=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 3, 1, input); - - throw nvae; - } - } - else { - NoViableAltException nvae = - new NoViableAltException("", 3, 0, input); - - throw nvae; - } - switch (alt3) { - case 1 : - // InternalRos.g:5912:16: '0b' - { - match("0b"); - - - } - break; - case 2 : - // InternalRos.g:5912:21: '0B' - { - match("0B"); - - - } - break; - - } - - // InternalRos.g:5912:27: ( '0' | '1' )+ - int cnt4=0; - loop4: - do { - int alt4=2; - int LA4_0 = input.LA(1); - - if ( ((LA4_0>='0' && LA4_0<='1')) ) { - alt4=1; - } - - - switch (alt4) { - case 1 : - // InternalRos.g: - { - if ( (input.LA(1)>='0' && input.LA(1)<='1') ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - default : - if ( cnt4 >= 1 ) break loop4; - EarlyExitException eee = - new EarlyExitException(4, input); - throw eee; - } - cnt4++; - } while (true); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_BINARY" - - // $ANTLR start "RULE_BOOLEAN" - public final void mRULE_BOOLEAN() throws RecognitionException { - try { - int _type = RULE_BOOLEAN; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:5914:14: ( ( 'true' | 'false' ) ) - // InternalRos.g:5914:16: ( 'true' | 'false' ) - { - // InternalRos.g:5914:16: ( 'true' | 'false' ) - int alt5=2; - int LA5_0 = input.LA(1); - - if ( (LA5_0=='t') ) { - alt5=1; - } - else if ( (LA5_0=='f') ) { - alt5=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 5, 0, input); - - throw nvae; - } - switch (alt5) { - case 1 : - // InternalRos.g:5914:17: 'true' - { - match("true"); - - - } - break; - case 2 : - // InternalRos.g:5914:24: 'false' - { - match("false"); - - - } - break; - - } - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_BOOLEAN" - - // $ANTLR start "RULE_DOUBLE" - public final void mRULE_DOUBLE() throws RecognitionException { - try { - int _type = RULE_DOUBLE; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:5916:13: ( RULE_DECINT ( '.' ( RULE_DIGIT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DECINT ) ) - // InternalRos.g:5916:15: RULE_DECINT ( '.' ( RULE_DIGIT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DECINT ) - { - mRULE_DECINT(); - // InternalRos.g:5916:27: ( '.' ( RULE_DIGIT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DECINT ) - int alt10=2; - alt10 = dfa10.predict(input); - switch (alt10) { - case 1 : - // InternalRos.g:5916:28: '.' ( RULE_DIGIT )* - { - match('.'); - // InternalRos.g:5916:32: ( RULE_DIGIT )* - loop6: - do { - int alt6=2; - int LA6_0 = input.LA(1); - - if ( ((LA6_0>='0' && LA6_0<='9')) ) { - alt6=1; - } - - - switch (alt6) { - case 1 : - // InternalRos.g:5916:32: RULE_DIGIT - { - mRULE_DIGIT(); - - } - break; - - default : - break loop6; - } - } while (true); - - - } - break; - case 2 : - // InternalRos.g:5916:44: ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DECINT - { - // InternalRos.g:5916:44: ( '.' ( RULE_DIGIT )* )? - int alt8=2; - int LA8_0 = input.LA(1); - - if ( (LA8_0=='.') ) { - alt8=1; - } - switch (alt8) { - case 1 : - // InternalRos.g:5916:45: '.' ( RULE_DIGIT )* - { - match('.'); - // InternalRos.g:5916:49: ( RULE_DIGIT )* - loop7: - do { - int alt7=2; - int LA7_0 = input.LA(1); - - if ( ((LA7_0>='0' && LA7_0<='9')) ) { - alt7=1; - } - - - switch (alt7) { - case 1 : - // InternalRos.g:5916:49: RULE_DIGIT - { - mRULE_DIGIT(); - - } - break; - - default : - break loop7; - } - } while (true); - - - } - break; - - } - - if ( input.LA(1)=='E'||input.LA(1)=='e' ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - // InternalRos.g:5916:73: ( '-' | '+' )? - int alt9=2; - int LA9_0 = input.LA(1); - - if ( (LA9_0=='-') ) { - int LA9_1 = input.LA(2); - - if ( (LA9_1=='0') ) { - alt9=1; - } - else if ( (LA9_1=='-'||(LA9_1>='1' && LA9_1<='9')) ) { - alt9=1; - } - } - else if ( (LA9_0=='+') ) { - alt9=1; - } - switch (alt9) { - case 1 : - // InternalRos.g: - { - if ( input.LA(1)=='+'||input.LA(1)=='-' ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - } - - mRULE_DECINT(); - - } - break; - - } - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_DOUBLE" - - // $ANTLR start "RULE_DECINT" - public final void mRULE_DECINT() throws RecognitionException { - try { - int _type = RULE_DECINT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:5918:13: ( ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) ) - // InternalRos.g:5918:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) - { - // InternalRos.g:5918:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) - int alt13=3; - switch ( input.LA(1) ) { - case '0': - { - alt13=1; - } - break; - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - { - alt13=2; - } - break; - case '-': - { - alt13=3; - } - break; - default: - NoViableAltException nvae = - new NoViableAltException("", 13, 0, input); - - throw nvae; - } - - switch (alt13) { - case 1 : - // InternalRos.g:5918:16: '0' - { - match('0'); - - } - break; - case 2 : - // InternalRos.g:5918:20: '1' .. '9' ( RULE_DIGIT )* - { - matchRange('1','9'); - // InternalRos.g:5918:29: ( RULE_DIGIT )* - loop11: - do { - int alt11=2; - int LA11_0 = input.LA(1); - - if ( ((LA11_0>='0' && LA11_0<='9')) ) { - alt11=1; - } - - - switch (alt11) { - case 1 : - // InternalRos.g:5918:29: RULE_DIGIT - { - mRULE_DIGIT(); - - } - break; - - default : - break loop11; - } - } while (true); - - - } - break; - case 3 : - // InternalRos.g:5918:41: '-' '0' .. '9' ( RULE_DIGIT )* - { - match('-'); - matchRange('0','9'); - // InternalRos.g:5918:54: ( RULE_DIGIT )* - loop12: - do { - int alt12=2; - int LA12_0 = input.LA(1); - - if ( ((LA12_0>='0' && LA12_0<='9')) ) { - alt12=1; - } - - - switch (alt12) { - case 1 : - // InternalRos.g:5918:54: RULE_DIGIT - { - mRULE_DIGIT(); - - } - break; - - default : - break loop12; - } - } while (true); - - - } - break; - - } - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_DECINT" - - // $ANTLR start "RULE_DAY" - public final void mRULE_DAY() throws RecognitionException { - try { - // InternalRos.g:5920:19: ( ( '1' .. '9' | '1' .. '3' '0' .. '9' ) ) - // InternalRos.g:5920:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) - { - // InternalRos.g:5920:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) - int alt14=2; - int LA14_0 = input.LA(1); - - if ( ((LA14_0>='1' && LA14_0<='3')) ) { - int LA14_1 = input.LA(2); - - if ( ((LA14_1>='0' && LA14_1<='9')) ) { - alt14=2; - } - else { - alt14=1;} - } - else if ( ((LA14_0>='4' && LA14_0<='9')) ) { - alt14=1; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 14, 0, input); - - throw nvae; - } - switch (alt14) { - case 1 : - // InternalRos.g:5920:22: '1' .. '9' - { - matchRange('1','9'); - - } - break; - case 2 : - // InternalRos.g:5920:31: '1' .. '3' '0' .. '9' - { - matchRange('1','3'); - matchRange('0','9'); - - } - break; - - } - - - } - - } - finally { - } - } - // $ANTLR end "RULE_DAY" - - // $ANTLR start "RULE_MONTH" - public final void mRULE_MONTH() throws RecognitionException { - try { - // InternalRos.g:5922:21: ( ( '1' .. '9' | '1' '0' .. '2' ) ) - // InternalRos.g:5922:23: ( '1' .. '9' | '1' '0' .. '2' ) - { - // InternalRos.g:5922:23: ( '1' .. '9' | '1' '0' .. '2' ) - int alt15=2; - int LA15_0 = input.LA(1); - - if ( (LA15_0=='1') ) { - int LA15_1 = input.LA(2); - - if ( ((LA15_1>='0' && LA15_1<='2')) ) { - alt15=2; - } - else { - alt15=1;} - } - else if ( ((LA15_0>='2' && LA15_0<='9')) ) { - alt15=1; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 15, 0, input); - - throw nvae; - } - switch (alt15) { - case 1 : - // InternalRos.g:5922:24: '1' .. '9' - { - matchRange('1','9'); - - } - break; - case 2 : - // InternalRos.g:5922:33: '1' '0' .. '2' - { - match('1'); - matchRange('0','2'); - - } - break; - - } - - - } - - } - finally { - } - } - // $ANTLR end "RULE_MONTH" - - // $ANTLR start "RULE_YEAR" - public final void mRULE_YEAR() throws RecognitionException { - try { - // InternalRos.g:5924:20: ( '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' ) - // InternalRos.g:5924:22: '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' - { - matchRange('0','2'); - matchRange('0','9'); - matchRange('0','9'); - matchRange('0','9'); - - } - - } - finally { - } - } - // $ANTLR end "RULE_YEAR" - - // $ANTLR start "RULE_HOUR" - public final void mRULE_HOUR() throws RecognitionException { - try { - // InternalRos.g:5926:20: ( ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) ) - // InternalRos.g:5926:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) - { - // InternalRos.g:5926:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) - int alt16=2; - int LA16_0 = input.LA(1); - - if ( ((LA16_0>='0' && LA16_0<='1')) ) { - alt16=1; - } - else if ( (LA16_0=='2') ) { - alt16=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 16, 0, input); - - throw nvae; - } - switch (alt16) { - case 1 : - // InternalRos.g:5926:23: '0' .. '1' '0' .. '9' - { - matchRange('0','1'); - matchRange('0','9'); - - } - break; - case 2 : - // InternalRos.g:5926:41: '2' '0' .. '3' - { - match('2'); - matchRange('0','3'); - - } - break; - - } - - - } - - } - finally { - } - } - // $ANTLR end "RULE_HOUR" - - // $ANTLR start "RULE_MIN_SEC" - public final void mRULE_MIN_SEC() throws RecognitionException { - try { - // InternalRos.g:5928:23: ( '0' .. '5' '0' .. '9' ) - // InternalRos.g:5928:25: '0' .. '5' '0' .. '9' - { - matchRange('0','5'); - matchRange('0','9'); - - } - - } - finally { - } - } - // $ANTLR end "RULE_MIN_SEC" - - // $ANTLR start "RULE_DATE_TIME" - public final void mRULE_DATE_TIME() throws RecognitionException { - try { - int _type = RULE_DATE_TIME; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:5930:16: ( RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC ) - // InternalRos.g:5930:18: RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC - { - mRULE_YEAR(); - match('-'); - mRULE_MONTH(); - match('-'); - mRULE_DAY(); - match('T'); - mRULE_HOUR(); - match(':'); - mRULE_MIN_SEC(); - match(':'); - mRULE_MIN_SEC(); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_DATE_TIME" - - // $ANTLR start "RULE_MESSAGE_ASIGMENT" - public final void mRULE_MESSAGE_ASIGMENT() throws RecognitionException { - try { - int _type = RULE_MESSAGE_ASIGMENT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:5932:23: ( ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) ) - // InternalRos.g:5932:25: ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) - { - // InternalRos.g:5932:25: ( RULE_ID | RULE_STRING ) - int alt17=2; - int LA17_0 = input.LA(1); - - if ( ((LA17_0>='A' && LA17_0<='Z')||(LA17_0>='^' && LA17_0<='_')||(LA17_0>='a' && LA17_0<='z')) ) { - alt17=1; - } - else if ( (LA17_0=='\"'||LA17_0=='\'') ) { - alt17=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 17, 0, input); - - throw nvae; - } - switch (alt17) { - case 1 : - // InternalRos.g:5932:26: RULE_ID - { - mRULE_ID(); - - } - break; - case 2 : - // InternalRos.g:5932:34: RULE_STRING - { - mRULE_STRING(); - - } - break; - - } - - match('='); - // InternalRos.g:5932:51: ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) - int alt18=4; - switch ( input.LA(1) ) { - case 'A': - case 'B': - case 'C': - case 'D': - case 'E': - case 'F': - case 'G': - case 'H': - case 'I': - case 'J': - case 'K': - case 'L': - case 'M': - case 'N': - case 'O': - case 'P': - case 'Q': - case 'R': - case 'S': - case 'T': - case 'U': - case 'V': - case 'W': - case 'X': - case 'Y': - case 'Z': - case '^': - case '_': - case 'a': - case 'b': - case 'c': - case 'd': - case 'e': - case 'f': - case 'g': - case 'h': - case 'i': - case 'j': - case 'k': - case 'l': - case 'm': - case 'n': - case 'o': - case 'p': - case 'q': - case 'r': - case 's': - case 't': - case 'u': - case 'v': - case 'w': - case 'x': - case 'y': - case 'z': - { - alt18=1; - } - break; - case '\"': - case '\'': - { - alt18=2; - } - break; - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - { - alt18=3; - } - break; - case '-': - { - alt18=4; - } - break; - default: - NoViableAltException nvae = - new NoViableAltException("", 18, 0, input); - - throw nvae; - } - - switch (alt18) { - case 1 : - // InternalRos.g:5932:52: RULE_ID - { - mRULE_ID(); - - } - break; - case 2 : - // InternalRos.g:5932:60: RULE_STRING - { - mRULE_STRING(); - - } - break; - case 3 : - // InternalRos.g:5932:72: RULE_INT - { - mRULE_INT(); - - } - break; - case 4 : - // InternalRos.g:5932:81: '-' RULE_INT - { - match('-'); - mRULE_INT(); - - } - break; - - } - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_MESSAGE_ASIGMENT" - - // $ANTLR start "RULE_ID" - public final void mRULE_ID() throws RecognitionException { - try { - int _type = RULE_ID; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:5934:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) - // InternalRos.g:5934:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* - { - // InternalRos.g:5934:11: ( '^' )? - int alt19=2; - int LA19_0 = input.LA(1); - - if ( (LA19_0=='^') ) { - alt19=1; - } - switch (alt19) { - case 1 : - // InternalRos.g:5934: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;} - - // InternalRos.g:5934:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* - loop20: - do { - int alt20=2; - int LA20_0 = input.LA(1); - - if ( ((LA20_0>='0' && LA20_0<='9')||(LA20_0>='A' && LA20_0<='Z')||LA20_0=='_'||(LA20_0>='a' && LA20_0<='z')) ) { - alt20=1; - } - - - switch (alt20) { - case 1 : - // InternalRos.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 loop20; - } - } 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 { - // InternalRos.g:5936:19: ( ( '0' .. '9' )+ ) - // InternalRos.g:5936:21: ( '0' .. '9' )+ - { - // InternalRos.g:5936:21: ( '0' .. '9' )+ - int cnt21=0; - loop21: - do { - int alt21=2; - int LA21_0 = input.LA(1); - - if ( ((LA21_0>='0' && LA21_0<='9')) ) { - alt21=1; - } - - - switch (alt21) { - case 1 : - // InternalRos.g:5936:22: '0' .. '9' - { - matchRange('0','9'); - - } - break; - - default : - if ( cnt21 >= 1 ) break loop21; - EarlyExitException eee = - new EarlyExitException(21, input); - throw eee; - } - cnt21++; - } while (true); - - - } - - } - 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; - // InternalRos.g:5938:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) - // InternalRos.g:5938:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) - { - // InternalRos.g:5938:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) - int alt24=2; - int LA24_0 = input.LA(1); - - if ( (LA24_0=='\"') ) { - alt24=1; - } - else if ( (LA24_0=='\'') ) { - alt24=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 24, 0, input); - - throw nvae; - } - switch (alt24) { - case 1 : - // InternalRos.g:5938:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' - { - match('\"'); - // InternalRos.g:5938:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* - loop22: - do { - int alt22=3; - int LA22_0 = input.LA(1); - - if ( (LA22_0=='\\') ) { - alt22=1; - } - else if ( ((LA22_0>='\u0000' && LA22_0<='!')||(LA22_0>='#' && LA22_0<='[')||(LA22_0>=']' && LA22_0<='\uFFFF')) ) { - alt22=2; - } - - - switch (alt22) { - case 1 : - // InternalRos.g:5938:21: '\\\\' . - { - match('\\'); - matchAny(); - - } - break; - case 2 : - // InternalRos.g:5938: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 loop22; - } - } while (true); - - match('\"'); - - } - break; - case 2 : - // InternalRos.g:5938:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' - { - match('\''); - // InternalRos.g:5938:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* - loop23: - do { - int alt23=3; - int LA23_0 = input.LA(1); - - if ( (LA23_0=='\\') ) { - alt23=1; - } - else if ( ((LA23_0>='\u0000' && LA23_0<='&')||(LA23_0>='(' && LA23_0<='[')||(LA23_0>=']' && LA23_0<='\uFFFF')) ) { - alt23=2; - } - - - switch (alt23) { - case 1 : - // InternalRos.g:5938:54: '\\\\' . - { - match('\\'); - matchAny(); - - } - break; - case 2 : - // InternalRos.g:5938: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 loop23; - } - } 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; - // InternalRos.g:5940:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) - // InternalRos.g:5940:19: '/*' ( options {greedy=false; } : . )* '*/' - { - match("/*"); - - // InternalRos.g:5940:24: ( options {greedy=false; } : . )* - loop25: - do { - int alt25=2; - int LA25_0 = input.LA(1); - - if ( (LA25_0=='*') ) { - int LA25_1 = input.LA(2); - - if ( (LA25_1=='/') ) { - alt25=2; - } - else if ( ((LA25_1>='\u0000' && LA25_1<='.')||(LA25_1>='0' && LA25_1<='\uFFFF')) ) { - alt25=1; - } - - - } - else if ( ((LA25_0>='\u0000' && LA25_0<=')')||(LA25_0>='+' && LA25_0<='\uFFFF')) ) { - alt25=1; - } - - - switch (alt25) { - case 1 : - // InternalRos.g:5940:52: . - { - matchAny(); - - } - break; - - default : - break loop25; - } - } while (true); - - match("*/"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_ML_COMMENT" - - // $ANTLR start "RULE_SL_COMMENT" - public final void mRULE_SL_COMMENT() throws RecognitionException { - try { - int _type = RULE_SL_COMMENT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:5942:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) - // InternalRos.g:5942:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? - { - match("//"); - - // InternalRos.g:5942:24: (~ ( ( '\\n' | '\\r' ) ) )* - loop26: - do { - int alt26=2; - int LA26_0 = input.LA(1); - - if ( ((LA26_0>='\u0000' && LA26_0<='\t')||(LA26_0>='\u000B' && LA26_0<='\f')||(LA26_0>='\u000E' && LA26_0<='\uFFFF')) ) { - alt26=1; - } - - - switch (alt26) { - case 1 : - // InternalRos.g:5942:24: ~ ( ( '\\n' | '\\r' ) ) - { - if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - default : - break loop26; - } - } while (true); - - // InternalRos.g:5942:40: ( ( '\\r' )? '\\n' )? - int alt28=2; - int LA28_0 = input.LA(1); - - if ( (LA28_0=='\n'||LA28_0=='\r') ) { - alt28=1; - } - switch (alt28) { - case 1 : - // InternalRos.g:5942:41: ( '\\r' )? '\\n' - { - // InternalRos.g:5942:41: ( '\\r' )? - int alt27=2; - int LA27_0 = input.LA(1); - - if ( (LA27_0=='\r') ) { - alt27=1; - } - switch (alt27) { - case 1 : - // InternalRos.g:5942:41: '\\r' - { - match('\r'); - - } - break; - - } - - match('\n'); - - } - break; - - } - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_SL_COMMENT" - - // $ANTLR start "RULE_WS" - public final void mRULE_WS() throws RecognitionException { - try { - int _type = RULE_WS; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalRos.g:5944:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) - // InternalRos.g:5944:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - { - // InternalRos.g:5944:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - int cnt29=0; - loop29: - do { - int alt29=2; - int LA29_0 = input.LA(1); - - if ( ((LA29_0>='\t' && LA29_0<='\n')||LA29_0=='\r'||LA29_0==' ') ) { - alt29=1; - } - - - switch (alt29) { - case 1 : - // InternalRos.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 ( cnt29 >= 1 ) break loop29; - EarlyExitException eee = - new EarlyExitException(29, input); - throw eee; - } - cnt29++; - } 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; - // InternalRos.g:5946:16: ( . ) - // InternalRos.g:5946:18: . - { - matchAny(); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_ANY_OTHER" - - public void mTokens() throws RecognitionException { - // InternalRos.g:1:8: ( T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | RULE_ROS_CONVENTION_A | RULE_ROS_CONVENTION_PARAM | RULE_BINARY | RULE_BOOLEAN | RULE_DOUBLE | RULE_DECINT | RULE_DATE_TIME | RULE_MESSAGE_ASIGMENT | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) - int alt30=103; - alt30 = dfa30.predict(input); - switch (alt30) { - case 1 : - // InternalRos.g:1:10: T__25 - { - mT__25(); - - } - break; - case 2 : - // InternalRos.g:1:16: T__26 - { - mT__26(); - - } - break; - case 3 : - // InternalRos.g:1:22: T__27 - { - mT__27(); - - } - break; - case 4 : - // InternalRos.g:1:28: T__28 - { - mT__28(); - - } - break; - case 5 : - // InternalRos.g:1:34: T__29 - { - mT__29(); - - } - break; - case 6 : - // InternalRos.g:1:40: T__30 - { - mT__30(); - - } - break; - case 7 : - // InternalRos.g:1:46: T__31 - { - mT__31(); - - } - break; - case 8 : - // InternalRos.g:1:52: T__32 - { - mT__32(); - - } - break; - case 9 : - // InternalRos.g:1:58: T__33 - { - mT__33(); - - } - break; - case 10 : - // InternalRos.g:1:64: T__34 - { - mT__34(); - - } - break; - case 11 : - // InternalRos.g:1:70: T__35 - { - mT__35(); - - } - break; - case 12 : - // InternalRos.g:1:76: T__36 - { - mT__36(); - - } - break; - case 13 : - // InternalRos.g:1:82: T__37 - { - mT__37(); - - } - break; - case 14 : - // InternalRos.g:1:88: T__38 - { - mT__38(); - - } - break; - case 15 : - // InternalRos.g:1:94: T__39 - { - mT__39(); - - } - break; - case 16 : - // InternalRos.g:1:100: T__40 - { - mT__40(); - - } - break; - case 17 : - // InternalRos.g:1:106: T__41 - { - mT__41(); - - } - break; - case 18 : - // InternalRos.g:1:112: T__42 - { - mT__42(); - - } - break; - case 19 : - // InternalRos.g:1:118: T__43 - { - mT__43(); - - } - break; - case 20 : - // InternalRos.g:1:124: T__44 - { - mT__44(); - - } - break; - case 21 : - // InternalRos.g:1:130: T__45 - { - mT__45(); - - } - break; - case 22 : - // InternalRos.g:1:136: T__46 - { - mT__46(); - - } - break; - case 23 : - // InternalRos.g:1:142: T__47 - { - mT__47(); - - } - break; - case 24 : - // InternalRos.g:1:148: T__48 - { - mT__48(); - - } - break; - case 25 : - // InternalRos.g:1:154: T__49 - { - mT__49(); - - } - break; - case 26 : - // InternalRos.g:1:160: T__50 - { - mT__50(); - - } - break; - case 27 : - // InternalRos.g:1:166: T__51 - { - mT__51(); - - } - break; - case 28 : - // InternalRos.g:1:172: T__52 - { - mT__52(); - - } - break; - case 29 : - // InternalRos.g:1:178: T__53 - { - mT__53(); - - } - break; - case 30 : - // InternalRos.g:1:184: T__54 - { - mT__54(); - - } - break; - case 31 : - // InternalRos.g:1:190: T__55 - { - mT__55(); - - } - break; - case 32 : - // InternalRos.g:1:196: T__56 - { - mT__56(); - - } - break; - case 33 : - // InternalRos.g:1:202: T__57 - { - mT__57(); - - } - break; - case 34 : - // InternalRos.g:1:208: T__58 - { - mT__58(); - - } - break; - case 35 : - // InternalRos.g:1:214: T__59 - { - mT__59(); - - } - break; - case 36 : - // InternalRos.g:1:220: T__60 - { - mT__60(); - - } - break; - case 37 : - // InternalRos.g:1:226: T__61 - { - mT__61(); - - } - break; - case 38 : - // InternalRos.g:1:232: T__62 - { - mT__62(); - - } - break; - case 39 : - // InternalRos.g:1:238: T__63 - { - mT__63(); - - } - break; - case 40 : - // InternalRos.g:1:244: T__64 - { - mT__64(); - - } - break; - case 41 : - // InternalRos.g:1:250: T__65 - { - mT__65(); - - } - break; - case 42 : - // InternalRos.g:1:256: T__66 - { - mT__66(); - - } - break; - case 43 : - // InternalRos.g:1:262: T__67 - { - mT__67(); - - } - break; - case 44 : - // InternalRos.g:1:268: T__68 - { - mT__68(); - - } - break; - case 45 : - // InternalRos.g:1:274: T__69 - { - mT__69(); - - } - break; - case 46 : - // InternalRos.g:1:280: T__70 - { - mT__70(); - - } - break; - case 47 : - // InternalRos.g:1:286: T__71 - { - mT__71(); - - } - break; - case 48 : - // InternalRos.g:1:292: T__72 - { - mT__72(); - - } - break; - case 49 : - // InternalRos.g:1:298: T__73 - { - mT__73(); - - } - break; - case 50 : - // InternalRos.g:1:304: T__74 - { - mT__74(); - - } - break; - case 51 : - // InternalRos.g:1:310: T__75 - { - mT__75(); - - } - break; - case 52 : - // InternalRos.g:1:316: T__76 - { - mT__76(); - - } - break; - case 53 : - // InternalRos.g:1:322: T__77 - { - mT__77(); - - } - break; - case 54 : - // InternalRos.g:1:328: T__78 - { - mT__78(); - - } - break; - case 55 : - // InternalRos.g:1:334: T__79 - { - mT__79(); - - } - break; - case 56 : - // InternalRos.g:1:340: T__80 - { - mT__80(); - - } - break; - case 57 : - // InternalRos.g:1:346: T__81 - { - mT__81(); - - } - break; - case 58 : - // InternalRos.g:1:352: T__82 - { - mT__82(); - - } - break; - case 59 : - // InternalRos.g:1:358: T__83 - { - mT__83(); - - } - break; - case 60 : - // InternalRos.g:1:364: T__84 - { - mT__84(); - - } - break; - case 61 : - // InternalRos.g:1:370: T__85 - { - mT__85(); - - } - break; - case 62 : - // InternalRos.g:1:376: T__86 - { - mT__86(); - - } - break; - case 63 : - // InternalRos.g:1:382: T__87 - { - mT__87(); - - } - break; - case 64 : - // InternalRos.g:1:388: T__88 - { - mT__88(); - - } - break; - case 65 : - // InternalRos.g:1:394: T__89 - { - mT__89(); - - } - break; - case 66 : - // InternalRos.g:1:400: T__90 - { - mT__90(); - - } - break; - case 67 : - // InternalRos.g:1:406: T__91 - { - mT__91(); - - } - break; - case 68 : - // InternalRos.g:1:412: T__92 - { - mT__92(); - - } - break; - case 69 : - // InternalRos.g:1:418: T__93 - { - mT__93(); - - } - break; - case 70 : - // InternalRos.g:1:424: T__94 - { - mT__94(); - - } - break; - case 71 : - // InternalRos.g:1:430: T__95 - { - mT__95(); - - } - break; - case 72 : - // InternalRos.g:1:436: T__96 - { - mT__96(); - - } - break; - case 73 : - // InternalRos.g:1:442: T__97 - { - mT__97(); - - } - break; - case 74 : - // InternalRos.g:1:448: T__98 - { - mT__98(); - - } - break; - case 75 : - // InternalRos.g:1:454: T__99 - { - mT__99(); - - } - break; - case 76 : - // InternalRos.g:1:460: T__100 - { - mT__100(); - - } - break; - case 77 : - // InternalRos.g:1:467: T__101 - { - mT__101(); - - } - break; - case 78 : - // InternalRos.g:1:474: T__102 - { - mT__102(); - - } - break; - case 79 : - // InternalRos.g:1:481: T__103 - { - mT__103(); - - } - break; - case 80 : - // InternalRos.g:1:488: T__104 - { - mT__104(); - - } - break; - case 81 : - // InternalRos.g:1:495: T__105 - { - mT__105(); - - } - break; - case 82 : - // InternalRos.g:1:502: T__106 - { - mT__106(); - - } - break; - case 83 : - // InternalRos.g:1:509: T__107 - { - mT__107(); - - } - break; - case 84 : - // InternalRos.g:1:516: T__108 - { - mT__108(); - - } - break; - case 85 : - // InternalRos.g:1:523: T__109 - { - mT__109(); - - } - break; - case 86 : - // InternalRos.g:1:530: T__110 - { - mT__110(); - - } - break; - case 87 : - // InternalRos.g:1:537: T__111 - { - mT__111(); - - } - break; - case 88 : - // InternalRos.g:1:544: T__112 - { - mT__112(); - - } - break; - case 89 : - // InternalRos.g:1:551: T__113 - { - mT__113(); - - } - break; - case 90 : - // InternalRos.g:1:558: RULE_ROS_CONVENTION_A - { - mRULE_ROS_CONVENTION_A(); - - } - break; - case 91 : - // InternalRos.g:1:580: RULE_ROS_CONVENTION_PARAM - { - mRULE_ROS_CONVENTION_PARAM(); - - } - break; - case 92 : - // InternalRos.g:1:606: RULE_BINARY - { - mRULE_BINARY(); - - } - break; - case 93 : - // InternalRos.g:1:618: RULE_BOOLEAN - { - mRULE_BOOLEAN(); - - } - break; - case 94 : - // InternalRos.g:1:631: RULE_DOUBLE - { - mRULE_DOUBLE(); - - } - break; - case 95 : - // InternalRos.g:1:643: RULE_DECINT - { - mRULE_DECINT(); - - } - break; - case 96 : - // InternalRos.g:1:655: RULE_DATE_TIME - { - mRULE_DATE_TIME(); - - } - break; - case 97 : - // InternalRos.g:1:670: RULE_MESSAGE_ASIGMENT - { - mRULE_MESSAGE_ASIGMENT(); - - } - break; - case 98 : - // InternalRos.g:1:692: RULE_ID - { - mRULE_ID(); - - } - break; - case 99 : - // InternalRos.g:1:700: RULE_STRING - { - mRULE_STRING(); - - } - break; - case 100 : - // InternalRos.g:1:712: RULE_ML_COMMENT - { - mRULE_ML_COMMENT(); - - } - break; - case 101 : - // InternalRos.g:1:728: RULE_SL_COMMENT - { - mRULE_SL_COMMENT(); - - } - break; - case 102 : - // InternalRos.g:1:744: RULE_WS - { - mRULE_WS(); - - } - break; - case 103 : - // InternalRos.g:1:752: RULE_ANY_OTHER - { - mRULE_ANY_OTHER(); - - } - break; - - } - - } - - - protected DFA10 dfa10 = new DFA10(this); - protected DFA30 dfa30 = new DFA30(this); - static final String DFA10_eotS = - "\1\uffff\1\4\1\uffff\1\4\1\uffff"; - static final String DFA10_eofS = - "\5\uffff"; - static final String DFA10_minS = - "\1\56\1\60\1\uffff\1\60\1\uffff"; - static final String DFA10_maxS = - "\2\145\1\uffff\1\145\1\uffff"; - static final String DFA10_acceptS = - "\2\uffff\1\2\1\uffff\1\1"; - static final String DFA10_specialS = - "\5\uffff}>"; - static final String[] DFA10_transitionS = { - "\1\1\26\uffff\1\2\37\uffff\1\2", - "\12\3\13\uffff\1\2\37\uffff\1\2", - "", - "\12\3\13\uffff\1\2\37\uffff\1\2", - "" - }; - - static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS); - static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS); - static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS); - static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS); - static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS); - static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS); - static final short[][] DFA10_transition; - - static { - int numStates = DFA10_transitionS.length; - DFA10_transition = new short[numStates][]; - for (int i=0; i"; - static final String[] DFA30_transitionS = { - "\11\56\2\55\2\56\1\55\22\56\1\55\1\56\1\46\4\56\1\47\4\56\1\3\1\53\1\56\1\42\1\51\2\52\7\54\7\56\1\10\1\34\1\11\1\12\1\25\1\5\1\24\1\15\1\32\2\44\1\31\1\44\1\21\1\44\1\1\1\44\1\27\1\6\1\14\6\44\1\41\2\56\1\43\1\44\1\56\1\23\1\36\1\44\1\33\1\44\1\20\1\17\1\44\1\37\3\44\1\16\1\7\1\44\1\26\1\44\1\13\1\22\1\30\1\40\1\35\4\44\1\2\1\56\1\4\1\50\uff81\56", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\57\20\62\1\61\2\62\1\60\5\62", - "", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\70\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\72\12\62\1\71\3\62\1\73\1\74\5\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\76\15\62\1\75\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\101\11\62\1\100\4\62\1\77\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\102\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\103\11\62\1\104\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\105\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\106\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\107\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\110\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\111\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\114\3\62\1\112\6\62\1\113\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\115\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\116\16\62\1\117\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\120\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\122\5\62\1\121\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\27\62\1\123\2\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\124\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\125\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\127\10\62\1\130\6\62\1\126\1\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\131\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\132\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\133\17\62\1\134\5\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\136\15\62\1\135\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\137\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\140\11\62\1\141\1\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\142\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\143\21\62", - "\1\144", - "\1\147\4\uffff\1\147\2\uffff\1\145\4\uffff\1\146\21\uffff\32\45\3\uffff\2\45\1\uffff\32\45", - "\32\150\4\uffff\1\150\1\uffff\32\150", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\42\152\1\153\71\152\1\151\uffa3\152", - "\47\155\1\156\64\155\1\154\uffa3\155", - "\1\147\4\uffff\1\147", - "\1\162\1\uffff\12\160\10\uffff\1\157\2\uffff\1\162\34\uffff\1\157\2\uffff\1\162", - "\1\162\1\uffff\12\163\13\uffff\1\162\37\uffff\1\162", - "\12\164", - "\1\162\1\uffff\12\165\13\uffff\1\162\37\uffff\1\162", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\167\16\62\1\170\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\171\30\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\172\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "", - "", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\173\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\174\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\175\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\176\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\177\30\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u0080\26\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u0081\15\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0083\1\62\1\u0082\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0084\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0085\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0086\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0087\12\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u0088\5\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\20\62\1\u0089\1\62\1\u008a\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u008b\12\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u008c\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u008d\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u008e\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u008f\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0090\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0091\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u0092\26\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0093\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0094\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0095\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0096\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0097\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0098\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0099\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u009a\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u009b\12\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u009c\15\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u009d\5\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u009e\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u009f\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u00a0\24\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u00a1\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u00a2\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00a3\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00a4\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u00a5\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00a6\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00a7\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u00a8\14\62", - "", - "", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\0\u00a9", - "\42\152\1\153\71\152\1\151\uffa3\152", - "\1\147\15\uffff\1\64", - "\0\u00ab", - "\47\155\1\156\64\155\1\154\uffa3\155", - "\1\147\15\uffff\1\64", - "", - "", - "", - "", - "\1\162\1\uffff\12\u00ac\13\uffff\1\162\37\uffff\1\162", - "\1\162\1\uffff\12\u00ad\13\uffff\1\162\37\uffff\1\162", - "\1\162\1\uffff\12\165\13\uffff\1\162\37\uffff\1\162", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\12\62\1\u00ae\17\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00af\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00b0\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u00b1\4\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u00b2\15\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u00b3\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u00b4\4\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00b5\13\62\1\u00b6\5\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00b7\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00b8\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00b9\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00ba\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00bb\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u00bc\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00bd\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\12\62\1\u00be\17\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00bf\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u00c0\30\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u00c1\5\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u00c2\4\62\1\u00c3\5\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00c4\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u00c5\26\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00c6\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00c7\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u00c8\26\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00c9\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00ca\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00cb\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u00cc\4\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00cd\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00ce\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u00cf\12\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u00d0\30\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00d1\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00d2\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00d3\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00d4\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00d5\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00d6\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00d7\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00d8\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00d9\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00da\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00db\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00dc\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u00dd\5\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00de\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00df\25\62", - "\1\45\1\62\1\u00e1\1\62\1\u00e2\2\62\1\u00e3\1\62\1\u00e0\1\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00e4\6\62", - "\42\152\1\153\71\152\1\151\uffa3\152", - "", - "\47\155\1\156\64\155\1\154\uffa3\155", - "\1\162\1\uffff\12\u00e5\13\uffff\1\162\37\uffff\1\162", - "\1\162\1\uffff\12\u00ad\13\uffff\1\162\37\uffff\1\162", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00e6\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u00e7\15\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00e8\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00e9\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\6\62\1\u00ea\23\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00eb\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00ec\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u00ed\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u00ee\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u00ef\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00f1\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u00f3\24\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u00f4\1\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00f5\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u00f6\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00f7\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u00f8\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00f9\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00fa\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u00fb\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00fc\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u00fd\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00fe\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00ff\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u0101\30\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0102\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0103\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0105\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0106\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0107\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\7\62\1\u0108\22\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0109\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u010a\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u010b\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u010c\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u0111\23\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u0112\5\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0113\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0114\25\62", - "\1\45\6\62\1\u0115\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0116\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u0117\3\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u0119\3\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u011b\3\uffff\1\62\1\uffff\32\62", - "\1\45\6\62\1\u011d\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\2\62\1\u011e\7\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\4\62\1\u011f\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\1\62\1\u0121\1\62\1\u0122\2\62\1\u0123\1\62\1\u0120\1\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\160\1\162\1\uffff\12\165\13\uffff\1\162\37\uffff\1\162", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u0124\23\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0125\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0126\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0127\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0128\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u012a\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u012b\23\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u012c\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u012d\10\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u012e\12\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u012f\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\17\62\1\u0131\12\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0132\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0133\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u0134\26\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0135\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0136\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0137\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0138\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\22\62\1\u0139\7\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u013a\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u013b\23\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u013c\31\62", - "\1\45\3\62\1\u013d\2\62\1\u013e\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u013f\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u0140\23\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0141\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\15\62\1\u0142\14\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0143\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0144\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0146\21\62", - "", - "", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0147\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0148\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0149\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u014a\31\62", - "\1\45\4\62\1\u014b\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "", - "", - "", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u014d\3\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u014f\3\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u0151\3\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u0153\3\uffff\1\62\1\uffff\32\62", - "\1\45\6\62\1\u0155\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\2\62\1\u0156\7\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\4\62\1\u0157\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0158\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0159\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\7\62\1\u015a\22\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u015b\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u015c\6\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u015d\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0160\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0161\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0162\27\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0163\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\2\62\1\u0165\17\62\1\u0164\7\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\17\62\1\u0166\12\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0167\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0169\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u016a\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u016c\12\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u016e\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u016f\27\62", - "\1\45\2\62\1\u0170\7\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\4\62\1\u0171\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0172\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u0173\3\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0176\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\15\62\1\u0177\14\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0178\31\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u0179\4\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u017a\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u017b\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u017c\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u017d\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u017f\3\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u0181\3\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u0183\3\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\22\62\1\u0185\7\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0187\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0188\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\15\62\1\u0189\14\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\21\62\1\u018a\10\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\2\62\1\u018c\17\62\1\u018b\7\62\4\uffff\1\62\1\uffff\32\62", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u018d\30\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u018e\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u018f\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0190\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0192\12\62\1\u0191\12\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0193\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0194\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0195\14\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0197\25\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0198\25\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\12\62\1\u019a\17\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u019b\3\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\1\u019d\3\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u01a0\15\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u01a1\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01a2\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01a3\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01a6\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "", - "", - "", - "", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01a8\25\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01a9\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01aa\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u01ab\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01ac\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01ae\12\62\1\u01ad\12\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01af\16\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01b0\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01b1\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\12\62\1\u01b3\17\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01b4\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01b5\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u01b6\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u01b7\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u01b8\27\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u01ba\27\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "", - "", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01bc\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u01bd\15\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\3\62\1\u01be\26\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\15\62\1\u01bf\14\62\4\uffff\1\62\1\uffff\32\62", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u01c1\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\1\u01c3\21\62\1\u01c4\7\62\4\uffff\1\62\1\uffff\22\62\1\u01c2\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u01c6\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u01c8\15\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u01c9\12\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01ca\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01cb\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u01cc\21\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01cd\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u01cf\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u01d0\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u01d1\4\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01d2\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\12\62\1\u01d3\17\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u01d4\21\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01d7\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01d8\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u01d9\31\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01dc\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u01dd\6\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01df\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u01e0\13\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u01e1\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u01e2\4\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01e3\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u01e4\7\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u01e6\23\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01e8\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01e9\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u01ea\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01eb\25\62", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u01ec\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u01ed\12\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u01ee\15\62", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u01ef\1\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01f0\10\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u01f1\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01f4\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01f5\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01f7\25\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01f8\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u01f9\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u01fa\23\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u01fb\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u01fc\12\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01fd\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01fe\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u0200\5\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0201\12\62", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0202\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0203\6\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0205\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0207\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0209\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u020b\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u020c\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u020d\7\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u020e\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u020f\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0210\7\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0212\7\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0217\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u0218\26\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0219\12\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u021a\6\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u021b\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u021e\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u021f\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0220\31\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\14\62\1\u0221\15\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0222\25\62", - "", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0224\14\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0225\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0226\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0228\27\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0229\25\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u022a\15\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u022b\1\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u022d\30\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u022f\25\62", - "", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0230\10\62", - "\1\45\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", - "" - }; - - static final short[] DFA30_eot = DFA.unpackEncodedString(DFA30_eotS); - static final short[] DFA30_eof = DFA.unpackEncodedString(DFA30_eofS); - static final char[] DFA30_min = DFA.unpackEncodedStringToUnsignedChars(DFA30_minS); - static final char[] DFA30_max = DFA.unpackEncodedStringToUnsignedChars(DFA30_maxS); - static final short[] DFA30_accept = DFA.unpackEncodedString(DFA30_acceptS); - static final short[] DFA30_special = DFA.unpackEncodedString(DFA30_specialS); - static final short[][] DFA30_transition; - - static { - int numStates = DFA30_transitionS.length; - DFA30_transition = new short[numStates][]; - for (int i=0; i='\u0000' && LA30_39<='&')||(LA30_39>='(' && LA30_39<='[')||(LA30_39>=']' && LA30_39<='\uFFFF')) ) {s = 109;} - - else if ( (LA30_39=='\'') ) {s = 110;} - - else s = 46; - - if ( s>=0 ) return s; - break; - case 1 : - int LA30_105 = input.LA(1); - - s = -1; - if ( ((LA30_105>='\u0000' && LA30_105<='\uFFFF')) ) {s = 169;} - - if ( s>=0 ) return s; - break; - case 2 : - int LA30_171 = input.LA(1); - - s = -1; - if ( (LA30_171=='\'') ) {s = 110;} - - else if ( (LA30_171=='\\') ) {s = 108;} - - else if ( ((LA30_171>='\u0000' && LA30_171<='&')||(LA30_171>='(' && LA30_171<='[')||(LA30_171>=']' && LA30_171<='\uFFFF')) ) {s = 109;} - - if ( s>=0 ) return s; - break; - case 3 : - int LA30_108 = input.LA(1); - - s = -1; - if ( ((LA30_108>='\u0000' && LA30_108<='\uFFFF')) ) {s = 171;} - - if ( s>=0 ) return s; - break; - case 4 : - int LA30_109 = input.LA(1); - - s = -1; - if ( (LA30_109=='\'') ) {s = 110;} - - else if ( (LA30_109=='\\') ) {s = 108;} - - else if ( ((LA30_109>='\u0000' && LA30_109<='&')||(LA30_109>='(' && LA30_109<='[')||(LA30_109>=']' && LA30_109<='\uFFFF')) ) {s = 109;} - - if ( s>=0 ) return s; - break; - case 5 : - int LA30_0 = input.LA(1); - - s = -1; - if ( (LA30_0=='P') ) {s = 1;} - - else if ( (LA30_0=='{') ) {s = 2;} - - else if ( (LA30_0==',') ) {s = 3;} - - else if ( (LA30_0=='}') ) {s = 4;} - - else if ( (LA30_0=='F') ) {s = 5;} - - else if ( (LA30_0=='S') ) {s = 6;} - - else if ( (LA30_0=='n') ) {s = 7;} - - else if ( (LA30_0=='A') ) {s = 8;} - - else if ( (LA30_0=='C') ) {s = 9;} - - else if ( (LA30_0=='D') ) {s = 10;} - - else if ( (LA30_0=='r') ) {s = 11;} - - else if ( (LA30_0=='T') ) {s = 12;} - - else if ( (LA30_0=='H') ) {s = 13;} - - else if ( (LA30_0=='m') ) {s = 14;} - - else if ( (LA30_0=='g') ) {s = 15;} - - else if ( (LA30_0=='f') ) {s = 16;} - - else if ( (LA30_0=='N') ) {s = 17;} - - else if ( (LA30_0=='s') ) {s = 18;} - - else if ( (LA30_0=='a') ) {s = 19;} - - else if ( (LA30_0=='G') ) {s = 20;} - - else if ( (LA30_0=='E') ) {s = 21;} - - else if ( (LA30_0=='p') ) {s = 22;} - - else if ( (LA30_0=='R') ) {s = 23;} - - else if ( (LA30_0=='t') ) {s = 24;} - - else if ( (LA30_0=='L') ) {s = 25;} - - else if ( (LA30_0=='I') ) {s = 26;} - - else if ( (LA30_0=='d') ) {s = 27;} - - else if ( (LA30_0=='B') ) {s = 28;} - - else if ( (LA30_0=='v') ) {s = 29;} - - else if ( (LA30_0=='b') ) {s = 30;} - - else if ( (LA30_0=='i') ) {s = 31;} - - else if ( (LA30_0=='u') ) {s = 32;} - - else if ( (LA30_0=='[') ) {s = 33;} - - else if ( (LA30_0=='/') ) {s = 34;} - - else if ( (LA30_0=='^') ) {s = 35;} - - else if ( ((LA30_0>='J' && LA30_0<='K')||LA30_0=='M'||LA30_0=='O'||LA30_0=='Q'||(LA30_0>='U' && LA30_0<='Z')||LA30_0=='_'||LA30_0=='c'||LA30_0=='e'||LA30_0=='h'||(LA30_0>='j' && LA30_0<='l')||LA30_0=='o'||LA30_0=='q'||(LA30_0>='w' && LA30_0<='z')) ) {s = 36;} - - else if ( (LA30_0=='\"') ) {s = 38;} - - else if ( (LA30_0=='\'') ) {s = 39;} - - else if ( (LA30_0=='~') ) {s = 40;} - - else if ( (LA30_0=='0') ) {s = 41;} - - else if ( ((LA30_0>='1' && LA30_0<='2')) ) {s = 42;} - - else if ( (LA30_0=='-') ) {s = 43;} - - else if ( ((LA30_0>='3' && LA30_0<='9')) ) {s = 44;} - - else if ( ((LA30_0>='\t' && LA30_0<='\n')||LA30_0=='\r'||LA30_0==' ') ) {s = 45;} - - else if ( ((LA30_0>='\u0000' && LA30_0<='\b')||(LA30_0>='\u000B' && LA30_0<='\f')||(LA30_0>='\u000E' && LA30_0<='\u001F')||LA30_0=='!'||(LA30_0>='#' && LA30_0<='&')||(LA30_0>='(' && LA30_0<='+')||LA30_0=='.'||(LA30_0>=':' && LA30_0<='@')||(LA30_0>='\\' && LA30_0<=']')||LA30_0=='`'||LA30_0=='|'||(LA30_0>='\u007F' && LA30_0<='\uFFFF')) ) {s = 46;} - - else s = 37; - - if ( s>=0 ) return s; - break; - case 6 : - int LA30_38 = input.LA(1); - - s = -1; - if ( (LA30_38=='\\') ) {s = 105;} - - else if ( ((LA30_38>='\u0000' && LA30_38<='!')||(LA30_38>='#' && LA30_38<='[')||(LA30_38>=']' && LA30_38<='\uFFFF')) ) {s = 106;} - - else if ( (LA30_38=='\"') ) {s = 107;} - - else s = 46; - - if ( s>=0 ) return s; - break; - case 7 : - int LA30_169 = input.LA(1); - - s = -1; - if ( (LA30_169=='\"') ) {s = 107;} - - else if ( (LA30_169=='\\') ) {s = 105;} - - else if ( ((LA30_169>='\u0000' && LA30_169<='!')||(LA30_169>='#' && LA30_169<='[')||(LA30_169>=']' && LA30_169<='\uFFFF')) ) {s = 106;} - - if ( s>=0 ) return s; - break; - case 8 : - int LA30_106 = input.LA(1); - - s = -1; - if ( (LA30_106=='\"') ) {s = 107;} - - else if ( (LA30_106=='\\') ) {s = 105;} - - else if ( ((LA30_106>='\u0000' && LA30_106<='!')||(LA30_106>='#' && LA30_106<='[')||(LA30_106>=']' && LA30_106<='\uFFFF')) ) {s = 106;} - - if ( s>=0 ) return s; - break; - } - NoViableAltException nvae = - new NoViableAltException(getDescription(), 30, _s, input); - error(nvae); - throw nvae; - } - } - - -} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosParser.g b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosParser.g new file mode 100644 index 000000000..b2e06e373 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosParser.g @@ -0,0 +1,5141 @@ +/* + * generated by Xtext 2.25.0 + */ +parser grammar InternalRosParser; + +options { + tokenVocab=InternalRosLexer; + superClass=AbstractInternalAntlrParser; +} + +@header { +package de.fraunhofer.ipa.ros.parser.antlr.internal; + +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; +import de.fraunhofer.ipa.ros.services.RosGrammarAccess; + +} + +@members { + + private RosGrammarAccess grammarAccess; + + public InternalRosParser(TokenStream input, RosGrammarAccess grammarAccess) { + this(input); + this.grammarAccess = grammarAccess; + registerRules(grammarAccess.getGrammar()); + } + + @Override + protected String getFirstRuleName() { + return "PackageSet"; + } + + @Override + protected RosGrammarAccess getGrammarAccess() { + return grammarAccess; + } + +} + +@rulecatch { + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } +} + +// Entry rule entryRulePackageSet +entryRulePackageSet returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPackageSetRule()); } + iv_rulePackageSet=rulePackageSet + { $current=$iv_rulePackageSet.current; } + EOF; + +// Rule PackageSet +rulePackageSet returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getPackageSetAccess().getPackageSetAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getPackageSetAccess().getPackagePackage_ImplParserRuleCall_1_0()); + } + lv_package_1_0=rulePackage_Impl + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackageSetRule()); + } + add( + $current, + "package", + lv_package_1_0, + "de.fraunhofer.ipa.ros.Ros.Package_Impl"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) +; + +// Entry rule entryRuleEString +entryRuleEString returns [String current=null]: + { newCompositeNode(grammarAccess.getEStringRule()); } + iv_ruleEString=ruleEString + { $current=$iv_ruleEString.current.getText(); } + EOF; + +// Rule EString +ruleEString returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + this_STRING_0=RULE_STRING + { + $current.merge(this_STRING_0); + } + { + newLeafNode(this_STRING_0, grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + } + | + this_ID_1=RULE_ID + { + $current.merge(this_ID_1); + } + { + newLeafNode(this_ID_1, grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); + } + ) +; + +// Entry rule entryRuleRosNames +entryRuleRosNames returns [String current=null]: + { newCompositeNode(grammarAccess.getRosNamesRule()); } + iv_ruleRosNames=ruleRosNames + { $current=$iv_ruleRosNames.current.getText(); } + EOF; + +// Rule RosNames +ruleRosNames returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + this_ROS_CONVENTION_A_0=RULE_ROS_CONVENTION_A + { + $current.merge(this_ROS_CONVENTION_A_0); + } + { + newLeafNode(this_ROS_CONVENTION_A_0, grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); + } + | + this_ID_1=RULE_ID + { + $current.merge(this_ID_1); + } + { + newLeafNode(this_ID_1, grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); + } + | + kw=Node + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getRosNamesAccess().getNodeKeyword_2()); + } + ) +; + +// Entry rule entryRulePackage_Impl +entryRulePackage_Impl returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPackage_ImplRule()); } + iv_rulePackage_Impl=rulePackage_Impl + { $current=$iv_rulePackage_Impl.current; } + EOF; + +// Rule Package_Impl +rulePackage_Impl returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getPackage_ImplAccess().getPackageAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); + } + lv_name_1_0=ruleRosNames + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); + } + ( + otherlv_4=FromGitRepo + { + newLeafNode(otherlv_4, grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + } + lv_fromGitRepo_5_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + set( + $current, + "fromGitRepo", + lv_fromGitRepo_5_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ( + otherlv_6=Specs + { + newLeafNode(otherlv_6, grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + } + this_BEGIN_7=RULE_BEGIN + { + newLeafNode(this_BEGIN_7, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); + } + lv_spec_8_0=ruleSpecBase + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + $current, + "spec", + lv_spec_8_0, + "de.fraunhofer.ipa.ros.Ros.SpecBase"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_9=RULE_END + { + newLeafNode(this_END_9, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); + } + )? + ( + otherlv_10=Dependencies + { + newLeafNode(otherlv_10, grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); + } + otherlv_11=LeftSquareBracket + { + newLeafNode(otherlv_11, grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); + } + lv_dependency_12_0=ruleDependency + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + $current, + "dependency", + lv_dependency_12_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_13=Comma + { + newLeafNode(otherlv_13, grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + } + lv_dependency_14_0=ruleDependency + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + $current, + "dependency", + lv_dependency_14_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_15=RightSquareBracket + { + newLeafNode(otherlv_15, grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); + } + )? + this_END_16=RULE_END + { + newLeafNode(this_END_16, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleArtifact +entryRuleArtifact returns [EObject current=null]: + { newCompositeNode(grammarAccess.getArtifactRule()); } + iv_ruleArtifact=ruleArtifact + { $current=$iv_ruleArtifact.current; } + EOF; + +// Rule Artifact +ruleArtifact returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getArtifactAccess().getArtifactAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); + } + lv_name_1_0=ruleRosNames + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getArtifactRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getArtifactAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); + } + ( + ( + { + newCompositeNode(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); + } + lv_node_4_0=ruleNode + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getArtifactRule()); + } + set( + $current, + "node", + lv_node_4_0, + "de.fraunhofer.ipa.ros.Ros.Node"); + afterParserOrEnumRuleCall(); + } + ) + )? + this_END_5=RULE_END + { + newLeafNode(this_END_5, grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); + } + ) +; + +// Entry rule entryRuleNode +entryRuleNode returns [EObject current=null]: + { newCompositeNode(grammarAccess.getNodeRule()); } + iv_ruleNode=ruleNode + { $current=$iv_ruleNode.current; } + EOF; + +// Rule Node +ruleNode returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0=Node_1 + { + newLeafNode(otherlv_0, grammarAccess.getNodeAccess().getNodeKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); + } + lv_name_1_0=ruleRosNames + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_BEGIN_2=RULE_BEGIN + { + newLeafNode(this_BEGIN_2, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); + } + ( + ( + otherlv_3=Publishers + { + newLeafNode(otherlv_3, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); + } + this_BEGIN_4=RULE_BEGIN + { + newLeafNode(this_BEGIN_4, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); + } + lv_publisher_5_0=rulePublisher + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "publisher", + lv_publisher_5_0, + "de.fraunhofer.ipa.ros.Ros.Publisher"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_6=RULE_END + { + newLeafNode(this_END_6, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); + } + ) + | + ( + otherlv_7=Subscribers + { + newLeafNode(otherlv_7, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); + } + this_BEGIN_8=RULE_BEGIN + { + newLeafNode(this_BEGIN_8, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); + } + lv_subscriber_9_0=ruleSubscriber + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "subscriber", + lv_subscriber_9_0, + "de.fraunhofer.ipa.ros.Ros.Subscriber"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_10=RULE_END + { + newLeafNode(this_END_10, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); + } + ) + | + ( + otherlv_11=Serviceserver + { + newLeafNode(otherlv_11, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); + } + this_BEGIN_12=RULE_BEGIN + { + newLeafNode(this_BEGIN_12, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); + } + lv_serviceserver_13_0=ruleServiceServer + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "serviceserver", + lv_serviceserver_13_0, + "de.fraunhofer.ipa.ros.Ros.ServiceServer"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_14=RULE_END + { + newLeafNode(this_END_14, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); + } + ) + | + ( + otherlv_15=Serviceclient + { + newLeafNode(otherlv_15, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); + } + this_BEGIN_16=RULE_BEGIN + { + newLeafNode(this_BEGIN_16, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); + } + lv_serviceclient_17_0=ruleServiceClient + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "serviceclient", + lv_serviceclient_17_0, + "de.fraunhofer.ipa.ros.Ros.ServiceClient"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_18=RULE_END + { + newLeafNode(this_END_18, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); + } + ) + | + ( + otherlv_19=Actionserver + { + newLeafNode(otherlv_19, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); + } + this_BEGIN_20=RULE_BEGIN + { + newLeafNode(this_BEGIN_20, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); + } + lv_actionserver_21_0=ruleActionServer + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "actionserver", + lv_actionserver_21_0, + "de.fraunhofer.ipa.ros.Ros.ActionServer"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_22=RULE_END + { + newLeafNode(this_END_22, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); + } + ) + | + ( + otherlv_23=Actionclient + { + newLeafNode(otherlv_23, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); + } + this_BEGIN_24=RULE_BEGIN + { + newLeafNode(this_BEGIN_24, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); + } + lv_actionclient_25_0=ruleActionClient + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "actionclient", + lv_actionclient_25_0, + "de.fraunhofer.ipa.ros.Ros.ActionClient"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_26=RULE_END + { + newLeafNode(this_END_26, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); + } + ) + | + ( + otherlv_27=Parameters + { + newLeafNode(otherlv_27, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); + } + this_BEGIN_28=RULE_BEGIN + { + newLeafNode(this_BEGIN_28, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); + } + lv_parameter_29_0=ruleParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "parameter", + lv_parameter_29_0, + "de.fraunhofer.ipa.ros.Ros.Parameter"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_30=RULE_END + { + newLeafNode(this_END_30, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); + } + ) + )* + this_END_31=RULE_END + { + newLeafNode(this_END_31, grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); + } + ) +; + +// Entry rule entryRuleSpecBase +entryRuleSpecBase returns [EObject current=null]: + { newCompositeNode(grammarAccess.getSpecBaseRule()); } + iv_ruleSpecBase=ruleSpecBase + { $current=$iv_ruleSpecBase.current; } + EOF; + +// Rule SpecBase +ruleSpecBase returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); + } + this_TopicSpec_0=ruleTopicSpec + { + $current = $this_TopicSpec_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); + } + this_ServiceSpec_1=ruleServiceSpec + { + $current = $this_ServiceSpec_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); + } + this_ActionSpec_2=ruleActionSpec + { + $current = $this_ActionSpec_2.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleTopicSpec +entryRuleTopicSpec returns [EObject current=null]: + { newCompositeNode(grammarAccess.getTopicSpecRule()); } + iv_ruleTopicSpec=ruleTopicSpec + { $current=$iv_ruleTopicSpec.current; } + EOF; + +// Rule TopicSpec +ruleTopicSpec returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getTopicSpecAccess().getTopicSpecAction_0(), + $current); + } + ) + otherlv_1=Msg + { + newLeafNode(otherlv_1, grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + } + lv_name_2_1=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getTopicSpecRule()); + } + set( + $current, + "name", + lv_name_2_1, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + | + lv_name_2_2=Header + { + newLeafNode(lv_name_2_2, grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getTopicSpecRule()); + } + setWithLastConsumed($current, "name", lv_name_2_2, null); + } + | + lv_name_2_3=String + { + newLeafNode(lv_name_2_3, grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getTopicSpecRule()); + } + setWithLastConsumed($current, "name", lv_name_2_3, null); + } + ) + ) + ) + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Message_1 + { + newLeafNode(otherlv_4, grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); + } + ( + this_BEGIN_5=RULE_BEGIN + { + newLeafNode(this_BEGIN_5, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); + } + lv_message_6_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getTopicSpecRule()); + } + set( + $current, + "message", + lv_message_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_7=RULE_END + { + newLeafNode(this_END_7, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); + } + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); + } + ) +; + +// Entry rule entryRuleServiceSpec +entryRuleServiceSpec returns [EObject current=null]: + { newCompositeNode(grammarAccess.getServiceSpecRule()); } + iv_ruleServiceSpec=ruleServiceSpec + { $current=$iv_ruleServiceSpec.current; } + EOF; + +// Rule ServiceSpec +ruleServiceSpec returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getServiceSpecAccess().getServiceSpecAction_0(), + $current); + } + ) + otherlv_1=Srv + { + newLeafNode(otherlv_1, grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); + } + lv_name_2_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + $current, + "name", + lv_name_2_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Request + { + newLeafNode(otherlv_4, grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); + } + ( + this_BEGIN_5=RULE_BEGIN + { + newLeafNode(this_BEGIN_5, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); + } + lv_request_6_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + $current, + "request", + lv_request_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_7=RULE_END + { + newLeafNode(this_END_7, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); + } + )? + otherlv_8=Response + { + newLeafNode(otherlv_8, grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); + } + ( + this_BEGIN_9=RULE_BEGIN + { + newLeafNode(this_BEGIN_9, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); + } + lv_response_10_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + $current, + "response", + lv_response_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_11=RULE_END + { + newLeafNode(this_END_11, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); + } + )? + this_END_12=RULE_END + { + newLeafNode(this_END_12, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); + } + ) +; + +// Entry rule entryRuleActionSpec +entryRuleActionSpec returns [EObject current=null]: + { newCompositeNode(grammarAccess.getActionSpecRule()); } + iv_ruleActionSpec=ruleActionSpec + { $current=$iv_ruleActionSpec.current; } + EOF; + +// Rule ActionSpec +ruleActionSpec returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getActionSpecAccess().getActionSpecAction_0(), + $current); + } + ) + otherlv_1=Action_1 + { + newLeafNode(otherlv_1, grammarAccess.getActionSpecAccess().getActionKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + } + lv_name_2_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + $current, + "name", + lv_name_2_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Goal_1 + { + newLeafNode(otherlv_4, grammarAccess.getActionSpecAccess().getGoalKeyword_4()); + } + ( + this_BEGIN_5=RULE_BEGIN + { + newLeafNode(this_BEGIN_5, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); + } + lv_goal_6_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + $current, + "goal", + lv_goal_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_7=RULE_END + { + newLeafNode(this_END_7, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); + } + )? + otherlv_8=Result_1 + { + newLeafNode(otherlv_8, grammarAccess.getActionSpecAccess().getResultKeyword_6()); + } + ( + this_BEGIN_9=RULE_BEGIN + { + newLeafNode(this_BEGIN_9, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); + } + lv_result_10_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + $current, + "result", + lv_result_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_11=RULE_END + { + newLeafNode(this_END_11, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); + } + )? + otherlv_12=Feedback_1 + { + newLeafNode(otherlv_12, grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + } + ( + this_BEGIN_13=RULE_BEGIN + { + newLeafNode(this_BEGIN_13, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); + } + lv_feedback_14_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + $current, + "feedback", + lv_feedback_14_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_15=RULE_END + { + newLeafNode(this_END_15, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); + } + )? + this_END_16=RULE_END + { + newLeafNode(this_END_16, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); + } + ) +; + +// Entry rule entryRuleMessageDefinition +entryRuleMessageDefinition returns [EObject current=null]: + { newCompositeNode(grammarAccess.getMessageDefinitionRule()); } + iv_ruleMessageDefinition=ruleMessageDefinition + { $current=$iv_ruleMessageDefinition.current; } + EOF; + +// Rule MessageDefinition +ruleMessageDefinition returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); + } + lv_MessagePart_1_0=ruleMessagePart + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getMessageDefinitionRule()); + } + add( + $current, + "MessagePart", + lv_MessagePart_1_0, + "de.fraunhofer.ipa.ros.Ros.MessagePart"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) +; + +// Entry rule entryRulePublisher +entryRulePublisher returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPublisherRule()); } + iv_rulePublisher=rulePublisher + { $current=$iv_rulePublisher.current; } + EOF; + +// Rule Publisher +rulePublisher returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getPublisherAccess().getPublisherAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPublisherRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getPublisherAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getPublisherAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getPublisherRule()); + } + } + { + newCompositeNode(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getPublisherAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPublisherRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleSubscriber +entryRuleSubscriber returns [EObject current=null]: + { newCompositeNode(grammarAccess.getSubscriberRule()); } + iv_ruleSubscriber=ruleSubscriber + { $current=$iv_ruleSubscriber.current; } + EOF; + +// Rule Subscriber +ruleSubscriber returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getSubscriberAccess().getSubscriberAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getSubscriberRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getSubscriberAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getSubscriberAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getSubscriberRule()); + } + } + { + newCompositeNode(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getSubscriberRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleServiceServer +entryRuleServiceServer returns [EObject current=null]: + { newCompositeNode(grammarAccess.getServiceServerRule()); } + iv_ruleServiceServer=ruleServiceServer + { $current=$iv_ruleServiceServer.current; } + EOF; + +// Rule ServiceServer +ruleServiceServer returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getServiceServerAccess().getServiceServerAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceServerRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getServiceServerAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getServiceServerAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getServiceServerRule()); + } + } + { + newCompositeNode(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceServerRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleServiceClient +entryRuleServiceClient returns [EObject current=null]: + { newCompositeNode(grammarAccess.getServiceClientRule()); } + iv_ruleServiceClient=ruleServiceClient + { $current=$iv_ruleServiceClient.current; } + EOF; + +// Rule ServiceClient +ruleServiceClient returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getServiceClientAccess().getServiceClientAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceClientRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getServiceClientAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getServiceClientAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getServiceClientRule()); + } + } + { + newCompositeNode(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceClientRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleActionServer +entryRuleActionServer returns [EObject current=null]: + { newCompositeNode(grammarAccess.getActionServerRule()); } + iv_ruleActionServer=ruleActionServer + { $current=$iv_ruleActionServer.current; } + EOF; + +// Rule ActionServer +ruleActionServer returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getActionServerAccess().getActionServerAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionServerRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getActionServerAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getActionServerAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getActionServerRule()); + } + } + { + newCompositeNode(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getActionServerAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionServerRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleActionClient +entryRuleActionClient returns [EObject current=null]: + { newCompositeNode(grammarAccess.getActionClientRule()); } + iv_ruleActionClient=ruleActionClient + { $current=$iv_ruleActionClient.current; } + EOF; + +// Rule ActionClient +ruleActionClient returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getActionClientAccess().getActionClientAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionClientRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getActionClientAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getActionClientAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getActionClientRule()); + } + } + { + newCompositeNode(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getActionClientAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionClientRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleDependency +entryRuleDependency returns [EObject current=null]: + { newCompositeNode(grammarAccess.getDependencyRule()); } + iv_ruleDependency=ruleDependency + { $current=$iv_ruleDependency.current; } + EOF; + +// Rule Dependency +ruleDependency returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + } + this_PackageDependency_0=rulePackageDependency + { + $current = $this_PackageDependency_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); + } + this_ExternalDependency_1=ruleExternalDependency + { + $current = $this_ExternalDependency_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRulePackageDependency +entryRulePackageDependency returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPackageDependencyRule()); } + iv_rulePackageDependency=rulePackageDependency + { $current=$iv_rulePackageDependency.current; } + EOF; + +// Rule PackageDependency +rulePackageDependency returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getPackageDependencyRule()); + } + } + { + newCompositeNode(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleExternalDependency +entryRuleExternalDependency returns [EObject current=null]: + { newCompositeNode(grammarAccess.getExternalDependencyRule()); } + iv_ruleExternalDependency=ruleExternalDependency + { $current=$iv_ruleExternalDependency.current; } + EOF; + +// Rule ExternalDependency +ruleExternalDependency returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0(), + $current); + } + ) + otherlv_1=ExternalDependency + { + newLeafNode(otherlv_1, grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getExternalDependencyAccess().getNameEStringParserRuleCall_2_0()); + } + lv_name_2_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getExternalDependencyRule()); + } + set( + $current, + "name", + lv_name_2_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleNamespace +entryRuleNamespace returns [EObject current=null]: + { newCompositeNode(grammarAccess.getNamespaceRule()); } + iv_ruleNamespace=ruleNamespace + { $current=$iv_ruleNamespace.current; } + EOF; + +// Rule Namespace +ruleNamespace returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + } + this_GlobalNamespace_0=ruleGlobalNamespace + { + $current = $this_GlobalNamespace_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + } + this_RelativeNamespace_Impl_1=ruleRelativeNamespace_Impl + { + $current = $this_RelativeNamespace_Impl_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + } + this_PrivateNamespace_2=rulePrivateNamespace + { + $current = $this_PrivateNamespace_2.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleGraphName +entryRuleGraphName returns [String current=null]: + { newCompositeNode(grammarAccess.getGraphNameRule()); } + iv_ruleGraphName=ruleGraphName + { $current=$iv_ruleGraphName.current.getText(); } + EOF; + +// Rule GraphName +ruleGraphName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw=GraphName + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + } +; + +// Entry rule entryRuleGlobalNamespace +entryRuleGlobalNamespace returns [EObject current=null]: + { newCompositeNode(grammarAccess.getGlobalNamespaceRule()); } + iv_ruleGlobalNamespace=ruleGlobalNamespace + { $current=$iv_ruleGlobalNamespace.current; } + EOF; + +// Rule GlobalNamespace +ruleGlobalNamespace returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0(), + $current); + } + ) + otherlv_1=GlobalNamespace + { + newLeafNode(otherlv_1, grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); + } + ( + otherlv_2=LeftSquareBracket + { + newLeafNode(otherlv_2, grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + } + lv_parts_3_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getGlobalNamespaceRule()); + } + add( + $current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Comma + { + newLeafNode(otherlv_4, grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + } + lv_parts_5_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getGlobalNamespaceRule()); + } + add( + $current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); + } + )? + ) +; + +// Entry rule entryRuleRelativeNamespace_Impl +entryRuleRelativeNamespace_Impl returns [EObject current=null]: + { newCompositeNode(grammarAccess.getRelativeNamespace_ImplRule()); } + iv_ruleRelativeNamespace_Impl=ruleRelativeNamespace_Impl + { $current=$iv_ruleRelativeNamespace_Impl.current; } + EOF; + +// Rule RelativeNamespace_Impl +ruleRelativeNamespace_Impl returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0(), + $current); + } + ) + otherlv_1=RelativeNamespace + { + newLeafNode(otherlv_1, grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); + } + ( + otherlv_2=LeftSquareBracket + { + newLeafNode(otherlv_2, grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); + } + lv_parts_3_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getRelativeNamespace_ImplRule()); + } + add( + $current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Comma + { + newLeafNode(otherlv_4, grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + } + lv_parts_5_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getRelativeNamespace_ImplRule()); + } + add( + $current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); + } + )? + ) +; + +// Entry rule entryRulePrivateNamespace +entryRulePrivateNamespace returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPrivateNamespaceRule()); } + iv_rulePrivateNamespace=rulePrivateNamespace + { $current=$iv_rulePrivateNamespace.current; } + EOF; + +// Rule PrivateNamespace +rulePrivateNamespace returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0(), + $current); + } + ) + otherlv_1=PrivateNamespace + { + newLeafNode(otherlv_1, grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); + } + ( + otherlv_2=LeftSquareBracket + { + newLeafNode(otherlv_2, grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + } + lv_parts_3_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPrivateNamespaceRule()); + } + add( + $current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Comma + { + newLeafNode(otherlv_4, grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + } + lv_parts_5_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPrivateNamespaceRule()); + } + add( + $current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); + } + )? + ) +; + +// Entry rule entryRuleParameter +entryRuleParameter returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterRule()); } + iv_ruleParameter=ruleParameter + { $current=$iv_ruleParameter.current; } + EOF; + +// Rule Parameter +ruleParameter returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterAccess().getParameterAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getParameterAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type + { + newLeafNode(otherlv_4, grammarAccess.getParameterAccess().getTypeKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); + } + lv_type_5_0=ruleParameterType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + $current, + "type", + lv_type_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getParameterAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); + } + otherlv_9=RightCurlyBracket + { + newLeafNode(otherlv_9, grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); + } + ) +; + +// Entry rule entryRuleParameterType +entryRuleParameterType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterTypeRule()); } + iv_ruleParameterType=ruleParameterType + { $current=$iv_ruleParameterType.current; } + EOF; + +// Rule ParameterType +ruleParameterType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); + } + this_ParameterListType_0=ruleParameterListType + { + $current = $this_ParameterListType_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); + } + this_ParameterStructType_1=ruleParameterStructType + { + $current = $this_ParameterStructType_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); + } + this_ParameterIntegerType_2=ruleParameterIntegerType + { + $current = $this_ParameterIntegerType_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); + } + this_ParameterStringType_3=ruleParameterStringType + { + $current = $this_ParameterStringType_3.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); + } + this_ParameterDoubleType_4=ruleParameterDoubleType + { + $current = $this_ParameterDoubleType_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); + } + this_ParameterBooleanType_5=ruleParameterBooleanType + { + $current = $this_ParameterBooleanType_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); + } + this_ParameterBase64Type_6=ruleParameterBase64Type + { + $current = $this_ParameterBase64Type_6.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); + } + this_ParameterArrayType_7=ruleParameterArrayType + { + $current = $this_ParameterArrayType_7.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleParameterValue +entryRuleParameterValue returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterValueRule()); } + iv_ruleParameterValue=ruleParameterValue + { $current=$iv_ruleParameterValue.current; } + EOF; + +// Rule ParameterValue +ruleParameterValue returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); + } + this_ParameterString_0=ruleParameterString + { + $current = $this_ParameterString_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); + } + this_ParameterBase64_1=ruleParameterBase64 + { + $current = $this_ParameterBase64_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); + } + this_ParameterInteger_2=ruleParameterInteger + { + $current = $this_ParameterInteger_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); + } + this_ParameterDouble_3=ruleParameterDouble + { + $current = $this_ParameterDouble_3.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); + } + this_ParameterBoolean_4=ruleParameterBoolean + { + $current = $this_ParameterBoolean_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); + } + this_ParameterList_5=ruleParameterList + { + $current = $this_ParameterList_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); + } + this_ParameterStruct_6=ruleParameterStruct + { + $current = $this_ParameterStruct_6.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleParameterListType +entryRuleParameterListType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterListTypeRule()); } + iv_ruleParameterListType=ruleParameterListType + { $current=$iv_ruleParameterListType.current; } + EOF; + +// Rule ParameterListType +ruleParameterListType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0(), + $current); + } + ) + otherlv_1=List + { + newLeafNode(otherlv_1, grammarAccess.getParameterListTypeAccess().getListKeyword_1()); + } + otherlv_2=LeftSquareBracket + { + newLeafNode(otherlv_2, grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); + } + lv_sequence_3_0=ruleParameterType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterListTypeRule()); + } + add( + $current, + "sequence", + lv_sequence_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Comma + { + newLeafNode(otherlv_4, grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); + } + lv_sequence_5_0=ruleParameterType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterListTypeRule()); + } + add( + $current, + "sequence", + lv_sequence_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); + } + ) +; + +// Entry rule entryRuleParameterStructType +entryRuleParameterStructType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStructTypeRule()); } + iv_ruleParameterStructType=ruleParameterStructType + { $current=$iv_ruleParameterStructType.current; } + EOF; + +// Rule ParameterStructType +ruleParameterStructType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0(), + $current); + } + ) + otherlv_1=Struct + { + newLeafNode(otherlv_1, grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); + } + otherlv_2=LeftSquareBracket + { + newLeafNode(otherlv_2, grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); + } + lv_parameterstructypetmember_3_0=ruleParameterStructTypeMember + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructTypeRule()); + } + add( + $current, + "parameterstructypetmember", + lv_parameterstructypetmember_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructTypeMember"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Comma + { + newLeafNode(otherlv_4, grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); + } + lv_parameterstructypetmember_5_0=ruleParameterStructTypeMember + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructTypeRule()); + } + add( + $current, + "parameterstructypetmember", + lv_parameterstructypetmember_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructTypeMember"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); + } + ) +; + +// Entry rule entryRuleParameterIntegerType +entryRuleParameterIntegerType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterIntegerTypeRule()); } + iv_ruleParameterIntegerType=ruleParameterIntegerType + { $current=$iv_ruleParameterIntegerType.current; } + EOF; + +// Rule ParameterIntegerType +ruleParameterIntegerType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0(), + $current); + } + ) + otherlv_1=Integer + { + newLeafNode(otherlv_1, grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); + } + ( + otherlv_2=Default + { + newLeafNode(otherlv_2, grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); + } + lv_default_3_0=ruleParameterInteger + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterIntegerTypeRule()); + } + set( + $current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterInteger"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterStringType +entryRuleParameterStringType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStringTypeRule()); } + iv_ruleParameterStringType=ruleParameterStringType + { $current=$iv_ruleParameterStringType.current; } + EOF; + +// Rule ParameterStringType +ruleParameterStringType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0(), + $current); + } + ) + otherlv_1=String + { + newLeafNode(otherlv_1, grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); + } + ( + otherlv_2=Default + { + newLeafNode(otherlv_2, grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); + } + lv_default_3_0=ruleParameterString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStringTypeRule()); + } + set( + $current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterString"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterDoubleType +entryRuleParameterDoubleType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterDoubleTypeRule()); } + iv_ruleParameterDoubleType=ruleParameterDoubleType + { $current=$iv_ruleParameterDoubleType.current; } + EOF; + +// Rule ParameterDoubleType +ruleParameterDoubleType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0(), + $current); + } + ) + otherlv_1=Double + { + newLeafNode(otherlv_1, grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); + } + ( + otherlv_2=Default + { + newLeafNode(otherlv_2, grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); + } + lv_default_3_0=ruleParameterDouble + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterDoubleTypeRule()); + } + set( + $current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterDouble"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterBooleanType +entryRuleParameterBooleanType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterBooleanTypeRule()); } + iv_ruleParameterBooleanType=ruleParameterBooleanType + { $current=$iv_ruleParameterBooleanType.current; } + EOF; + +// Rule ParameterBooleanType +ruleParameterBooleanType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0(), + $current); + } + ) + otherlv_1=Boolean + { + newLeafNode(otherlv_1, grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); + } + ( + otherlv_2=Default + { + newLeafNode(otherlv_2, grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); + } + lv_default_3_0=ruleParameterBoolean + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterBooleanTypeRule()); + } + set( + $current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterBoolean"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterBase64Type +entryRuleParameterBase64Type returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterBase64TypeRule()); } + iv_ruleParameterBase64Type=ruleParameterBase64Type + { $current=$iv_ruleParameterBase64Type.current; } + EOF; + +// Rule ParameterBase64Type +ruleParameterBase64Type returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0(), + $current); + } + ) + otherlv_1=Base64 + { + newLeafNode(otherlv_1, grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); + } + ( + otherlv_2=Default + { + newLeafNode(otherlv_2, grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); + } + lv_default_3_0=ruleParameterBase64 + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterBase64TypeRule()); + } + set( + $current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterBase64"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterArrayType +entryRuleParameterArrayType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterArrayTypeRule()); } + iv_ruleParameterArrayType=ruleParameterArrayType + { $current=$iv_ruleParameterArrayType.current; } + EOF; + +// Rule ParameterArrayType +ruleParameterArrayType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0=Array + { + newLeafNode(otherlv_0, grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); + } + this_BEGIN_1=RULE_BEGIN + { + newLeafNode(this_BEGIN_1, grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); + } + otherlv_2=Type + { + newLeafNode(otherlv_2, grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); + } + lv_type_3_0=ruleParameterType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterArrayTypeRule()); + } + set( + $current, + "type", + lv_type_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Default + { + newLeafNode(otherlv_4, grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); + } + lv_default_5_0=ruleParameterList + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterArrayTypeRule()); + } + set( + $current, + "default", + lv_default_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterList"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_6=RULE_END + { + newLeafNode(this_END_6, grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); + } + ) +; + +// Entry rule entryRuleParameterList +entryRuleParameterList returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterListRule()); } + iv_ruleParameterList=ruleParameterList + { $current=$iv_ruleParameterList.current; } + EOF; + +// Rule ParameterList +ruleParameterList returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterListAccess().getParameterSequenceAction_0(), + $current); + } + ) + otherlv_1=LeftSquareBracket + { + newLeafNode(otherlv_1, grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); + } + lv_value_2_0=ruleParameterValue + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterListRule()); + } + add( + $current, + "value", + lv_value_2_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=Comma + { + newLeafNode(otherlv_3, grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); + } + lv_value_4_0=ruleParameterValue + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterListRule()); + } + add( + $current, + "value", + lv_value_4_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_5=RightSquareBracket + { + newLeafNode(otherlv_5, grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); + } + ) +; + +// Entry rule entryRuleParameterAny +entryRuleParameterAny returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterAnyRule()); } + iv_ruleParameterAny=ruleParameterAny + { $current=$iv_ruleParameterAny.current; } + EOF; + +// Rule ParameterAny +ruleParameterAny returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterAnyAccess().getParameterAnyAction_0(), + $current); + } + ) + otherlv_1=ParameterAny + { + newLeafNode(otherlv_1, grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); + } + ( + otherlv_2=Value + { + newLeafNode(otherlv_2, grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); + } + lv_value_3_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterAnyRule()); + } + set( + $current, + "value", + lv_value_3_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterString +entryRuleParameterString returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStringRule()); } + iv_ruleParameterString=ruleParameterString + { $current=$iv_ruleParameterString.current; } + EOF; + +// Rule ParameterString +ruleParameterString returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); + } + lv_value_0_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStringRule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterBase64 +entryRuleParameterBase64 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterBase64Rule()); } + iv_ruleParameterBase64=ruleParameterBase64 + { $current=$iv_ruleParameterBase64.current; } + EOF; + +// Rule ParameterBase64 +ruleParameterBase64 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); + } + lv_value_0_0=ruleBase64Binary + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterBase64Rule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Base64Binary"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterInteger +entryRuleParameterInteger returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterIntegerRule()); } + iv_ruleParameterInteger=ruleParameterInteger + { $current=$iv_ruleParameterInteger.current; } + EOF; + +// Rule ParameterInteger +ruleParameterInteger returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); + } + lv_value_0_0=ruleInteger0 + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterIntegerRule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Integer0"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterDouble +entryRuleParameterDouble returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterDoubleRule()); } + iv_ruleParameterDouble=ruleParameterDouble + { $current=$iv_ruleParameterDouble.current; } + EOF; + +// Rule ParameterDouble +ruleParameterDouble returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); + } + lv_value_0_0=ruleDouble0 + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterDoubleRule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Double0"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterBoolean +entryRuleParameterBoolean returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterBooleanRule()); } + iv_ruleParameterBoolean=ruleParameterBoolean + { $current=$iv_ruleParameterBoolean.current; } + EOF; + +// Rule ParameterBoolean +ruleParameterBoolean returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); + } + lv_value_0_0=ruleboolean0 + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterBooleanRule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.boolean0"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterStruct +entryRuleParameterStruct returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStructRule()); } + iv_ruleParameterStruct=ruleParameterStruct + { $current=$iv_ruleParameterStruct.current; } + EOF; + +// Rule ParameterStruct +ruleParameterStruct returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterStructAccess().getParameterStructAction_0(), + $current); + } + ) + ( + otherlv_1=LeftSquareBracket + { + newLeafNode(otherlv_1, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); + } + lv_value_2_0=ruleParameterStructMember + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructRule()); + } + add( + $current, + "value", + lv_value_2_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructMember"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=Comma + { + newLeafNode(otherlv_3, grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); + } + otherlv_4=LeftSquareBracket + { + newLeafNode(otherlv_4, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); + } + lv_value_5_0=ruleParameterStructMember + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructRule()); + } + add( + $current, + "value", + lv_value_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructMember"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); + } + )* + otherlv_7=RightSquareBracket + { + newLeafNode(otherlv_7, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); + } + )? + ) +; + +// Entry rule entryRuleParameterDate +entryRuleParameterDate returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterDateRule()); } + iv_ruleParameterDate=ruleParameterDate + { $current=$iv_ruleParameterDate.current; } + EOF; + +// Rule ParameterDate +ruleParameterDate returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); + } + lv_value_0_0=ruleDateTime0 + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterDateRule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.DateTime0"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterStructMember +entryRuleParameterStructMember returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStructMemberRule()); } + iv_ruleParameterStructMember=ruleParameterStructMember + { $current=$iv_ruleParameterStructMember.current; } + EOF; + +// Rule ParameterStructMember +ruleParameterStructMember returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0=ParameterStructMember + { + newLeafNode(otherlv_0, grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructMemberRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); + } + lv_value_4_0=ruleParameterValue + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructMemberRule()); + } + set( + $current, + "value", + lv_value_4_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_5=RULE_END + { + newLeafNode(this_END_5, grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); + } + ) +; + +// Entry rule entryRuleParameterStructTypeMember +entryRuleParameterStructTypeMember returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStructTypeMemberRule()); } + iv_ruleParameterStructTypeMember=ruleParameterStructTypeMember + { $current=$iv_ruleParameterStructTypeMember.current; } + EOF; + +// Rule ParameterStructTypeMember +ruleParameterStructTypeMember returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); + } + lv_name_0_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructTypeMemberRule()); + } + set( + $current, + "name", + lv_name_0_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); + } + lv_type_1_0=ruleParameterType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructTypeMemberRule()); + } + set( + $current, + "type", + lv_type_1_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleBase64Binary +entryRuleBase64Binary returns [String current=null]: + { newCompositeNode(grammarAccess.getBase64BinaryRule()); } + iv_ruleBase64Binary=ruleBase64Binary + { $current=$iv_ruleBase64Binary.current.getText(); } + EOF; + +// Rule Base64Binary +ruleBase64Binary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_BINARY_0=RULE_BINARY + { + $current.merge(this_BINARY_0); + } + { + newLeafNode(this_BINARY_0, grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); + } +; + +// Entry rule entryRuleboolean0 +entryRuleboolean0 returns [String current=null]: + { newCompositeNode(grammarAccess.getBoolean0Rule()); } + iv_ruleboolean0=ruleboolean0 + { $current=$iv_ruleboolean0.current.getText(); } + EOF; + +// Rule boolean0 +ruleboolean0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_BOOLEAN_0=RULE_BOOLEAN + { + $current.merge(this_BOOLEAN_0); + } + { + newLeafNode(this_BOOLEAN_0, grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); + } +; + +// Entry rule entryRuleDouble0 +entryRuleDouble0 returns [String current=null]: + { newCompositeNode(grammarAccess.getDouble0Rule()); } + iv_ruleDouble0=ruleDouble0 + { $current=$iv_ruleDouble0.current.getText(); } + EOF; + +// Rule Double0 +ruleDouble0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_DOUBLE_0=RULE_DOUBLE + { + $current.merge(this_DOUBLE_0); + } + { + newLeafNode(this_DOUBLE_0, grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); + } +; + +// Entry rule entryRuleInteger0 +entryRuleInteger0 returns [String current=null]: + { newCompositeNode(grammarAccess.getInteger0Rule()); } + iv_ruleInteger0=ruleInteger0 + { $current=$iv_ruleInteger0.current.getText(); } + EOF; + +// Rule Integer0 +ruleInteger0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_DECINT_0=RULE_DECINT + { + $current.merge(this_DECINT_0); + } + { + newLeafNode(this_DECINT_0, grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); + } +; + +// Entry rule entryRuleDateTime0 +entryRuleDateTime0 returns [String current=null]: + { newCompositeNode(grammarAccess.getDateTime0Rule()); } + iv_ruleDateTime0=ruleDateTime0 + { $current=$iv_ruleDateTime0.current.getText(); } + EOF; + +// Rule DateTime0 +ruleDateTime0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_DATE_TIME_0=RULE_DATE_TIME + { + $current.merge(this_DATE_TIME_0); + } + { + newLeafNode(this_DATE_TIME_0, grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); + } +; + +// Entry rule entryRuleMessagePart +entryRuleMessagePart returns [EObject current=null]: + { newCompositeNode(grammarAccess.getMessagePartRule()); } + iv_ruleMessagePart=ruleMessagePart + { $current=$iv_ruleMessagePart.current; } + EOF; + +// Rule MessagePart +ruleMessagePart returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); + } + lv_Type_0_0=ruleAbstractType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + $current, + "Type", + lv_Type_0_0, + "de.fraunhofer.ipa.ros.Ros.AbstractType"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ( + { + newCompositeNode(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); + } + lv_Data_1_1=ruleKEYWORD + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + $current, + "Data", + lv_Data_1_1, + "de.fraunhofer.ipa.ros.Ros.KEYWORD"); + afterParserOrEnumRuleCall(); + } + | + lv_Data_1_2=RULE_MESSAGE_ASIGMENT + { + newLeafNode(lv_Data_1_2, grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getMessagePartRule()); + } + setWithLastConsumed( + $current, + "Data", + lv_Data_1_2, + "de.fraunhofer.ipa.ros.Ros.MESSAGE_ASIGMENT"); + } + | + { + newCompositeNode(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); + } + lv_Data_1_3=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + $current, + "Data", + lv_Data_1_3, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) +; + +// Entry rule entryRuleAbstractType +entryRuleAbstractType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getAbstractTypeRule()); } + iv_ruleAbstractType=ruleAbstractType + { $current=$iv_ruleAbstractType.current; } + EOF; + +// Rule AbstractType +ruleAbstractType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); + } + this_bool_0=rulebool + { + $current = $this_bool_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); + } + this_int8_1=ruleint8 + { + $current = $this_int8_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); + } + this_uint8_2=ruleuint8 + { + $current = $this_uint8_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); + } + this_int16_3=ruleint16 + { + $current = $this_int16_3.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); + } + this_uint16_4=ruleuint16 + { + $current = $this_uint16_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); + } + this_int32_5=ruleint32 + { + $current = $this_int32_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); + } + this_uint32_6=ruleuint32 + { + $current = $this_uint32_6.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); + } + this_int64_7=ruleint64 + { + $current = $this_int64_7.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); + } + this_uint64_8=ruleuint64 + { + $current = $this_uint64_8.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); + } + this_float32_9=rulefloat32 + { + $current = $this_float32_9.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); + } + this_float64_10=rulefloat64 + { + $current = $this_float64_10.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); + } + this_string0_11=rulestring0 + { + $current = $this_string0_11.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); + } + this_byte_12=rulebyte + { + $current = $this_byte_12.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); + } + this_time_13=ruletime + { + $current = $this_time_13.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); + } + this_duration_14=ruleduration + { + $current = $this_duration_14.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); + } + this_Header_15=ruleHeader + { + $current = $this_Header_15.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); + } + this_boolArray_16=ruleboolArray + { + $current = $this_boolArray_16.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); + } + this_int8Array_17=ruleint8Array + { + $current = $this_int8Array_17.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); + } + this_uint8Array_18=ruleuint8Array + { + $current = $this_uint8Array_18.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); + } + this_int16Array_19=ruleint16Array + { + $current = $this_int16Array_19.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); + } + this_uint16Array_20=ruleuint16Array + { + $current = $this_uint16Array_20.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); + } + this_int32Array_21=ruleint32Array + { + $current = $this_int32Array_21.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); + } + this_uint32Array_22=ruleuint32Array + { + $current = $this_uint32Array_22.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); + } + this_int64Array_23=ruleint64Array + { + $current = $this_int64Array_23.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); + } + this_uint64Array_24=ruleuint64Array + { + $current = $this_uint64Array_24.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); + } + this_float32Array_25=rulefloat32Array + { + $current = $this_float32Array_25.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); + } + this_float64Array_26=rulefloat64Array + { + $current = $this_float64Array_26.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); + } + this_string0Array_27=rulestring0Array + { + $current = $this_string0Array_27.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); + } + this_byteArray_28=rulebyteArray + { + $current = $this_byteArray_28.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); + } + this_TopicSpecRef_29=ruleTopicSpecRef + { + $current = $this_TopicSpecRef_29.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); + } + this_ArrayTopicSpecRef_30=ruleArrayTopicSpecRef + { + $current = $this_ArrayTopicSpecRef_30.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRulebool +entryRulebool returns [EObject current=null]: + { newCompositeNode(grammarAccess.getBoolRule()); } + iv_rulebool=rulebool + { $current=$iv_rulebool.current; } + EOF; + +// Rule bool +rulebool returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getBoolAccess().getBoolAction_0(), + $current); + } + ) + otherlv_1=Bool + { + newLeafNode(otherlv_1, grammarAccess.getBoolAccess().getBoolKeyword_1()); + } + ) +; + +// Entry rule entryRuleint8 +entryRuleint8 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt8Rule()); } + iv_ruleint8=ruleint8 + { $current=$iv_ruleint8.current; } + EOF; + +// Rule int8 +ruleint8 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt8Access().getInt8Action_0(), + $current); + } + ) + otherlv_1=Int8 + { + newLeafNode(otherlv_1, grammarAccess.getInt8Access().getInt8Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint8 +entryRuleuint8 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint8Rule()); } + iv_ruleuint8=ruleuint8 + { $current=$iv_ruleuint8.current; } + EOF; + +// Rule uint8 +ruleuint8 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint8Access().getUint8Action_0(), + $current); + } + ) + otherlv_1=Uint8 + { + newLeafNode(otherlv_1, grammarAccess.getUint8Access().getUint8Keyword_1()); + } + ) +; + +// Entry rule entryRuleint16 +entryRuleint16 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt16Rule()); } + iv_ruleint16=ruleint16 + { $current=$iv_ruleint16.current; } + EOF; + +// Rule int16 +ruleint16 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt16Access().getInt16Action_0(), + $current); + } + ) + otherlv_1=Int16 + { + newLeafNode(otherlv_1, grammarAccess.getInt16Access().getInt16Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint16 +entryRuleuint16 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint16Rule()); } + iv_ruleuint16=ruleuint16 + { $current=$iv_ruleuint16.current; } + EOF; + +// Rule uint16 +ruleuint16 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint16Access().getUint16Action_0(), + $current); + } + ) + otherlv_1=Uint16 + { + newLeafNode(otherlv_1, grammarAccess.getUint16Access().getUint16Keyword_1()); + } + ) +; + +// Entry rule entryRuleint32 +entryRuleint32 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt32Rule()); } + iv_ruleint32=ruleint32 + { $current=$iv_ruleint32.current; } + EOF; + +// Rule int32 +ruleint32 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt32Access().getInt32Action_0(), + $current); + } + ) + otherlv_1=Int32 + { + newLeafNode(otherlv_1, grammarAccess.getInt32Access().getInt32Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint32 +entryRuleuint32 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint32Rule()); } + iv_ruleuint32=ruleuint32 + { $current=$iv_ruleuint32.current; } + EOF; + +// Rule uint32 +ruleuint32 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint32Access().getUint32Action_0(), + $current); + } + ) + otherlv_1=Uint32 + { + newLeafNode(otherlv_1, grammarAccess.getUint32Access().getUint32Keyword_1()); + } + ) +; + +// Entry rule entryRuleint64 +entryRuleint64 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt64Rule()); } + iv_ruleint64=ruleint64 + { $current=$iv_ruleint64.current; } + EOF; + +// Rule int64 +ruleint64 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt64Access().getInt64Action_0(), + $current); + } + ) + otherlv_1=Int64 + { + newLeafNode(otherlv_1, grammarAccess.getInt64Access().getInt64Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint64 +entryRuleuint64 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint64Rule()); } + iv_ruleuint64=ruleuint64 + { $current=$iv_ruleuint64.current; } + EOF; + +// Rule uint64 +ruleuint64 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint64Access().getUint64Action_0(), + $current); + } + ) + otherlv_1=Uint64 + { + newLeafNode(otherlv_1, grammarAccess.getUint64Access().getUint64Keyword_1()); + } + ) +; + +// Entry rule entryRulefloat32 +entryRulefloat32 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFloat32Rule()); } + iv_rulefloat32=rulefloat32 + { $current=$iv_rulefloat32.current; } + EOF; + +// Rule float32 +rulefloat32 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getFloat32Access().getFloat32Action_0(), + $current); + } + ) + otherlv_1=Float32 + { + newLeafNode(otherlv_1, grammarAccess.getFloat32Access().getFloat32Keyword_1()); + } + ) +; + +// Entry rule entryRulefloat64 +entryRulefloat64 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFloat64Rule()); } + iv_rulefloat64=rulefloat64 + { $current=$iv_rulefloat64.current; } + EOF; + +// Rule float64 +rulefloat64 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getFloat64Access().getFloat64Action_0(), + $current); + } + ) + otherlv_1=Float64 + { + newLeafNode(otherlv_1, grammarAccess.getFloat64Access().getFloat64Keyword_1()); + } + ) +; + +// Entry rule entryRulestring0 +entryRulestring0 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getString0Rule()); } + iv_rulestring0=rulestring0 + { $current=$iv_rulestring0.current; } + EOF; + +// Rule string0 +rulestring0 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getString0Access().getStringAction_0(), + $current); + } + ) + otherlv_1=String_1 + { + newLeafNode(otherlv_1, grammarAccess.getString0Access().getStringKeyword_1()); + } + ) +; + +// Entry rule entryRulebyte +entryRulebyte returns [EObject current=null]: + { newCompositeNode(grammarAccess.getByteRule()); } + iv_rulebyte=rulebyte + { $current=$iv_rulebyte.current; } + EOF; + +// Rule byte +rulebyte returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getByteAccess().getByteAction_0(), + $current); + } + ) + otherlv_1=Byte + { + newLeafNode(otherlv_1, grammarAccess.getByteAccess().getByteKeyword_1()); + } + ) +; + +// Entry rule entryRuletime +entryRuletime returns [EObject current=null]: + { newCompositeNode(grammarAccess.getTimeRule()); } + iv_ruletime=ruletime + { $current=$iv_ruletime.current; } + EOF; + +// Rule time +ruletime returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getTimeAccess().getTimeAction_0(), + $current); + } + ) + otherlv_1=Time + { + newLeafNode(otherlv_1, grammarAccess.getTimeAccess().getTimeKeyword_1()); + } + ) +; + +// Entry rule entryRuleduration +entryRuleduration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getDurationRule()); } + iv_ruleduration=ruleduration + { $current=$iv_ruleduration.current; } + EOF; + +// Rule duration +ruleduration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getDurationAccess().getDurationAction_0(), + $current); + } + ) + otherlv_1=Duration + { + newLeafNode(otherlv_1, grammarAccess.getDurationAccess().getDurationKeyword_1()); + } + ) +; + +// Entry rule entryRuleboolArray +entryRuleboolArray returns [EObject current=null]: + { newCompositeNode(grammarAccess.getBoolArrayRule()); } + iv_ruleboolArray=ruleboolArray + { $current=$iv_ruleboolArray.current; } + EOF; + +// Rule boolArray +ruleboolArray returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getBoolArrayAccess().getBoolArrayAction_0(), + $current); + } + ) + otherlv_1=Bool_1 + { + newLeafNode(otherlv_1, grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); + } + ) +; + +// Entry rule entryRuleint8Array +entryRuleint8Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt8ArrayRule()); } + iv_ruleint8Array=ruleint8Array + { $current=$iv_ruleint8Array.current; } + EOF; + +// Rule int8Array +ruleint8Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0(), + $current); + } + ) + otherlv_1=Int8_1 + { + newLeafNode(otherlv_1, grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint8Array +entryRuleuint8Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint8ArrayRule()); } + iv_ruleuint8Array=ruleuint8Array + { $current=$iv_ruleuint8Array.current; } + EOF; + +// Rule uint8Array +ruleuint8Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0(), + $current); + } + ) + otherlv_1=Uint8_1 + { + newLeafNode(otherlv_1, grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); + } + ) +; + +// Entry rule entryRuleint16Array +entryRuleint16Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt16ArrayRule()); } + iv_ruleint16Array=ruleint16Array + { $current=$iv_ruleint16Array.current; } + EOF; + +// Rule int16Array +ruleint16Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0(), + $current); + } + ) + otherlv_1=Int16_1 + { + newLeafNode(otherlv_1, grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint16Array +entryRuleuint16Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint16ArrayRule()); } + iv_ruleuint16Array=ruleuint16Array + { $current=$iv_ruleuint16Array.current; } + EOF; + +// Rule uint16Array +ruleuint16Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0(), + $current); + } + ) + otherlv_1=Uint16_1 + { + newLeafNode(otherlv_1, grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); + } + ) +; + +// Entry rule entryRuleint32Array +entryRuleint32Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt32ArrayRule()); } + iv_ruleint32Array=ruleint32Array + { $current=$iv_ruleint32Array.current; } + EOF; + +// Rule int32Array +ruleint32Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0(), + $current); + } + ) + otherlv_1=Int32_1 + { + newLeafNode(otherlv_1, grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint32Array +entryRuleuint32Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint32ArrayRule()); } + iv_ruleuint32Array=ruleuint32Array + { $current=$iv_ruleuint32Array.current; } + EOF; + +// Rule uint32Array +ruleuint32Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0(), + $current); + } + ) + otherlv_1=Uint32_1 + { + newLeafNode(otherlv_1, grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); + } + ) +; + +// Entry rule entryRuleint64Array +entryRuleint64Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt64ArrayRule()); } + iv_ruleint64Array=ruleint64Array + { $current=$iv_ruleint64Array.current; } + EOF; + +// Rule int64Array +ruleint64Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0(), + $current); + } + ) + otherlv_1=Int64_1 + { + newLeafNode(otherlv_1, grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint64Array +entryRuleuint64Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint64ArrayRule()); } + iv_ruleuint64Array=ruleuint64Array + { $current=$iv_ruleuint64Array.current; } + EOF; + +// Rule uint64Array +ruleuint64Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0(), + $current); + } + ) + otherlv_1=Uint64_1 + { + newLeafNode(otherlv_1, grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); + } + ) +; + +// Entry rule entryRulefloat32Array +entryRulefloat32Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFloat32ArrayRule()); } + iv_rulefloat32Array=rulefloat32Array + { $current=$iv_rulefloat32Array.current; } + EOF; + +// Rule float32Array +rulefloat32Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0(), + $current); + } + ) + otherlv_1=Float32_1 + { + newLeafNode(otherlv_1, grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); + } + ) +; + +// Entry rule entryRulefloat64Array +entryRulefloat64Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFloat64ArrayRule()); } + iv_rulefloat64Array=rulefloat64Array + { $current=$iv_rulefloat64Array.current; } + EOF; + +// Rule float64Array +rulefloat64Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0(), + $current); + } + ) + otherlv_1=Float64_1 + { + newLeafNode(otherlv_1, grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); + } + ) +; + +// Entry rule entryRulestring0Array +entryRulestring0Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getString0ArrayRule()); } + iv_rulestring0Array=rulestring0Array + { $current=$iv_rulestring0Array.current; } + EOF; + +// Rule string0Array +rulestring0Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getString0ArrayAccess().getStringArrayAction_0(), + $current); + } + ) + otherlv_1=String_2 + { + newLeafNode(otherlv_1, grammarAccess.getString0ArrayAccess().getStringKeyword_1()); + } + ) +; + +// Entry rule entryRulebyteArray +entryRulebyteArray returns [EObject current=null]: + { newCompositeNode(grammarAccess.getByteArrayRule()); } + iv_rulebyteArray=rulebyteArray + { $current=$iv_rulebyteArray.current; } + EOF; + +// Rule byteArray +rulebyteArray returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getByteArrayAccess().getByteArrayAction_0(), + $current); + } + ) + otherlv_1=Byte_1 + { + newLeafNode(otherlv_1, grammarAccess.getByteArrayAccess().getByteKeyword_1()); + } + ) +; + +// Entry rule entryRuleHeader +entryRuleHeader returns [EObject current=null]: + { newCompositeNode(grammarAccess.getHeaderRule()); } + iv_ruleHeader=ruleHeader + { $current=$iv_ruleHeader.current; } + EOF; + +// Rule Header +ruleHeader returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getHeaderAccess().getHeaderAction_0(), + $current); + } + ) + otherlv_1=Header + { + newLeafNode(otherlv_1, grammarAccess.getHeaderAccess().getHeaderKeyword_1()); + } + ) +; + +// Entry rule entryRuleTopicSpecRef +entryRuleTopicSpecRef returns [EObject current=null]: + { newCompositeNode(grammarAccess.getTopicSpecRefRule()); } + iv_ruleTopicSpecRef=ruleTopicSpecRef + { $current=$iv_ruleTopicSpecRef.current; } + EOF; + +// Rule TopicSpecRef +ruleTopicSpecRef returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getTopicSpecRefRule()); + } + } + { + newCompositeNode(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleArrayTopicSpecRef +entryRuleArrayTopicSpecRef returns [EObject current=null]: + { newCompositeNode(grammarAccess.getArrayTopicSpecRefRule()); } + iv_ruleArrayTopicSpecRef=ruleArrayTopicSpecRef + { $current=$iv_ruleArrayTopicSpecRef.current; } + EOF; + +// Rule ArrayTopicSpecRef +ruleArrayTopicSpecRef returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getArrayTopicSpecRefRule()); + } + } + { + newCompositeNode(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_1=LeftSquareBracketRightSquareBracket + { + newLeafNode(otherlv_1, grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); + } + ) +; + +// Entry rule entryRuleKEYWORD +entryRuleKEYWORD returns [String current=null]: + { newCompositeNode(grammarAccess.getKEYWORDRule()); } + iv_ruleKEYWORD=ruleKEYWORD + { $current=$iv_ruleKEYWORD.current.getText(); } + EOF; + +// Rule KEYWORD +ruleKEYWORD returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw=Goal + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); + } + | + kw=Message + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); + } + | + kw=Result + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getResultKeyword_2()); + } + | + kw=Feedback + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); + } + | + kw=Name + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getNameKeyword_4()); + } + | + kw=Value + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getValueKeyword_5()); + } + | + kw=Service + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); + } + | + kw=Type + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); + } + | + kw=Action + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getActionKeyword_8()); + } + | + kw=Duration + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); + } + | + kw=Time + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); + } + ) +; diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosParser.java b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosParser.java index 09bd2f8a5..22923f7b8 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosParser.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosParser.java @@ -21,119 +21,119 @@ @SuppressWarnings("all") public class InternalRosParser extends AbstractInternalAntlrParser { public static final String[] tokenNames = new String[] { - "", "", "", "", "RULE_STRING", "RULE_ID", "RULE_ROS_CONVENTION_A", "RULE_BINARY", "RULE_BOOLEAN", "RULE_DOUBLE", "RULE_DECINT", "RULE_DATE_TIME", "RULE_MESSAGE_ASIGMENT", "RULE_ROS_CONVENTION_PARAM", "RULE_DIGIT", "RULE_DAY", "RULE_MONTH", "RULE_YEAR", "RULE_HOUR", "RULE_MIN_SEC", "RULE_INT", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'PackageSet'", "'{'", "','", "'}'", "'Package'", "'FromGitRepo'", "'Specs'", "'node'", "'Artifact'", "'CatkinPackage'", "'Dependencies'", "'AmentPackage'", "'ServiceSpec'", "'request'", "'response'", "'TopicSpec'", "'Header'", "'String'", "'message'", "'ActionSpec'", "'goal'", "'result'", "'feedback'", "'Node'", "'name'", "'ServiceServers'", "'Publishers'", "'Subscribers'", "'ServiceClients'", "'ActionServers'", "'ActionClients'", "'Parameters'", "'ServiceServer'", "'service'", "'namespace'", "'Publisher'", "'Subscriber'", "'ServiceClient'", "'ActionServer'", "'action'", "'ActionClient'", "'GraphName'", "'ExternalDependency'", "'GlobalNamespace'", "'parts'", "'RelativeNamespace'", "'PrivateNamespace'", "'Parameter'", "'type'", "'List'", "'Struct'", "'Integer'", "'default'", "'Double'", "'Boolean'", "'Base64'", "'Array'", "'ParameterAny'", "'value'", "'ParameterStructMember'", "'bool'", "'int8'", "'uint8'", "'int16'", "'uint16'", "'int32'", "'uint32'", "'int64'", "'uint64'", "'float32'", "'float64'", "'string'", "'byte'", "'time'", "'duration'", "'bool[]'", "'int8[]'", "'uint8[]'", "'int16[]'", "'uint16[]'", "'int32[]'", "'uint32[]'", "'int64[]'", "'uint64[]'", "'float32[]'", "'float64[]'", "'string[]'", "'byte[]'", "'[]'" + "", "", "", "", "ParameterStructMember", "ExternalDependency", "RelativeNamespace", "PrivateNamespace", "GlobalNamespace", "Serviceclient", "Serviceserver", "Actionclient", "Actionserver", "Dependencies", "AmentPackage", "ParameterAny", "FromGitRepo", "Subscribers", "Parameters", "Publishers", "Artifacts", "GraphName", "Feedback_1", "Float32_1", "Float64_1", "Response", "Duration", "Feedback", "Message_1", "Request", "String_2", "Uint16_1", "Uint32_1", "Uint64_1", "Boolean", "Integer", "Action_1", "Default", "Float32", "Float64", "Int16_1", "Int32_1", "Int64_1", "Message", "Result_1", "Service", "Uint8_1", "Array", "Base64", "Double", "Header", "String", "Struct", "Action", "Bool_1", "Byte_1", "Int8_1", "Result", "Specs", "String_1", "Uint16", "Uint32", "Uint64", "Goal_1", "Int16", "Int32", "Int64", "Node_1", "Type_1", "Uint8", "Value", "Date", "List", "Bool", "Byte", "Goal", "Int8", "Msg", "Name", "Node", "Srv", "Time", "Type", "Any", "Ns", "LeftSquareBracketRightSquareBracket", "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_DIGIT", "RULE_BINARY", "RULE_BOOLEAN", "RULE_DECINT", "RULE_DOUBLE", "RULE_DAY", "RULE_MONTH", "RULE_YEAR", "RULE_HOUR", "RULE_MIN_SEC", "RULE_DATE_TIME", "RULE_INT", "RULE_MESSAGE_ASIGMENT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER" }; - public static final int T__50=50; - public static final int RULE_DATE_TIME=11; - public static final int T__59=59; - public static final int T__55=55; - public static final int T__56=56; - public static final int T__57=57; - public static final int T__58=58; - public static final int T__51=51; - public static final int T__52=52; - public static final int T__53=53; - public static final int T__54=54; - public static final int T__60=60; - public static final int T__61=61; - public static final int RULE_ID=5; - public static final int RULE_DIGIT=14; - public static final int RULE_INT=20; - public static final int T__66=66; - public static final int RULE_ML_COMMENT=21; - public static final int T__67=67; - public static final int T__68=68; - public static final int T__69=69; - public static final int T__62=62; - public static final int T__63=63; - public static final int T__64=64; - public static final int T__65=65; - public static final int RULE_MESSAGE_ASIGMENT=12; - public static final int T__37=37; - public static final int T__38=38; - public static final int T__39=39; - public static final int T__33=33; - public static final int T__34=34; - public static final int T__35=35; - public static final int T__36=36; - public static final int RULE_DECINT=10; - public static final int T__30=30; - public static final int T__31=31; - public static final int T__32=32; - public static final int RULE_HOUR=18; - public static final int T__48=48; - public static final int T__49=49; - public static final int T__44=44; - public static final int T__45=45; - public static final int T__46=46; - public static final int RULE_BINARY=7; - public static final int T__47=47; - public static final int T__40=40; - public static final int T__41=41; - public static final int T__42=42; - public static final int T__43=43; - public static final int T__91=91; - public static final int T__100=100; - public static final int T__92=92; - public static final int T__93=93; - public static final int T__102=102; - public static final int T__94=94; - public static final int T__101=101; - public static final int RULE_DAY=15; - public static final int T__90=90; - public static final int RULE_BOOLEAN=8; - public static final int RULE_YEAR=17; - public static final int RULE_MIN_SEC=19; - public static final int T__99=99; - public static final int T__95=95; - public static final int T__96=96; - public static final int T__97=97; - public static final int T__98=98; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; - public static final int T__29=29; - public static final int T__25=25; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=4; - public static final int RULE_SL_COMMENT=22; - public static final int RULE_DOUBLE=9; - public static final int RULE_ROS_CONVENTION_A=6; - public static final int T__77=77; - public static final int T__78=78; - public static final int RULE_ROS_CONVENTION_PARAM=13; - public static final int T__79=79; - public static final int T__73=73; + public static final int Float32_1=23; + public static final int Node=79; + public static final int RULE_DATE_TIME=108; + public static final int Uint64_1=33; + public static final int String=51; + public static final int Int16=64; + public static final int Float32=38; + public static final int Goal=75; + public static final int Bool=73; + public static final int Uint16=60; + public static final int Boolean=34; + public static final int ExternalDependency=5; + public static final int Uint8=69; + public static final int Parameters=18; + public static final int RULE_ID=94; + public static final int AmentPackage=14; + public static final int Actionclient=11; + public static final int RULE_DIGIT=98; + public static final int GlobalNamespace=8; + public static final int Artifacts=20; + public static final int Node_1=67; + public static final int Int16_1=40; + public static final int Header=50; + public static final int RULE_INT=109; + public static final int Byte=74; + public static final int RULE_ML_COMMENT=111; + public static final int LeftSquareBracket=88; + public static final int Specs=58; + public static final int Base64=48; + public static final int Message_1=28; + public static final int Comma=86; + public static final int RULE_MESSAGE_ASIGMENT=110; + public static final int Goal_1=63; + public static final int LeftSquareBracketRightSquareBracket=85; + public static final int Int32=65; + public static final int Publishers=19; + public static final int Serviceserver=10; + public static final int RightCurlyBracket=90; + public static final int RULE_DECINT=101; + public static final int Uint32=61; + public static final int FromGitRepo=16; + public static final int Msg=77; + public static final int RULE_HOUR=106; + public static final int Int8=76; + public static final int Default=37; + public static final int Actionserver=12; + public static final int Int8_1=56; + public static final int Uint16_1=31; + public static final int Type=82; + public static final int Float64=39; + public static final int Int32_1=41; + public static final int Result_1=44; + public static final int RULE_BINARY=99; + public static final int String_1=59; + public static final int Subscribers=17; + public static final int String_2=30; + public static final int RULE_BEGIN=91; + public static final int RULE_DAY=103; + public static final int RULE_BOOLEAN=100; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=105; + public static final int Feedback_1=22; + public static final int Result=57; + public static final int Name=78; + public static final int RULE_MIN_SEC=107; + public static final int ParameterAny=15; + public static final int List=72; + public static final int Dependencies=13; + public static final int RightSquareBracket=89; + public static final int PrivateNamespace=7; + public static final int GraphName=21; + public static final int Byte_1=55; + public static final int Float64_1=24; + public static final int Duration=26; + public static final int Uint32_1=32; + public static final int Action_1=36; + public static final int Double=49; + public static final int Type_1=68; + public static final int Value=70; + public static final int Uint64=62; + public static final int Action=53; + public static final int RULE_END=92; + public static final int Message=43; + public static final int Time=81; + public static final int RULE_STRING=96; + public static final int Bool_1=54; + public static final int Any=83; + public static final int Struct=52; + public static final int RULE_SL_COMMENT=93; + public static final int Uint8_1=46; + public static final int RULE_DOUBLE=102; + public static final int Feedback=27; + public static final int ParameterStructMember=4; + public static final int Srv=80; + public static final int RULE_ROS_CONVENTION_A=95; + public static final int RULE_ROS_CONVENTION_PARAM=97; + public static final int Colon=87; public static final int EOF=-1; - public static final int T__74=74; - public static final int T__75=75; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__111=111; - public static final int T__81=81; - public static final int T__110=110; - public static final int T__82=82; - public static final int T__113=113; - public static final int T__83=83; - public static final int T__112=112; - public static final int RULE_WS=23; - public static final int RULE_ANY_OTHER=24; - public static final int T__88=88; - public static final int T__108=108; - public static final int T__89=89; - public static final int T__107=107; - public static final int RULE_MONTH=16; - public static final int T__109=109; - public static final int T__84=84; - public static final int T__104=104; - public static final int T__85=85; - public static final int T__103=103; - public static final int T__86=86; - public static final int T__106=106; - public static final int T__87=87; - public static final int T__105=105; + public static final int Ns=84; + public static final int RULE_WS=112; + public static final int Request=29; + public static final int Int64_1=42; + public static final int Service=45; + public static final int RULE_ANY_OTHER=113; + public static final int Date=71; + public static final int Response=25; + public static final int Integer=35; + public static final int Array=47; + public static final int Serviceclient=9; + public static final int Int64=66; + public static final int RULE_MONTH=104; // delegates // delegators @@ -149,7 +149,7 @@ public InternalRosParser(TokenStream input, RecognizerSharedState state) { public String[] getTokenNames() { return InternalRosParser.tokenNames; } - public String getGrammarFileName() { return "InternalRos.g"; } + public String getGrammarFileName() { return "InternalRosParser.g"; } @@ -175,7 +175,7 @@ protected RosGrammarAccess getGrammarAccess() { // $ANTLR start "entryRulePackageSet" - // InternalRos.g:64:1: entryRulePackageSet returns [EObject current=null] : iv_rulePackageSet= rulePackageSet EOF ; + // InternalRosParser.g:57:1: entryRulePackageSet returns [EObject current=null] : iv_rulePackageSet= rulePackageSet EOF ; public final EObject entryRulePackageSet() throws RecognitionException { EObject current = null; @@ -183,8 +183,8 @@ public final EObject entryRulePackageSet() throws RecognitionException { try { - // InternalRos.g:64:51: (iv_rulePackageSet= rulePackageSet EOF ) - // InternalRos.g:65:2: iv_rulePackageSet= rulePackageSet EOF + // InternalRosParser.g:57:51: (iv_rulePackageSet= rulePackageSet EOF ) + // InternalRosParser.g:58:2: iv_rulePackageSet= rulePackageSet EOF { newCompositeNode(grammarAccess.getPackageSetRule()); pushFollow(FOLLOW_1); @@ -211,31 +211,25 @@ public final EObject entryRulePackageSet() throws RecognitionException { // $ANTLR start "rulePackageSet" - // InternalRos.g:71:1: rulePackageSet returns [EObject current=null] : ( () otherlv_1= 'PackageSet' otherlv_2= '{' ( ( (lv_package_3_0= rulePackage ) ) (otherlv_4= ',' ( (lv_package_5_0= rulePackage ) ) )* )? otherlv_6= '}' ) ; + // InternalRosParser.g:64:1: rulePackageSet returns [EObject current=null] : ( () ( (lv_package_1_0= rulePackage_Impl ) )* ) ; public final EObject rulePackageSet() throws RecognitionException { EObject current = null; - Token otherlv_1=null; - Token otherlv_2=null; - Token otherlv_4=null; - Token otherlv_6=null; - EObject lv_package_3_0 = null; - - EObject lv_package_5_0 = null; + EObject lv_package_1_0 = null; enterRule(); try { - // InternalRos.g:77:2: ( ( () otherlv_1= 'PackageSet' otherlv_2= '{' ( ( (lv_package_3_0= rulePackage ) ) (otherlv_4= ',' ( (lv_package_5_0= rulePackage ) ) )* )? otherlv_6= '}' ) ) - // InternalRos.g:78:2: ( () otherlv_1= 'PackageSet' otherlv_2= '{' ( ( (lv_package_3_0= rulePackage ) ) (otherlv_4= ',' ( (lv_package_5_0= rulePackage ) ) )* )? otherlv_6= '}' ) + // InternalRosParser.g:70:2: ( ( () ( (lv_package_1_0= rulePackage_Impl ) )* ) ) + // InternalRosParser.g:71:2: ( () ( (lv_package_1_0= rulePackage_Impl ) )* ) { - // InternalRos.g:78:2: ( () otherlv_1= 'PackageSet' otherlv_2= '{' ( ( (lv_package_3_0= rulePackage ) ) (otherlv_4= ',' ( (lv_package_5_0= rulePackage ) ) )* )? otherlv_6= '}' ) - // InternalRos.g:79:3: () otherlv_1= 'PackageSet' otherlv_2= '{' ( ( (lv_package_3_0= rulePackage ) ) (otherlv_4= ',' ( (lv_package_5_0= rulePackage ) ) )* )? otherlv_6= '}' + // InternalRosParser.g:71:2: ( () ( (lv_package_1_0= rulePackage_Impl ) )* ) + // InternalRosParser.g:72:3: () ( (lv_package_1_0= rulePackage_Impl ) )* { - // InternalRos.g:79:3: () - // InternalRos.g:80:4: + // InternalRosParser.g:72:3: () + // InternalRosParser.g:73:4: { current = forceCreateModelElement( @@ -245,125 +239,55 @@ public final EObject rulePackageSet() throws RecognitionException { } - otherlv_1=(Token)match(input,25,FOLLOW_3); - - newLeafNode(otherlv_1, grammarAccess.getPackageSetAccess().getPackageSetKeyword_1()); - - otherlv_2=(Token)match(input,26,FOLLOW_4); - - newLeafNode(otherlv_2, grammarAccess.getPackageSetAccess().getLeftCurlyBracketKeyword_2()); - - // InternalRos.g:94:3: ( ( (lv_package_3_0= rulePackage ) ) (otherlv_4= ',' ( (lv_package_5_0= rulePackage ) ) )* )? - int alt2=2; - int LA2_0 = input.LA(1); - - if ( (LA2_0==29||LA2_0==34||LA2_0==36) ) { - alt2=1; - } - switch (alt2) { - case 1 : - // InternalRos.g:95:4: ( (lv_package_3_0= rulePackage ) ) (otherlv_4= ',' ( (lv_package_5_0= rulePackage ) ) )* - { - // InternalRos.g:95:4: ( (lv_package_3_0= rulePackage ) ) - // InternalRos.g:96:5: (lv_package_3_0= rulePackage ) - { - // InternalRos.g:96:5: (lv_package_3_0= rulePackage ) - // InternalRos.g:97:6: lv_package_3_0= rulePackage - { - - newCompositeNode(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_0_0()); - - pushFollow(FOLLOW_5); - lv_package_3_0=rulePackage(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getPackageSetRule()); - } - add( - current, - "package", - lv_package_3_0, - "de.fraunhofer.ipa.ros.Ros.Package"); - afterParserOrEnumRuleCall(); - - - } - - - } - - // InternalRos.g:114:4: (otherlv_4= ',' ( (lv_package_5_0= rulePackage ) ) )* - loop1: - do { - int alt1=2; - int LA1_0 = input.LA(1); - - if ( (LA1_0==27) ) { - alt1=1; - } - - - switch (alt1) { - case 1 : - // InternalRos.g:115:5: otherlv_4= ',' ( (lv_package_5_0= rulePackage ) ) - { - otherlv_4=(Token)match(input,27,FOLLOW_6); - - newLeafNode(otherlv_4, grammarAccess.getPackageSetAccess().getCommaKeyword_3_1_0()); - - // InternalRos.g:119:5: ( (lv_package_5_0= rulePackage ) ) - // InternalRos.g:120:6: (lv_package_5_0= rulePackage ) - { - // InternalRos.g:120:6: (lv_package_5_0= rulePackage ) - // InternalRos.g:121:7: lv_package_5_0= rulePackage - { - - newCompositeNode(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_1_1_0()); - - pushFollow(FOLLOW_5); - lv_package_5_0=rulePackage(); - - state._fsp--; - + // InternalRosParser.g:79:3: ( (lv_package_1_0= rulePackage_Impl ) )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); - if (current==null) { - current = createModelElementForParent(grammarAccess.getPackageSetRule()); - } - add( - current, - "package", - lv_package_5_0, - "de.fraunhofer.ipa.ros.Ros.Package"); - afterParserOrEnumRuleCall(); - + if ( (LA1_0==Node||(LA1_0>=RULE_ID && LA1_0<=RULE_ROS_CONVENTION_A)) ) { + alt1=1; + } - } + switch (alt1) { + case 1 : + // InternalRosParser.g:80:4: (lv_package_1_0= rulePackage_Impl ) + { + // InternalRosParser.g:80:4: (lv_package_1_0= rulePackage_Impl ) + // InternalRosParser.g:81:5: lv_package_1_0= rulePackage_Impl + { - } + newCompositeNode(grammarAccess.getPackageSetAccess().getPackagePackage_ImplParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_package_1_0=rulePackage_Impl(); + state._fsp--; - } - break; - default : - break loop1; - } - } while (true); + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackageSetRule()); + } + add( + current, + "package", + lv_package_1_0, + "de.fraunhofer.ipa.ros.Ros.Package_Impl"); + afterParserOrEnumRuleCall(); + + } - } - break; - } + } + break; - otherlv_6=(Token)match(input,28,FOLLOW_2); + default : + break loop1; + } + } while (true); - newLeafNode(otherlv_6, grammarAccess.getPackageSetAccess().getRightCurlyBracketKeyword_4()); - } @@ -386,25 +310,25 @@ public final EObject rulePackageSet() throws RecognitionException { // $ANTLR end "rulePackageSet" - // $ANTLR start "entryRulePackage" - // InternalRos.g:148:1: entryRulePackage returns [EObject current=null] : iv_rulePackage= rulePackage EOF ; - public final EObject entryRulePackage() throws RecognitionException { - EObject current = null; + // $ANTLR start "entryRuleEString" + // InternalRosParser.g:102:1: entryRuleEString returns [String current=null] : iv_ruleEString= ruleEString EOF ; + public final String entryRuleEString() throws RecognitionException { + String current = null; - EObject iv_rulePackage = null; + AntlrDatatypeRuleToken iv_ruleEString = null; try { - // InternalRos.g:148:48: (iv_rulePackage= rulePackage EOF ) - // InternalRos.g:149:2: iv_rulePackage= rulePackage EOF + // InternalRosParser.g:102:47: (iv_ruleEString= ruleEString EOF ) + // InternalRosParser.g:103:2: iv_ruleEString= ruleEString EOF { - newCompositeNode(grammarAccess.getPackageRule()); + newCompositeNode(grammarAccess.getEStringRule()); pushFollow(FOLLOW_1); - iv_rulePackage=rulePackage(); + iv_ruleEString=ruleEString(); state._fsp--; - current =iv_rulePackage; + current =iv_ruleEString.getText(); match(input,EOF,FOLLOW_2); } @@ -419,104 +343,63 @@ public final EObject entryRulePackage() throws RecognitionException { } return current; } - // $ANTLR end "entryRulePackage" - - - // $ANTLR start "rulePackage" - // InternalRos.g:155:1: rulePackage returns [EObject current=null] : (this_Package_Impl_0= rulePackage_Impl | this_CatkinPackage_1= ruleCatkinPackage | this_AmentPackage_2= ruleAmentPackage ) ; - public final EObject rulePackage() throws RecognitionException { - EObject current = null; - - EObject this_Package_Impl_0 = null; + // $ANTLR end "entryRuleEString" - EObject this_CatkinPackage_1 = null; - EObject this_AmentPackage_2 = null; + // $ANTLR start "ruleEString" + // InternalRosParser.g:109: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 { - // InternalRos.g:161:2: ( (this_Package_Impl_0= rulePackage_Impl | this_CatkinPackage_1= ruleCatkinPackage | this_AmentPackage_2= ruleAmentPackage ) ) - // InternalRos.g:162:2: (this_Package_Impl_0= rulePackage_Impl | this_CatkinPackage_1= ruleCatkinPackage | this_AmentPackage_2= ruleAmentPackage ) + // InternalRosParser.g:115:2: ( (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) ) + // InternalRosParser.g:116:2: (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) { - // InternalRos.g:162:2: (this_Package_Impl_0= rulePackage_Impl | this_CatkinPackage_1= ruleCatkinPackage | this_AmentPackage_2= ruleAmentPackage ) - int alt3=3; - switch ( input.LA(1) ) { - case 29: - { - alt3=1; - } - break; - case 34: - { - alt3=2; - } - break; - case 36: - { - alt3=3; - } - break; - default: + // InternalRosParser.g:116:2: (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0==RULE_STRING) ) { + alt2=1; + } + else if ( (LA2_0==RULE_ID) ) { + alt2=2; + } + else { NoViableAltException nvae = - new NoViableAltException("", 3, 0, input); + new NoViableAltException("", 2, 0, input); throw nvae; } - - switch (alt3) { + switch (alt2) { case 1 : - // InternalRos.g:163:3: this_Package_Impl_0= rulePackage_Impl + // InternalRosParser.g:117:3: this_STRING_0= RULE_STRING { + this_STRING_0=(Token)match(input,RULE_STRING,FOLLOW_2); - newCompositeNode(grammarAccess.getPackageAccess().getPackage_ImplParserRuleCall_0()); + current.merge(this_STRING_0); - pushFollow(FOLLOW_2); - this_Package_Impl_0=rulePackage_Impl(); - - state._fsp--; - - current = this_Package_Impl_0; - afterParserOrEnumRuleCall(); + newLeafNode(this_STRING_0, grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); } break; case 2 : - // InternalRos.g:172:3: this_CatkinPackage_1= ruleCatkinPackage - { - - newCompositeNode(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall_1()); - - pushFollow(FOLLOW_2); - this_CatkinPackage_1=ruleCatkinPackage(); - - state._fsp--; - - - current = this_CatkinPackage_1; - afterParserOrEnumRuleCall(); - - - } - break; - case 3 : - // InternalRos.g:181:3: this_AmentPackage_2= ruleAmentPackage + // InternalRosParser.g:125:3: this_ID_1= RULE_ID { + this_ID_1=(Token)match(input,RULE_ID,FOLLOW_2); - newCompositeNode(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall_2()); + current.merge(this_ID_1); - pushFollow(FOLLOW_2); - this_AmentPackage_2=ruleAmentPackage(); - state._fsp--; - - - current = this_AmentPackage_2; - afterParserOrEnumRuleCall(); + newLeafNode(this_ID_1, grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); } @@ -540,28 +423,28 @@ public final EObject rulePackage() throws RecognitionException { } return current; } - // $ANTLR end "rulePackage" + // $ANTLR end "ruleEString" - // $ANTLR start "entryRuleSpecBase" - // InternalRos.g:193:1: entryRuleSpecBase returns [EObject current=null] : iv_ruleSpecBase= ruleSpecBase EOF ; - public final EObject entryRuleSpecBase() throws RecognitionException { - EObject current = null; + // $ANTLR start "entryRuleRosNames" + // InternalRosParser.g:136:1: entryRuleRosNames returns [String current=null] : iv_ruleRosNames= ruleRosNames EOF ; + public final String entryRuleRosNames() throws RecognitionException { + String current = null; - EObject iv_ruleSpecBase = null; + AntlrDatatypeRuleToken iv_ruleRosNames = null; try { - // InternalRos.g:193:49: (iv_ruleSpecBase= ruleSpecBase EOF ) - // InternalRos.g:194:2: iv_ruleSpecBase= ruleSpecBase EOF + // InternalRosParser.g:136:48: (iv_ruleRosNames= ruleRosNames EOF ) + // InternalRosParser.g:137:2: iv_ruleRosNames= ruleRosNames EOF { - newCompositeNode(grammarAccess.getSpecBaseRule()); + newCompositeNode(grammarAccess.getRosNamesRule()); pushFollow(FOLLOW_1); - iv_ruleSpecBase=ruleSpecBase(); + iv_ruleRosNames=ruleRosNames(); state._fsp--; - current =iv_ruleSpecBase; + current =iv_ruleRosNames.getText(); match(input,EOF,FOLLOW_2); } @@ -576,104 +459,84 @@ public final EObject entryRuleSpecBase() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleSpecBase" - - - // $ANTLR start "ruleSpecBase" - // InternalRos.g:200:1: ruleSpecBase returns [EObject current=null] : (this_ServiceSpec_0= ruleServiceSpec | this_TopicSpec_1= ruleTopicSpec | this_ActionSpec_2= ruleActionSpec ) ; - public final EObject ruleSpecBase() throws RecognitionException { - EObject current = null; - - EObject this_ServiceSpec_0 = null; + // $ANTLR end "entryRuleRosNames" - EObject this_TopicSpec_1 = null; - EObject this_ActionSpec_2 = null; + // $ANTLR start "ruleRosNames" + // InternalRosParser.g:143: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 { - // InternalRos.g:206:2: ( (this_ServiceSpec_0= ruleServiceSpec | this_TopicSpec_1= ruleTopicSpec | this_ActionSpec_2= ruleActionSpec ) ) - // InternalRos.g:207:2: (this_ServiceSpec_0= ruleServiceSpec | this_TopicSpec_1= ruleTopicSpec | this_ActionSpec_2= ruleActionSpec ) + // InternalRosParser.g:149:2: ( (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) ) + // InternalRosParser.g:150:2: (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) { - // InternalRos.g:207:2: (this_ServiceSpec_0= ruleServiceSpec | this_TopicSpec_1= ruleTopicSpec | this_ActionSpec_2= ruleActionSpec ) - int alt4=3; + // InternalRosParser.g:150:2: (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) + int alt3=3; switch ( input.LA(1) ) { - case 37: + case RULE_ROS_CONVENTION_A: { - alt4=1; + alt3=1; } break; - case 40: + case RULE_ID: { - alt4=2; + alt3=2; } break; - case 44: + case Node: { - alt4=3; + alt3=3; } break; default: NoViableAltException nvae = - new NoViableAltException("", 4, 0, input); + new NoViableAltException("", 3, 0, input); throw nvae; } - switch (alt4) { + switch (alt3) { case 1 : - // InternalRos.g:208:3: this_ServiceSpec_0= ruleServiceSpec + // InternalRosParser.g:151:3: this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A { + this_ROS_CONVENTION_A_0=(Token)match(input,RULE_ROS_CONVENTION_A,FOLLOW_2); - newCompositeNode(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_0()); + current.merge(this_ROS_CONVENTION_A_0); - pushFollow(FOLLOW_2); - this_ServiceSpec_0=ruleServiceSpec(); - state._fsp--; - - - current = this_ServiceSpec_0; - afterParserOrEnumRuleCall(); + newLeafNode(this_ROS_CONVENTION_A_0, grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); } break; case 2 : - // InternalRos.g:217:3: this_TopicSpec_1= ruleTopicSpec + // InternalRosParser.g:159:3: this_ID_1= RULE_ID { + this_ID_1=(Token)match(input,RULE_ID,FOLLOW_2); - newCompositeNode(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_1()); + current.merge(this_ID_1); - pushFollow(FOLLOW_2); - this_TopicSpec_1=ruleTopicSpec(); - state._fsp--; - - - current = this_TopicSpec_1; - afterParserOrEnumRuleCall(); + newLeafNode(this_ID_1, grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); } break; case 3 : - // InternalRos.g:226:3: this_ActionSpec_2= ruleActionSpec + // InternalRosParser.g:167:3: kw= Node { + kw=(Token)match(input,Node,FOLLOW_2); - newCompositeNode(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); - - pushFollow(FOLLOW_2); - this_ActionSpec_2=ruleActionSpec(); - - state._fsp--; - - - current = this_ActionSpec_2; - afterParserOrEnumRuleCall(); + current.merge(kw); + newLeafNode(kw, grammarAccess.getRosNamesAccess().getNodeKeyword_2()); } @@ -697,28 +560,28 @@ public final EObject ruleSpecBase() throws RecognitionException { } return current; } - // $ANTLR end "ruleSpecBase" + // $ANTLR end "ruleRosNames" - // $ANTLR start "entryRuleDependency" - // InternalRos.g:238:1: entryRuleDependency returns [EObject current=null] : iv_ruleDependency= ruleDependency EOF ; - public final EObject entryRuleDependency() throws RecognitionException { + // $ANTLR start "entryRulePackage_Impl" + // InternalRosParser.g:176:1: entryRulePackage_Impl returns [EObject current=null] : iv_rulePackage_Impl= rulePackage_Impl EOF ; + public final EObject entryRulePackage_Impl() throws RecognitionException { EObject current = null; - EObject iv_ruleDependency = null; + EObject iv_rulePackage_Impl = null; try { - // InternalRos.g:238:51: (iv_ruleDependency= ruleDependency EOF ) - // InternalRos.g:239:2: iv_ruleDependency= ruleDependency EOF + // InternalRosParser.g:176:53: (iv_rulePackage_Impl= rulePackage_Impl EOF ) + // InternalRosParser.g:177:2: iv_rulePackage_Impl= rulePackage_Impl EOF { - newCompositeNode(grammarAccess.getDependencyRule()); + newCompositeNode(grammarAccess.getPackage_ImplRule()); pushFollow(FOLLOW_1); - iv_ruleDependency=ruleDependency(); + iv_rulePackage_Impl=rulePackage_Impl(); state._fsp--; - current =iv_ruleDependency; + current =iv_rulePackage_Impl; match(input,EOF,FOLLOW_2); } @@ -733,1233 +596,79 @@ public final EObject entryRuleDependency() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleDependency" + // $ANTLR end "entryRulePackage_Impl" - // $ANTLR start "ruleDependency" - // InternalRos.g:245:1: ruleDependency returns [EObject current=null] : (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) ; - public final EObject ruleDependency() throws RecognitionException { + // $ANTLR start "rulePackage_Impl" + // InternalRosParser.g:183:1: rulePackage_Impl 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= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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 rulePackage_Impl() throws RecognitionException { EObject current = null; - EObject this_PackageDependency_0 = 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; - EObject this_ExternalDependency_1 = null; + AntlrDatatypeRuleToken lv_fromGitRepo_5_0 = null; + EObject lv_spec_8_0 = null; + EObject lv_dependency_12_0 = null; - enterRule(); - - try { - // InternalRos.g:251:2: ( (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) ) - // InternalRos.g:252:2: (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) - { - // InternalRos.g:252:2: (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) - int alt5=2; - int LA5_0 = input.LA(1); - - if ( ((LA5_0>=RULE_STRING && LA5_0<=RULE_ID)) ) { - alt5=1; - } - else if ( (LA5_0==67) ) { - alt5=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 5, 0, input); - - throw nvae; - } - switch (alt5) { - case 1 : - // InternalRos.g:253: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 : - // InternalRos.g:262: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 "entryRuleNamespace" - // InternalRos.g:274:1: entryRuleNamespace returns [EObject current=null] : iv_ruleNamespace= ruleNamespace EOF ; - public final EObject entryRuleNamespace() throws RecognitionException { - EObject current = null; - - EObject iv_ruleNamespace = null; - - - try { - // InternalRos.g:274:50: (iv_ruleNamespace= ruleNamespace EOF ) - // InternalRos.g:275:2: iv_ruleNamespace= ruleNamespace EOF - { - newCompositeNode(grammarAccess.getNamespaceRule()); - pushFollow(FOLLOW_1); - iv_ruleNamespace=ruleNamespace(); - - state._fsp--; - - current =iv_ruleNamespace; - match(input,EOF,FOLLOW_2); - - } - - } - - catch (RecognitionException re) { - recover(input,re); - appendSkippedTokens(); - } - finally { - } - return current; - } - // $ANTLR end "entryRuleNamespace" - - - // $ANTLR start "ruleNamespace" - // InternalRos.g:281:1: ruleNamespace returns [EObject current=null] : (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) ; - public final EObject ruleNamespace() throws RecognitionException { - EObject current = null; - - EObject this_GlobalNamespace_0 = null; - - EObject this_RelativeNamespace_Impl_1 = null; - - EObject this_PrivateNamespace_2 = null; - - - - enterRule(); - - try { - // InternalRos.g:287:2: ( (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) ) - // InternalRos.g:288:2: (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) - { - // InternalRos.g:288:2: (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) - int alt6=3; - switch ( input.LA(1) ) { - case 68: - { - alt6=1; - } - break; - case 70: - { - alt6=2; - } - break; - case 71: - { - alt6=3; - } - break; - default: - NoViableAltException nvae = - new NoViableAltException("", 6, 0, input); - - throw nvae; - } - - switch (alt6) { - case 1 : - // InternalRos.g:289:3: this_GlobalNamespace_0= ruleGlobalNamespace - { - - newCompositeNode(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); - - pushFollow(FOLLOW_2); - this_GlobalNamespace_0=ruleGlobalNamespace(); - - state._fsp--; - - - current = this_GlobalNamespace_0; - afterParserOrEnumRuleCall(); - - - } - break; - case 2 : - // InternalRos.g:298:3: this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl - { - - newCompositeNode(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); - - pushFollow(FOLLOW_2); - this_RelativeNamespace_Impl_1=ruleRelativeNamespace_Impl(); - - state._fsp--; - - - current = this_RelativeNamespace_Impl_1; - afterParserOrEnumRuleCall(); - - - } - break; - case 3 : - // InternalRos.g:307:3: this_PrivateNamespace_2= rulePrivateNamespace - { - - newCompositeNode(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); - - pushFollow(FOLLOW_2); - this_PrivateNamespace_2=rulePrivateNamespace(); - - state._fsp--; - - - current = this_PrivateNamespace_2; - afterParserOrEnumRuleCall(); - - - } - break; - - } - - - } - - - leaveRule(); - - } - - catch (RecognitionException re) { - recover(input,re); - appendSkippedTokens(); - } - finally { - } - return current; - } - // $ANTLR end "ruleNamespace" - - - // $ANTLR start "entryRulePackage_Impl" - // InternalRos.g:319:1: entryRulePackage_Impl returns [EObject current=null] : iv_rulePackage_Impl= rulePackage_Impl EOF ; - public final EObject entryRulePackage_Impl() throws RecognitionException { - EObject current = null; - - EObject iv_rulePackage_Impl = null; - - - try { - // InternalRos.g:319:53: (iv_rulePackage_Impl= rulePackage_Impl EOF ) - // InternalRos.g:320:2: iv_rulePackage_Impl= rulePackage_Impl EOF - { - newCompositeNode(grammarAccess.getPackage_ImplRule()); - pushFollow(FOLLOW_1); - iv_rulePackage_Impl=rulePackage_Impl(); - - state._fsp--; - - current =iv_rulePackage_Impl; - match(input,EOF,FOLLOW_2); - - } - - } - - catch (RecognitionException re) { - recover(input,re); - appendSkippedTokens(); - } - finally { - } - return current; - } - // $ANTLR end "entryRulePackage_Impl" - - - // $ANTLR start "rulePackage_Impl" - // InternalRos.g:326:1: rulePackage_Impl returns [EObject current=null] : ( () otherlv_1= 'Package' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Specs' otherlv_7= '{' ( (lv_spec_8_0= ruleSpecBase ) ) (otherlv_9= ',' ( (lv_spec_10_0= ruleSpecBase ) ) )* otherlv_11= '}' )? ( ( (lv_artifact_12_0= ruleArtifact ) ) (otherlv_13= ',' ( (lv_artifact_14_0= ruleArtifact ) ) )* )? otherlv_15= '}' ) ; - public final EObject rulePackage_Impl() throws RecognitionException { - EObject current = null; - - Token otherlv_1=null; - Token otherlv_3=null; - Token otherlv_4=null; - Token otherlv_6=null; - Token otherlv_7=null; - Token otherlv_9=null; - Token otherlv_11=null; - Token otherlv_13=null; - Token otherlv_15=null; - AntlrDatatypeRuleToken lv_name_2_0 = null; - - AntlrDatatypeRuleToken lv_fromGitRepo_5_0 = null; - - EObject lv_spec_8_0 = null; - - EObject lv_spec_10_0 = null; - - EObject lv_artifact_12_0 = null; - - EObject lv_artifact_14_0 = null; - - - - enterRule(); - - try { - // InternalRos.g:332:2: ( ( () otherlv_1= 'Package' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Specs' otherlv_7= '{' ( (lv_spec_8_0= ruleSpecBase ) ) (otherlv_9= ',' ( (lv_spec_10_0= ruleSpecBase ) ) )* otherlv_11= '}' )? ( ( (lv_artifact_12_0= ruleArtifact ) ) (otherlv_13= ',' ( (lv_artifact_14_0= ruleArtifact ) ) )* )? otherlv_15= '}' ) ) - // InternalRos.g:333:2: ( () otherlv_1= 'Package' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Specs' otherlv_7= '{' ( (lv_spec_8_0= ruleSpecBase ) ) (otherlv_9= ',' ( (lv_spec_10_0= ruleSpecBase ) ) )* otherlv_11= '}' )? ( ( (lv_artifact_12_0= ruleArtifact ) ) (otherlv_13= ',' ( (lv_artifact_14_0= ruleArtifact ) ) )* )? otherlv_15= '}' ) - { - // InternalRos.g:333:2: ( () otherlv_1= 'Package' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Specs' otherlv_7= '{' ( (lv_spec_8_0= ruleSpecBase ) ) (otherlv_9= ',' ( (lv_spec_10_0= ruleSpecBase ) ) )* otherlv_11= '}' )? ( ( (lv_artifact_12_0= ruleArtifact ) ) (otherlv_13= ',' ( (lv_artifact_14_0= ruleArtifact ) ) )* )? otherlv_15= '}' ) - // InternalRos.g:334:3: () otherlv_1= 'Package' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Specs' otherlv_7= '{' ( (lv_spec_8_0= ruleSpecBase ) ) (otherlv_9= ',' ( (lv_spec_10_0= ruleSpecBase ) ) )* otherlv_11= '}' )? ( ( (lv_artifact_12_0= ruleArtifact ) ) (otherlv_13= ',' ( (lv_artifact_14_0= ruleArtifact ) ) )* )? otherlv_15= '}' - { - // InternalRos.g:334:3: () - // InternalRos.g:335:4: - { - - current = forceCreateModelElement( - grammarAccess.getPackage_ImplAccess().getPackageAction_0(), - current); - - - } - - otherlv_1=(Token)match(input,29,FOLLOW_7); - - newLeafNode(otherlv_1, grammarAccess.getPackage_ImplAccess().getPackageKeyword_1()); - - // InternalRos.g:345:3: ( (lv_name_2_0= ruleEString ) ) - // InternalRos.g:346:4: (lv_name_2_0= ruleEString ) - { - // InternalRos.g:346:4: (lv_name_2_0= ruleEString ) - // InternalRos.g:347:5: lv_name_2_0= ruleEString - { - - newCompositeNode(grammarAccess.getPackage_ImplAccess().getNameEStringParserRuleCall_2_0()); - - pushFollow(FOLLOW_3); - lv_name_2_0=ruleEString(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); - } - set( - current, - "name", - lv_name_2_0, - "de.fraunhofer.ipa.ros.Ros.EString"); - afterParserOrEnumRuleCall(); - - - } - - - } - - otherlv_3=(Token)match(input,26,FOLLOW_8); - - newLeafNode(otherlv_3, grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_3()); - - // InternalRos.g:368:3: (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? - int alt7=2; - int LA7_0 = input.LA(1); - - if ( (LA7_0==30) ) { - alt7=1; - } - switch (alt7) { - case 1 : - // InternalRos.g:369:4: otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) - { - otherlv_4=(Token)match(input,30,FOLLOW_7); - - newLeafNode(otherlv_4, grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); - - // InternalRos.g:373:4: ( (lv_fromGitRepo_5_0= ruleEString ) ) - // InternalRos.g:374:5: (lv_fromGitRepo_5_0= ruleEString ) - { - // InternalRos.g:374:5: (lv_fromGitRepo_5_0= ruleEString ) - // InternalRos.g:375:6: lv_fromGitRepo_5_0= ruleEString - { - - newCompositeNode(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); - - pushFollow(FOLLOW_9); - lv_fromGitRepo_5_0=ruleEString(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); - } - set( - current, - "fromGitRepo", - lv_fromGitRepo_5_0, - "de.fraunhofer.ipa.ros.Ros.EString"); - afterParserOrEnumRuleCall(); - - - } - - - } - - - } - break; - - } - - // InternalRos.g:393:3: (otherlv_6= 'Specs' otherlv_7= '{' ( (lv_spec_8_0= ruleSpecBase ) ) (otherlv_9= ',' ( (lv_spec_10_0= ruleSpecBase ) ) )* otherlv_11= '}' )? - int alt9=2; - int LA9_0 = input.LA(1); - - if ( (LA9_0==31) ) { - alt9=1; - } - switch (alt9) { - case 1 : - // InternalRos.g:394:4: otherlv_6= 'Specs' otherlv_7= '{' ( (lv_spec_8_0= ruleSpecBase ) ) (otherlv_9= ',' ( (lv_spec_10_0= ruleSpecBase ) ) )* otherlv_11= '}' - { - otherlv_6=(Token)match(input,31,FOLLOW_3); - - newLeafNode(otherlv_6, grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); - - otherlv_7=(Token)match(input,26,FOLLOW_10); - - newLeafNode(otherlv_7, grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_5_1()); - - // InternalRos.g:402:4: ( (lv_spec_8_0= ruleSpecBase ) ) - // InternalRos.g:403:5: (lv_spec_8_0= ruleSpecBase ) - { - // InternalRos.g:403:5: (lv_spec_8_0= ruleSpecBase ) - // InternalRos.g:404:6: lv_spec_8_0= ruleSpecBase - { - - newCompositeNode(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); - - pushFollow(FOLLOW_5); - lv_spec_8_0=ruleSpecBase(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); - } - add( - current, - "spec", - lv_spec_8_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); - afterParserOrEnumRuleCall(); - - - } - - - } - - // InternalRos.g:421:4: (otherlv_9= ',' ( (lv_spec_10_0= ruleSpecBase ) ) )* - loop8: - do { - int alt8=2; - int LA8_0 = input.LA(1); - - if ( (LA8_0==27) ) { - alt8=1; - } - - - switch (alt8) { - case 1 : - // InternalRos.g:422:5: otherlv_9= ',' ( (lv_spec_10_0= ruleSpecBase ) ) - { - otherlv_9=(Token)match(input,27,FOLLOW_10); - - newLeafNode(otherlv_9, grammarAccess.getPackage_ImplAccess().getCommaKeyword_5_3_0()); - - // InternalRos.g:426:5: ( (lv_spec_10_0= ruleSpecBase ) ) - // InternalRos.g:427:6: (lv_spec_10_0= ruleSpecBase ) - { - // InternalRos.g:427:6: (lv_spec_10_0= ruleSpecBase ) - // InternalRos.g:428:7: lv_spec_10_0= ruleSpecBase - { - - newCompositeNode(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_3_1_0()); - - pushFollow(FOLLOW_5); - lv_spec_10_0=ruleSpecBase(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); - } - add( - current, - "spec", - lv_spec_10_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); - afterParserOrEnumRuleCall(); - - - } - - - } - - - } - break; - - default : - break loop8; - } - } while (true); - - otherlv_11=(Token)match(input,28,FOLLOW_11); - - newLeafNode(otherlv_11, grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_5_4()); - - - } - break; - - } - - // InternalRos.g:451:3: ( ( (lv_artifact_12_0= ruleArtifact ) ) (otherlv_13= ',' ( (lv_artifact_14_0= ruleArtifact ) ) )* )? - int alt11=2; - int LA11_0 = input.LA(1); - - if ( (LA11_0==33) ) { - alt11=1; - } - switch (alt11) { - case 1 : - // InternalRos.g:452:4: ( (lv_artifact_12_0= ruleArtifact ) ) (otherlv_13= ',' ( (lv_artifact_14_0= ruleArtifact ) ) )* - { - // InternalRos.g:452:4: ( (lv_artifact_12_0= ruleArtifact ) ) - // InternalRos.g:453:5: (lv_artifact_12_0= ruleArtifact ) - { - // InternalRos.g:453:5: (lv_artifact_12_0= ruleArtifact ) - // InternalRos.g:454:6: lv_artifact_12_0= ruleArtifact - { - - newCompositeNode(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_0_0()); - - pushFollow(FOLLOW_5); - lv_artifact_12_0=ruleArtifact(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); - } - add( - current, - "artifact", - lv_artifact_12_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); - afterParserOrEnumRuleCall(); - - - } - - - } - - // InternalRos.g:471:4: (otherlv_13= ',' ( (lv_artifact_14_0= ruleArtifact ) ) )* - loop10: - do { - int alt10=2; - int LA10_0 = input.LA(1); - - if ( (LA10_0==27) ) { - alt10=1; - } - - - switch (alt10) { - case 1 : - // InternalRos.g:472:5: otherlv_13= ',' ( (lv_artifact_14_0= ruleArtifact ) ) - { - otherlv_13=(Token)match(input,27,FOLLOW_12); - - newLeafNode(otherlv_13, grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_1_0()); - - // InternalRos.g:476:5: ( (lv_artifact_14_0= ruleArtifact ) ) - // InternalRos.g:477:6: (lv_artifact_14_0= ruleArtifact ) - { - // InternalRos.g:477:6: (lv_artifact_14_0= ruleArtifact ) - // InternalRos.g:478:7: lv_artifact_14_0= ruleArtifact - { - - newCompositeNode(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_1_1_0()); - - pushFollow(FOLLOW_5); - lv_artifact_14_0=ruleArtifact(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); - } - add( - current, - "artifact", - lv_artifact_14_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); - afterParserOrEnumRuleCall(); - - - } - - - } - - - } - break; - - default : - break loop10; - } - } while (true); - - - } - break; - - } - - otherlv_15=(Token)match(input,28,FOLLOW_2); - - newLeafNode(otherlv_15, grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_7()); - - - } - - - } - - - leaveRule(); - - } - - catch (RecognitionException re) { - recover(input,re); - appendSkippedTokens(); - } - finally { - } - return current; - } - // $ANTLR end "rulePackage_Impl" - - - // $ANTLR start "entryRuleEString" - // InternalRos.g:505:1: entryRuleEString returns [String current=null] : iv_ruleEString= ruleEString EOF ; - public final String entryRuleEString() throws RecognitionException { - String current = null; - - AntlrDatatypeRuleToken iv_ruleEString = null; - - - try { - // InternalRos.g:505:47: (iv_ruleEString= ruleEString EOF ) - // InternalRos.g:506: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" - // InternalRos.g:512: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 { - // InternalRos.g:518:2: ( (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) ) - // InternalRos.g:519:2: (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) - { - // InternalRos.g:519:2: (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) - int alt12=2; - int LA12_0 = input.LA(1); - - if ( (LA12_0==RULE_STRING) ) { - alt12=1; - } - else if ( (LA12_0==RULE_ID) ) { - alt12=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 12, 0, input); - - throw nvae; - } - switch (alt12) { - case 1 : - // InternalRos.g:520: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 : - // InternalRos.g:528: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" - - - // $ANTLR start "entryRuleRosNames" - // InternalRos.g:539:1: entryRuleRosNames returns [String current=null] : iv_ruleRosNames= ruleRosNames EOF ; - public final String entryRuleRosNames() throws RecognitionException { - String current = null; - - AntlrDatatypeRuleToken iv_ruleRosNames = null; - - - try { - // InternalRos.g:539:48: (iv_ruleRosNames= ruleRosNames EOF ) - // InternalRos.g:540: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" - // InternalRos.g:546: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 { - // InternalRos.g:552:2: ( (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= 'node' ) ) - // InternalRos.g:553:2: (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= 'node' ) - { - // InternalRos.g:553:2: (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= 'node' ) - int alt13=3; - switch ( input.LA(1) ) { - case RULE_ROS_CONVENTION_A: - { - alt13=1; - } - break; - case RULE_ID: - { - alt13=2; - } - break; - case 32: - { - alt13=3; - } - break; - default: - NoViableAltException nvae = - new NoViableAltException("", 13, 0, input); - - throw nvae; - } - - switch (alt13) { - case 1 : - // InternalRos.g:554: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 : - // InternalRos.g:562: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 : - // InternalRos.g:570:3: kw= 'node' - { - kw=(Token)match(input,32,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 "entryRuleArtifact" - // InternalRos.g:579:1: entryRuleArtifact returns [EObject current=null] : iv_ruleArtifact= ruleArtifact EOF ; - public final EObject entryRuleArtifact() throws RecognitionException { - EObject current = null; - - EObject iv_ruleArtifact = null; - - - try { - // InternalRos.g:579:49: (iv_ruleArtifact= ruleArtifact EOF ) - // InternalRos.g:580: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" - // InternalRos.g:586:1: ruleArtifact returns [EObject current=null] : ( () otherlv_1= 'Artifact' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' ( (lv_node_4_0= ruleNode ) )? otherlv_5= '}' ) ; - public final EObject ruleArtifact() throws RecognitionException { - EObject current = null; - - Token otherlv_1=null; - Token otherlv_3=null; - Token otherlv_5=null; - AntlrDatatypeRuleToken lv_name_2_0 = null; - - EObject lv_node_4_0 = null; - - - - enterRule(); - - try { - // InternalRos.g:592:2: ( ( () otherlv_1= 'Artifact' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' ( (lv_node_4_0= ruleNode ) )? otherlv_5= '}' ) ) - // InternalRos.g:593:2: ( () otherlv_1= 'Artifact' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' ( (lv_node_4_0= ruleNode ) )? otherlv_5= '}' ) - { - // InternalRos.g:593:2: ( () otherlv_1= 'Artifact' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' ( (lv_node_4_0= ruleNode ) )? otherlv_5= '}' ) - // InternalRos.g:594:3: () otherlv_1= 'Artifact' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' ( (lv_node_4_0= ruleNode ) )? otherlv_5= '}' - { - // InternalRos.g:594:3: () - // InternalRos.g:595:4: - { - - current = forceCreateModelElement( - grammarAccess.getArtifactAccess().getArtifactAction_0(), - current); - - - } - - otherlv_1=(Token)match(input,33,FOLLOW_13); - - newLeafNode(otherlv_1, grammarAccess.getArtifactAccess().getArtifactKeyword_1()); - - // InternalRos.g:605:3: ( (lv_name_2_0= ruleRosNames ) ) - // InternalRos.g:606:4: (lv_name_2_0= ruleRosNames ) - { - // InternalRos.g:606:4: (lv_name_2_0= ruleRosNames ) - // InternalRos.g:607:5: lv_name_2_0= ruleRosNames - { - - newCompositeNode(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_2_0()); - - pushFollow(FOLLOW_3); - lv_name_2_0=ruleRosNames(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getArtifactRule()); - } - set( - current, - "name", - lv_name_2_0, - "de.fraunhofer.ipa.ros.Ros.RosNames"); - afterParserOrEnumRuleCall(); - - - } - - - } - - otherlv_3=(Token)match(input,26,FOLLOW_14); - - newLeafNode(otherlv_3, grammarAccess.getArtifactAccess().getLeftCurlyBracketKeyword_3()); - - // InternalRos.g:628:3: ( (lv_node_4_0= ruleNode ) )? - int alt14=2; - int LA14_0 = input.LA(1); - - if ( (LA14_0==48) ) { - alt14=1; - } - switch (alt14) { - case 1 : - // InternalRos.g:629:4: (lv_node_4_0= ruleNode ) - { - // InternalRos.g:629:4: (lv_node_4_0= ruleNode ) - // InternalRos.g:630:5: lv_node_4_0= ruleNode - { - - newCompositeNode(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); - - pushFollow(FOLLOW_15); - lv_node_4_0=ruleNode(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getArtifactRule()); - } - set( - current, - "node", - lv_node_4_0, - "de.fraunhofer.ipa.ros.Ros.Node"); - afterParserOrEnumRuleCall(); - - - } - - - } - break; - - } - - otherlv_5=(Token)match(input,28,FOLLOW_2); - - newLeafNode(otherlv_5, grammarAccess.getArtifactAccess().getRightCurlyBracketKeyword_5()); - - - } - - - } - - - leaveRule(); - - } - - catch (RecognitionException re) { - recover(input,re); - appendSkippedTokens(); - } - finally { - } - return current; - } - // $ANTLR end "ruleArtifact" - - - // $ANTLR start "entryRuleCatkinPackage" - // InternalRos.g:655:1: entryRuleCatkinPackage returns [EObject current=null] : iv_ruleCatkinPackage= ruleCatkinPackage EOF ; - public final EObject entryRuleCatkinPackage() throws RecognitionException { - EObject current = null; - - EObject iv_ruleCatkinPackage = null; - - - try { - // InternalRos.g:655:54: (iv_ruleCatkinPackage= ruleCatkinPackage EOF ) - // InternalRos.g:656: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" - // InternalRos.g:662:1: ruleCatkinPackage returns [EObject current=null] : ( () otherlv_1= 'CatkinPackage' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? otherlv_21= '}' ) ; - public final EObject ruleCatkinPackage() throws RecognitionException { - EObject current = null; - - Token otherlv_1=null; - Token otherlv_3=null; - Token otherlv_4=null; - Token otherlv_6=null; - Token otherlv_7=null; - Token otherlv_9=null; - Token otherlv_11=null; - Token otherlv_12=null; - Token otherlv_13=null; - Token otherlv_15=null; - Token otherlv_17=null; - Token otherlv_19=null; - Token otherlv_21=null; - AntlrDatatypeRuleToken lv_name_2_0 = null; - - AntlrDatatypeRuleToken lv_fromGitRepo_5_0 = null; - - EObject lv_dependency_8_0 = null; - - EObject lv_dependency_10_0 = null; - - EObject lv_spec_14_0 = null; - - EObject lv_spec_16_0 = null; - - EObject lv_artifact_18_0 = null; - - EObject lv_artifact_20_0 = null; + EObject lv_dependency_14_0 = null; enterRule(); try { - // InternalRos.g:668:2: ( ( () otherlv_1= 'CatkinPackage' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? otherlv_21= '}' ) ) - // InternalRos.g:669:2: ( () otherlv_1= 'CatkinPackage' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? otherlv_21= '}' ) + // InternalRosParser.g:189:2: ( ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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 ) ) + // InternalRosParser.g:190:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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 ) { - // InternalRos.g:669:2: ( () otherlv_1= 'CatkinPackage' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? otherlv_21= '}' ) - // InternalRos.g:670:3: () otherlv_1= 'CatkinPackage' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? otherlv_21= '}' + // InternalRosParser.g:190:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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 ) + // InternalRosParser.g:191:3: () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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 { - // InternalRos.g:670:3: () - // InternalRos.g:671:4: + // InternalRosParser.g:191:3: () + // InternalRosParser.g:192:4: { current = forceCreateModelElement( - grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0(), + grammarAccess.getPackage_ImplAccess().getPackageAction_0(), current); } - otherlv_1=(Token)match(input,34,FOLLOW_13); - - newLeafNode(otherlv_1, grammarAccess.getCatkinPackageAccess().getCatkinPackageKeyword_1()); - - // InternalRos.g:681:3: ( (lv_name_2_0= ruleRosNames ) ) - // InternalRos.g:682:4: (lv_name_2_0= ruleRosNames ) + // InternalRosParser.g:198:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRosParser.g:199:4: (lv_name_1_0= ruleRosNames ) { - // InternalRos.g:682:4: (lv_name_2_0= ruleRosNames ) - // InternalRos.g:683:5: lv_name_2_0= ruleRosNames + // InternalRosParser.g:199:4: (lv_name_1_0= ruleRosNames ) + // InternalRosParser.g:200:5: lv_name_1_0= ruleRosNames { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_2_0()); + newCompositeNode(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); - pushFollow(FOLLOW_3); - lv_name_2_0=ruleRosNames(); + pushFollow(FOLLOW_4); + lv_name_1_0=ruleRosNames(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); } set( current, "name", - lv_name_2_0, + lv_name_1_0, "de.fraunhofer.ipa.ros.Ros.RosNames"); afterParserOrEnumRuleCall(); @@ -1969,42 +678,46 @@ public final EObject ruleCatkinPackage() throws RecognitionException { } - otherlv_3=(Token)match(input,26,FOLLOW_16); + otherlv_2=(Token)match(input,Colon,FOLLOW_5); + + newLeafNode(otherlv_2, grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_6); - newLeafNode(otherlv_3, grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_3()); + newLeafNode(this_BEGIN_3, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); - // InternalRos.g:704:3: (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? - int alt15=2; - int LA15_0 = input.LA(1); + // InternalRosParser.g:225:3: (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? + int alt4=2; + int LA4_0 = input.LA(1); - if ( (LA15_0==30) ) { - alt15=1; + if ( (LA4_0==FromGitRepo) ) { + alt4=1; } - switch (alt15) { + switch (alt4) { case 1 : - // InternalRos.g:705:4: otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) + // InternalRosParser.g:226:4: otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) { - otherlv_4=(Token)match(input,30,FOLLOW_7); + otherlv_4=(Token)match(input,FromGitRepo,FOLLOW_7); - newLeafNode(otherlv_4, grammarAccess.getCatkinPackageAccess().getFromGitRepoKeyword_4_0()); + newLeafNode(otherlv_4, grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); - // InternalRos.g:709:4: ( (lv_fromGitRepo_5_0= ruleEString ) ) - // InternalRos.g:710:5: (lv_fromGitRepo_5_0= ruleEString ) + // InternalRosParser.g:230:4: ( (lv_fromGitRepo_5_0= ruleEString ) ) + // InternalRosParser.g:231:5: (lv_fromGitRepo_5_0= ruleEString ) { - // InternalRos.g:710:5: (lv_fromGitRepo_5_0= ruleEString ) - // InternalRos.g:711:6: lv_fromGitRepo_5_0= ruleEString + // InternalRosParser.g:231:5: (lv_fromGitRepo_5_0= ruleEString ) + // InternalRosParser.g:232:6: lv_fromGitRepo_5_0= ruleEString { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + newCompositeNode(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); - pushFollow(FOLLOW_17); + pushFollow(FOLLOW_8); lv_fromGitRepo_5_0=ruleEString(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); } set( current, @@ -2025,103 +738,62 @@ public final EObject ruleCatkinPackage() throws RecognitionException { } - // InternalRos.g:729:3: (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? - int alt17=2; - int LA17_0 = input.LA(1); + // InternalRosParser.g:250:3: (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* this_END_9= RULE_END )? + int alt6=2; + int LA6_0 = input.LA(1); - if ( (LA17_0==35) ) { - alt17=1; + if ( (LA6_0==Specs) ) { + alt6=1; } - switch (alt17) { + switch (alt6) { case 1 : - // InternalRos.g:730:4: otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' + // InternalRosParser.g:251:4: otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* this_END_9= RULE_END { - otherlv_6=(Token)match(input,35,FOLLOW_3); + otherlv_6=(Token)match(input,Specs,FOLLOW_5); - newLeafNode(otherlv_6, grammarAccess.getCatkinPackageAccess().getDependenciesKeyword_5_0()); + newLeafNode(otherlv_6, grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); - otherlv_7=(Token)match(input,26,FOLLOW_18); + this_BEGIN_7=(Token)match(input,RULE_BEGIN,FOLLOW_9); - newLeafNode(otherlv_7, grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_5_1()); + newLeafNode(this_BEGIN_7, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); - // InternalRos.g:738:4: ( (lv_dependency_8_0= ruleDependency ) ) - // InternalRos.g:739:5: (lv_dependency_8_0= ruleDependency ) - { - // InternalRos.g:739:5: (lv_dependency_8_0= ruleDependency ) - // InternalRos.g:740:6: lv_dependency_8_0= ruleDependency - { - - newCompositeNode(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); - - pushFollow(FOLLOW_5); - lv_dependency_8_0=ruleDependency(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); - } - add( - current, - "dependency", - lv_dependency_8_0, - "de.fraunhofer.ipa.ros.Ros.Dependency"); - afterParserOrEnumRuleCall(); - - - } - - - } - - // InternalRos.g:757:4: (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* - loop16: + // InternalRosParser.g:259:4: ( (lv_spec_8_0= ruleSpecBase ) )* + loop5: do { - int alt16=2; - int LA16_0 = input.LA(1); + int alt5=2; + int LA5_0 = input.LA(1); - if ( (LA16_0==27) ) { - alt16=1; + if ( (LA5_0==Action_1||LA5_0==Msg||LA5_0==Srv) ) { + alt5=1; } - switch (alt16) { + switch (alt5) { case 1 : - // InternalRos.g:758:5: otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) - { - otherlv_9=(Token)match(input,27,FOLLOW_18); - - newLeafNode(otherlv_9, grammarAccess.getCatkinPackageAccess().getCommaKeyword_5_3_0()); - - // InternalRos.g:762:5: ( (lv_dependency_10_0= ruleDependency ) ) - // InternalRos.g:763:6: (lv_dependency_10_0= ruleDependency ) + // InternalRosParser.g:260:5: (lv_spec_8_0= ruleSpecBase ) { - // InternalRos.g:763:6: (lv_dependency_10_0= ruleDependency ) - // InternalRos.g:764:7: lv_dependency_10_0= ruleDependency + // InternalRosParser.g:260:5: (lv_spec_8_0= ruleSpecBase ) + // InternalRosParser.g:261:6: lv_spec_8_0= ruleSpecBase { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); - - pushFollow(FOLLOW_5); - lv_dependency_10_0=ruleDependency(); + newCompositeNode(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); + + pushFollow(FOLLOW_9); + lv_spec_8_0=ruleSpecBase(); state._fsp--; - if (current==null) { - current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); - } - add( - current, - "dependency", - lv_dependency_10_0, - "de.fraunhofer.ipa.ros.Ros.Dependency"); - afterParserOrEnumRuleCall(); - - - } - + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + current, + "spec", + lv_spec_8_0, + "de.fraunhofer.ipa.ros.Ros.SpecBase"); + afterParserOrEnumRuleCall(); + } @@ -2130,13 +802,13 @@ public final EObject ruleCatkinPackage() throws RecognitionException { break; default : - break loop16; + break loop5; } } while (true); - otherlv_11=(Token)match(input,28,FOLLOW_9); + this_END_9=(Token)match(input,RULE_END,FOLLOW_10); - newLeafNode(otherlv_11, grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_5_4()); + newLeafNode(this_END_9, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); } @@ -2144,48 +816,48 @@ public final EObject ruleCatkinPackage() throws RecognitionException { } - // InternalRos.g:787:3: (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? - int alt19=2; - int LA19_0 = input.LA(1); + // InternalRosParser.g:283:3: (otherlv_10= Dependencies otherlv_11= LeftSquareBracket ( (lv_dependency_12_0= ruleDependency ) ) (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* otherlv_15= RightSquareBracket )? + int alt8=2; + int LA8_0 = input.LA(1); - if ( (LA19_0==31) ) { - alt19=1; + if ( (LA8_0==Dependencies) ) { + alt8=1; } - switch (alt19) { + switch (alt8) { case 1 : - // InternalRos.g:788:4: otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' + // InternalRosParser.g:284:4: otherlv_10= Dependencies otherlv_11= LeftSquareBracket ( (lv_dependency_12_0= ruleDependency ) ) (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* otherlv_15= RightSquareBracket { - otherlv_12=(Token)match(input,31,FOLLOW_3); + otherlv_10=(Token)match(input,Dependencies,FOLLOW_11); - newLeafNode(otherlv_12, grammarAccess.getCatkinPackageAccess().getSpecsKeyword_6_0()); + newLeafNode(otherlv_10, grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); - otherlv_13=(Token)match(input,26,FOLLOW_10); + otherlv_11=(Token)match(input,LeftSquareBracket,FOLLOW_12); - newLeafNode(otherlv_13, grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_6_1()); + newLeafNode(otherlv_11, grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); - // InternalRos.g:796:4: ( (lv_spec_14_0= ruleSpecBase ) ) - // InternalRos.g:797:5: (lv_spec_14_0= ruleSpecBase ) + // InternalRosParser.g:292:4: ( (lv_dependency_12_0= ruleDependency ) ) + // InternalRosParser.g:293:5: (lv_dependency_12_0= ruleDependency ) { - // InternalRos.g:797:5: (lv_spec_14_0= ruleSpecBase ) - // InternalRos.g:798:6: lv_spec_14_0= ruleSpecBase + // InternalRosParser.g:293:5: (lv_dependency_12_0= ruleDependency ) + // InternalRosParser.g:294:6: lv_dependency_12_0= ruleDependency { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); - pushFollow(FOLLOW_5); - lv_spec_14_0=ruleSpecBase(); + pushFollow(FOLLOW_13); + lv_dependency_12_0=ruleDependency(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); } add( current, - "spec", - lv_spec_14_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); + "dependency", + lv_dependency_12_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); afterParserOrEnumRuleCall(); @@ -2194,48 +866,48 @@ public final EObject ruleCatkinPackage() throws RecognitionException { } - // InternalRos.g:815:4: (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* - loop18: + // InternalRosParser.g:311:4: (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* + loop7: do { - int alt18=2; - int LA18_0 = input.LA(1); + int alt7=2; + int LA7_0 = input.LA(1); - if ( (LA18_0==27) ) { - alt18=1; + if ( (LA7_0==Comma) ) { + alt7=1; } - switch (alt18) { + switch (alt7) { case 1 : - // InternalRos.g:816:5: otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) + // InternalRosParser.g:312:5: otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) { - otherlv_15=(Token)match(input,27,FOLLOW_10); + otherlv_13=(Token)match(input,Comma,FOLLOW_12); - newLeafNode(otherlv_15, grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); + newLeafNode(otherlv_13, grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); - // InternalRos.g:820:5: ( (lv_spec_16_0= ruleSpecBase ) ) - // InternalRos.g:821:6: (lv_spec_16_0= ruleSpecBase ) + // InternalRosParser.g:316:5: ( (lv_dependency_14_0= ruleDependency ) ) + // InternalRosParser.g:317:6: (lv_dependency_14_0= ruleDependency ) { - // InternalRos.g:821:6: (lv_spec_16_0= ruleSpecBase ) - // InternalRos.g:822:7: lv_spec_16_0= ruleSpecBase + // InternalRosParser.g:317:6: (lv_dependency_14_0= ruleDependency ) + // InternalRosParser.g:318:7: lv_dependency_14_0= ruleDependency { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); - pushFollow(FOLLOW_5); - lv_spec_16_0=ruleSpecBase(); + pushFollow(FOLLOW_13); + lv_dependency_14_0=ruleDependency(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); } add( current, - "spec", - lv_spec_16_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); + "dependency", + lv_dependency_14_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); afterParserOrEnumRuleCall(); @@ -2249,13 +921,13 @@ public final EObject ruleCatkinPackage() throws RecognitionException { break; default : - break loop18; + break loop7; } } while (true); - otherlv_17=(Token)match(input,28,FOLLOW_11); + otherlv_15=(Token)match(input,RightSquareBracket,FOLLOW_14); - newLeafNode(otherlv_17, grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_6_4()); + newLeafNode(otherlv_15, grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); } @@ -2263,106 +935,176 @@ public final EObject ruleCatkinPackage() throws RecognitionException { } - // InternalRos.g:845:3: ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? - int alt21=2; - int LA21_0 = input.LA(1); + this_END_16=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_16, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); + - if ( (LA21_0==33) ) { - alt21=1; } - switch (alt21) { - case 1 : - // InternalRos.g:846:4: ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* - { - // InternalRos.g:846:4: ( (lv_artifact_18_0= ruleArtifact ) ) - // InternalRos.g:847:5: (lv_artifact_18_0= ruleArtifact ) - { - // InternalRos.g:847:5: (lv_artifact_18_0= ruleArtifact ) - // InternalRos.g:848:6: lv_artifact_18_0= ruleArtifact - { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); - - pushFollow(FOLLOW_5); - lv_artifact_18_0=ruleArtifact(); - state._fsp--; + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePackage_Impl" + + + // $ANTLR start "entryRuleArtifact" + // InternalRosParser.g:349:1: entryRuleArtifact returns [EObject current=null] : iv_ruleArtifact= ruleArtifact EOF ; + public final EObject entryRuleArtifact() throws RecognitionException { + EObject current = null; + + EObject iv_ruleArtifact = null; + + + try { + // InternalRosParser.g:349:49: (iv_ruleArtifact= ruleArtifact EOF ) + // InternalRosParser.g:350: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" + // InternalRosParser.g:356: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 { + // InternalRosParser.g:362:2: ( ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END ) ) + // InternalRosParser.g:363:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END ) + { + // InternalRosParser.g:363:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END ) + // InternalRosParser.g:364:3: () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END + { + // InternalRosParser.g:364:3: () + // InternalRosParser.g:365:4: + { - if (current==null) { - current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); - } - add( - current, - "artifact", - lv_artifact_18_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); - afterParserOrEnumRuleCall(); - + current = forceCreateModelElement( + grammarAccess.getArtifactAccess().getArtifactAction_0(), + current); + - } + } + // InternalRosParser.g:371:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRosParser.g:372:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRosParser.g:372:4: (lv_name_1_0= ruleRosNames ) + // InternalRosParser.g:373:5: lv_name_1_0= ruleRosNames + { - } + newCompositeNode(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); + + pushFollow(FOLLOW_4); + lv_name_1_0=ruleRosNames(); - // InternalRos.g:865:4: (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* - loop20: - do { - int alt20=2; - int LA20_0 = input.LA(1); + state._fsp--; - if ( (LA20_0==27) ) { - alt20=1; - } + if (current==null) { + current = createModelElementForParent(grammarAccess.getArtifactRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + - switch (alt20) { - case 1 : - // InternalRos.g:866:5: otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) - { - otherlv_19=(Token)match(input,27,FOLLOW_12); + } - newLeafNode(otherlv_19, grammarAccess.getCatkinPackageAccess().getCommaKeyword_7_1_0()); - - // InternalRos.g:870:5: ( (lv_artifact_20_0= ruleArtifact ) ) - // InternalRos.g:871:6: (lv_artifact_20_0= ruleArtifact ) - { - // InternalRos.g:871:6: (lv_artifact_20_0= ruleArtifact ) - // InternalRos.g:872:7: lv_artifact_20_0= ruleArtifact - { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); - - pushFollow(FOLLOW_5); - lv_artifact_20_0=ruleArtifact(); + } - state._fsp--; + otherlv_2=(Token)match(input,Colon,FOLLOW_5); + newLeafNode(otherlv_2, grammarAccess.getArtifactAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_15); - if (current==null) { - current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); - } - add( - current, - "artifact", - lv_artifact_20_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); - afterParserOrEnumRuleCall(); - + newLeafNode(this_BEGIN_3, grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); + + // InternalRosParser.g:398:3: ( (lv_node_4_0= ruleNode ) )? + int alt9=2; + int LA9_0 = input.LA(1); - } + if ( (LA9_0==Node_1) ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalRosParser.g:399:4: (lv_node_4_0= ruleNode ) + { + // InternalRosParser.g:399:4: (lv_node_4_0= ruleNode ) + // InternalRosParser.g:400:5: lv_node_4_0= ruleNode + { + newCompositeNode(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); + + pushFollow(FOLLOW_14); + lv_node_4_0=ruleNode(); - } + state._fsp--; - } - break; + if (current==null) { + current = createModelElementForParent(grammarAccess.getArtifactRule()); + } + set( + current, + "node", + lv_node_4_0, + "de.fraunhofer.ipa.ros.Ros.Node"); + afterParserOrEnumRuleCall(); + - default : - break loop20; - } - } while (true); + } } @@ -2370,9 +1112,9 @@ public final EObject ruleCatkinPackage() throws RecognitionException { } - otherlv_21=(Token)match(input,28,FOLLOW_2); + this_END_5=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_21, grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_8()); + newLeafNode(this_END_5, grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); } @@ -2393,28 +1135,28 @@ public final EObject ruleCatkinPackage() throws RecognitionException { } return current; } - // $ANTLR end "ruleCatkinPackage" + // $ANTLR end "ruleArtifact" - // $ANTLR start "entryRuleAmentPackage" - // InternalRos.g:899:1: entryRuleAmentPackage returns [EObject current=null] : iv_ruleAmentPackage= ruleAmentPackage EOF ; - public final EObject entryRuleAmentPackage() throws RecognitionException { + // $ANTLR start "entryRuleNode" + // InternalRosParser.g:425:1: entryRuleNode returns [EObject current=null] : iv_ruleNode= ruleNode EOF ; + public final EObject entryRuleNode() throws RecognitionException { EObject current = null; - EObject iv_ruleAmentPackage = null; + EObject iv_ruleNode = null; try { - // InternalRos.g:899:53: (iv_ruleAmentPackage= ruleAmentPackage EOF ) - // InternalRos.g:900:2: iv_ruleAmentPackage= ruleAmentPackage EOF + // InternalRosParser.g:425:45: (iv_ruleNode= ruleNode EOF ) + // InternalRosParser.g:426:2: iv_ruleNode= ruleNode EOF { - newCompositeNode(grammarAccess.getAmentPackageRule()); + newCompositeNode(grammarAccess.getNodeRule()); pushFollow(FOLLOW_1); - iv_ruleAmentPackage=ruleAmentPackage(); + iv_ruleNode=ruleNode(); state._fsp--; - current =iv_ruleAmentPackage; + current =iv_ruleNode; match(input,EOF,FOLLOW_2); } @@ -2429,91 +1171,91 @@ public final EObject entryRuleAmentPackage() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleAmentPackage" + // $ANTLR end "entryRuleNode" - // $ANTLR start "ruleAmentPackage" - // InternalRos.g:906:1: ruleAmentPackage returns [EObject current=null] : ( () otherlv_1= 'AmentPackage' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? otherlv_21= '}' ) ; - public final EObject ruleAmentPackage() throws RecognitionException { + // $ANTLR start "ruleNode" + // InternalRosParser.g:432: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END ) ; + public final EObject ruleNode() throws RecognitionException { EObject current = null; - Token otherlv_1=null; + Token otherlv_0=null; + Token this_BEGIN_2=null; Token otherlv_3=null; - Token otherlv_4=null; - Token otherlv_6=null; + Token this_BEGIN_4=null; + Token this_END_6=null; Token otherlv_7=null; - Token otherlv_9=null; + Token this_BEGIN_8=null; + Token this_END_10=null; Token otherlv_11=null; - Token otherlv_12=null; - Token otherlv_13=null; + Token this_BEGIN_12=null; + Token this_END_14=null; Token otherlv_15=null; - Token otherlv_17=null; + Token this_BEGIN_16=null; + Token this_END_18=null; Token otherlv_19=null; - Token otherlv_21=null; - AntlrDatatypeRuleToken lv_name_2_0 = null; + Token this_BEGIN_20=null; + Token this_END_22=null; + Token otherlv_23=null; + Token this_BEGIN_24=null; + Token this_END_26=null; + Token otherlv_27=null; + Token this_BEGIN_28=null; + Token this_END_30=null; + Token this_END_31=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; - AntlrDatatypeRuleToken lv_fromGitRepo_5_0 = null; + EObject lv_publisher_5_0 = null; - EObject lv_dependency_8_0 = null; + EObject lv_subscriber_9_0 = null; - EObject lv_dependency_10_0 = null; + EObject lv_serviceserver_13_0 = null; - EObject lv_spec_14_0 = null; + EObject lv_serviceclient_17_0 = null; - EObject lv_spec_16_0 = null; + EObject lv_actionserver_21_0 = null; - EObject lv_artifact_18_0 = null; + EObject lv_actionclient_25_0 = null; - EObject lv_artifact_20_0 = null; + EObject lv_parameter_29_0 = null; enterRule(); try { - // InternalRos.g:912:2: ( ( () otherlv_1= 'AmentPackage' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? otherlv_21= '}' ) ) - // InternalRos.g:913:2: ( () otherlv_1= 'AmentPackage' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? otherlv_21= '}' ) - { - // InternalRos.g:913:2: ( () otherlv_1= 'AmentPackage' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? otherlv_21= '}' ) - // InternalRos.g:914:3: () otherlv_1= 'AmentPackage' ( (lv_name_2_0= ruleRosNames ) ) otherlv_3= '{' (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? otherlv_21= '}' + // InternalRosParser.g:438: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END ) ) + // InternalRosParser.g:439: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END ) { - // InternalRos.g:914:3: () - // InternalRos.g:915:4: + // InternalRosParser.g:439: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END ) + // InternalRosParser.g:440: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END { + otherlv_0=(Token)match(input,Node_1,FOLLOW_16); - current = forceCreateModelElement( - grammarAccess.getAmentPackageAccess().getAmentPackageAction_0(), - current); - - - } - - otherlv_1=(Token)match(input,36,FOLLOW_13); - - newLeafNode(otherlv_1, grammarAccess.getAmentPackageAccess().getAmentPackageKeyword_1()); + newLeafNode(otherlv_0, grammarAccess.getNodeAccess().getNodeKeyword_0()); - // InternalRos.g:925:3: ( (lv_name_2_0= ruleRosNames ) ) - // InternalRos.g:926:4: (lv_name_2_0= ruleRosNames ) + // InternalRosParser.g:444:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRosParser.g:445:4: (lv_name_1_0= ruleRosNames ) { - // InternalRos.g:926:4: (lv_name_2_0= ruleRosNames ) - // InternalRos.g:927:5: lv_name_2_0= ruleRosNames + // InternalRosParser.g:445:4: (lv_name_1_0= ruleRosNames ) + // InternalRosParser.g:446:5: lv_name_1_0= ruleRosNames { - newCompositeNode(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_2_0()); + newCompositeNode(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); - pushFollow(FOLLOW_3); - lv_name_2_0=ruleRosNames(); + pushFollow(FOLLOW_5); + lv_name_1_0=ruleRosNames(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getAmentPackageRule()); + current = createModelElementForParent(grammarAccess.getNodeRule()); } set( current, "name", - lv_name_2_0, + lv_name_1_0, "de.fraunhofer.ipa.ros.Ros.RosNames"); afterParserOrEnumRuleCall(); @@ -2523,410 +1265,574 @@ public final EObject ruleAmentPackage() throws RecognitionException { } - otherlv_3=(Token)match(input,26,FOLLOW_16); + this_BEGIN_2=(Token)match(input,RULE_BEGIN,FOLLOW_17); - newLeafNode(otherlv_3, grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_3()); + newLeafNode(this_BEGIN_2, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); - // InternalRos.g:948:3: (otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) )? - int alt22=2; - int LA22_0 = input.LA(1); - - if ( (LA22_0==30) ) { - alt22=1; - } - switch (alt22) { - case 1 : - // InternalRos.g:949:4: otherlv_4= 'FromGitRepo' ( (lv_fromGitRepo_5_0= ruleEString ) ) + // InternalRosParser.g:467:3: ( (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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* + loop17: + do { + int alt17=8; + switch ( input.LA(1) ) { + case Publishers: { - otherlv_4=(Token)match(input,30,FOLLOW_7); - - newLeafNode(otherlv_4, grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); - - // InternalRos.g:953:4: ( (lv_fromGitRepo_5_0= ruleEString ) ) - // InternalRos.g:954:5: (lv_fromGitRepo_5_0= ruleEString ) + alt17=1; + } + break; + case Subscribers: { - // InternalRos.g:954:5: (lv_fromGitRepo_5_0= ruleEString ) - // InternalRos.g:955:6: lv_fromGitRepo_5_0= ruleEString + alt17=2; + } + break; + case Serviceserver: + { + alt17=3; + } + break; + case Serviceclient: + { + alt17=4; + } + break; + case Actionserver: { + alt17=5; + } + break; + case Actionclient: + { + alt17=6; + } + break; + case Parameters: + { + alt17=7; + } + break; - newCompositeNode(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); - - pushFollow(FOLLOW_17); - lv_fromGitRepo_5_0=ruleEString(); + } - state._fsp--; + switch (alt17) { + case 1 : + // InternalRosParser.g:468:4: (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END ) + { + // InternalRosParser.g:468:4: (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END ) + // InternalRosParser.g:469:5: 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_5); + newLeafNode(otherlv_3, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); + + this_BEGIN_4=(Token)match(input,RULE_BEGIN,FOLLOW_18); - if (current==null) { - current = createModelElementForParent(grammarAccess.getAmentPackageRule()); - } - set( - current, - "fromGitRepo", - lv_fromGitRepo_5_0, - "de.fraunhofer.ipa.ros.Ros.EString"); - afterParserOrEnumRuleCall(); - + newLeafNode(this_BEGIN_4, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); + + // InternalRosParser.g:477:5: ( (lv_publisher_5_0= rulePublisher ) )* + loop10: + do { + int alt10=2; + int LA10_0 = input.LA(1); - } + if ( (LA10_0==RULE_ID||LA10_0==RULE_STRING) ) { + alt10=1; + } - } + switch (alt10) { + case 1 : + // InternalRosParser.g:478:6: (lv_publisher_5_0= rulePublisher ) + { + // InternalRosParser.g:478:6: (lv_publisher_5_0= rulePublisher ) + // InternalRosParser.g:479:7: lv_publisher_5_0= rulePublisher + { + newCompositeNode(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); + + pushFollow(FOLLOW_18); + lv_publisher_5_0=rulePublisher(); - } - break; + state._fsp--; - } - // InternalRos.g:973:3: (otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' )? - int alt24=2; - int LA24_0 = input.LA(1); + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "publisher", + lv_publisher_5_0, + "de.fraunhofer.ipa.ros.Ros.Publisher"); + afterParserOrEnumRuleCall(); + - if ( (LA24_0==35) ) { - alt24=1; - } - switch (alt24) { - case 1 : - // InternalRos.g:974:4: otherlv_6= 'Dependencies' otherlv_7= '{' ( (lv_dependency_8_0= ruleDependency ) ) (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* otherlv_11= '}' - { - otherlv_6=(Token)match(input,35,FOLLOW_3); + } - newLeafNode(otherlv_6, grammarAccess.getAmentPackageAccess().getDependenciesKeyword_5_0()); - - otherlv_7=(Token)match(input,26,FOLLOW_18); - newLeafNode(otherlv_7, grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_5_1()); - - // InternalRos.g:982:4: ( (lv_dependency_8_0= ruleDependency ) ) - // InternalRos.g:983:5: (lv_dependency_8_0= ruleDependency ) - { - // InternalRos.g:983:5: (lv_dependency_8_0= ruleDependency ) - // InternalRos.g:984:6: lv_dependency_8_0= ruleDependency - { + } + break; - newCompositeNode(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); - - pushFollow(FOLLOW_5); - lv_dependency_8_0=ruleDependency(); + default : + break loop10; + } + } while (true); - state._fsp--; + this_END_6=(Token)match(input,RULE_END,FOLLOW_17); + newLeafNode(this_END_6, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); + - if (current==null) { - current = createModelElementForParent(grammarAccess.getAmentPackageRule()); - } - add( - current, - "dependency", - lv_dependency_8_0, - "de.fraunhofer.ipa.ros.Ros.Dependency"); - afterParserOrEnumRuleCall(); - + } - } + } + break; + case 2 : + // InternalRosParser.g:502:4: (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END ) + { + // InternalRosParser.g:502:4: (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END ) + // InternalRosParser.g:503:5: 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_5); + + newLeafNode(otherlv_7, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); + + this_BEGIN_8=(Token)match(input,RULE_BEGIN,FOLLOW_18); - } + newLeafNode(this_BEGIN_8, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); + + // InternalRosParser.g:511:5: ( (lv_subscriber_9_0= ruleSubscriber ) )* + loop11: + do { + int alt11=2; + int LA11_0 = input.LA(1); - // InternalRos.g:1001:4: (otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) )* - loop23: - do { - int alt23=2; - int LA23_0 = input.LA(1); + if ( (LA11_0==RULE_ID||LA11_0==RULE_STRING) ) { + alt11=1; + } - if ( (LA23_0==27) ) { - alt23=1; - } + switch (alt11) { + case 1 : + // InternalRosParser.g:512:6: (lv_subscriber_9_0= ruleSubscriber ) + { + // InternalRosParser.g:512:6: (lv_subscriber_9_0= ruleSubscriber ) + // InternalRosParser.g:513:7: lv_subscriber_9_0= ruleSubscriber + { - switch (alt23) { - case 1 : - // InternalRos.g:1002:5: otherlv_9= ',' ( (lv_dependency_10_0= ruleDependency ) ) - { - otherlv_9=(Token)match(input,27,FOLLOW_18); + newCompositeNode(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); + + pushFollow(FOLLOW_18); + lv_subscriber_9_0=ruleSubscriber(); - newLeafNode(otherlv_9, grammarAccess.getAmentPackageAccess().getCommaKeyword_5_3_0()); - - // InternalRos.g:1006:5: ( (lv_dependency_10_0= ruleDependency ) ) - // InternalRos.g:1007:6: (lv_dependency_10_0= ruleDependency ) - { - // InternalRos.g:1007:6: (lv_dependency_10_0= ruleDependency ) - // InternalRos.g:1008:7: lv_dependency_10_0= ruleDependency - { + state._fsp--; - newCompositeNode(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); - - pushFollow(FOLLOW_5); - lv_dependency_10_0=ruleDependency(); - state._fsp--; + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "subscriber", + lv_subscriber_9_0, + "de.fraunhofer.ipa.ros.Ros.Subscriber"); + afterParserOrEnumRuleCall(); + + } - if (current==null) { - current = createModelElementForParent(grammarAccess.getAmentPackageRule()); - } - add( - current, - "dependency", - lv_dependency_10_0, - "de.fraunhofer.ipa.ros.Ros.Dependency"); - afterParserOrEnumRuleCall(); - - } + } + break; + default : + break loop11; + } + } while (true); - } + this_END_10=(Token)match(input,RULE_END,FOLLOW_17); + newLeafNode(this_END_10, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); + - } - break; + } + + + } + break; + case 3 : + // InternalRosParser.g:536:4: (otherlv_11= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) + { + // InternalRosParser.g:536:4: (otherlv_11= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) + // InternalRosParser.g:537:5: otherlv_11= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END + { + otherlv_11=(Token)match(input,Serviceserver,FOLLOW_5); + + newLeafNode(otherlv_11, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); + + this_BEGIN_12=(Token)match(input,RULE_BEGIN,FOLLOW_18); + + newLeafNode(this_BEGIN_12, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); + + // InternalRosParser.g:545:5: ( (lv_serviceserver_13_0= ruleServiceServer ) )* + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0==RULE_ID||LA12_0==RULE_STRING) ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalRosParser.g:546:6: (lv_serviceserver_13_0= ruleServiceServer ) + { + // InternalRosParser.g:546:6: (lv_serviceserver_13_0= ruleServiceServer ) + // InternalRosParser.g:547:7: lv_serviceserver_13_0= ruleServiceServer + { + + newCompositeNode(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); + + pushFollow(FOLLOW_18); + lv_serviceserver_13_0=ruleServiceServer(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "serviceserver", + lv_serviceserver_13_0, + "de.fraunhofer.ipa.ros.Ros.ServiceServer"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop12; + } + } while (true); + + this_END_14=(Token)match(input,RULE_END,FOLLOW_17); + + newLeafNode(this_END_14, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); + + + } + + + } + break; + case 4 : + // InternalRosParser.g:570:4: (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) + { + // InternalRosParser.g:570:4: (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) + // InternalRosParser.g:571:5: otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END + { + otherlv_15=(Token)match(input,Serviceclient,FOLLOW_5); + + newLeafNode(otherlv_15, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); + + this_BEGIN_16=(Token)match(input,RULE_BEGIN,FOLLOW_18); + + newLeafNode(this_BEGIN_16, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); + + // InternalRosParser.g:579:5: ( (lv_serviceclient_17_0= ruleServiceClient ) )* + 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 : + // InternalRosParser.g:580:6: (lv_serviceclient_17_0= ruleServiceClient ) + { + // InternalRosParser.g:580:6: (lv_serviceclient_17_0= ruleServiceClient ) + // InternalRosParser.g:581:7: lv_serviceclient_17_0= ruleServiceClient + { + + newCompositeNode(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); + + pushFollow(FOLLOW_18); + lv_serviceclient_17_0=ruleServiceClient(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "serviceclient", + lv_serviceclient_17_0, + "de.fraunhofer.ipa.ros.Ros.ServiceClient"); + afterParserOrEnumRuleCall(); + + + } - default : - break loop23; - } - } while (true); - otherlv_11=(Token)match(input,28,FOLLOW_9); + } + break; - newLeafNode(otherlv_11, grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_5_4()); - + default : + break loop13; + } + } while (true); - } - break; + this_END_18=(Token)match(input,RULE_END,FOLLOW_17); - } + newLeafNode(this_END_18, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); + - // InternalRos.g:1031:3: (otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' )? - int alt26=2; - int LA26_0 = input.LA(1); + } - if ( (LA26_0==31) ) { - alt26=1; - } - switch (alt26) { - case 1 : - // InternalRos.g:1032:4: otherlv_12= 'Specs' otherlv_13= '{' ( (lv_spec_14_0= ruleSpecBase ) ) (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* otherlv_17= '}' - { - otherlv_12=(Token)match(input,31,FOLLOW_3); - newLeafNode(otherlv_12, grammarAccess.getAmentPackageAccess().getSpecsKeyword_6_0()); - - otherlv_13=(Token)match(input,26,FOLLOW_10); + } + break; + case 5 : + // InternalRosParser.g:604:4: (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) + { + // InternalRosParser.g:604:4: (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) + // InternalRosParser.g:605:5: otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END + { + otherlv_19=(Token)match(input,Actionserver,FOLLOW_5); - newLeafNode(otherlv_13, grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_6_1()); - - // InternalRos.g:1040:4: ( (lv_spec_14_0= ruleSpecBase ) ) - // InternalRos.g:1041:5: (lv_spec_14_0= ruleSpecBase ) - { - // InternalRos.g:1041:5: (lv_spec_14_0= ruleSpecBase ) - // InternalRos.g:1042:6: lv_spec_14_0= ruleSpecBase - { + newLeafNode(otherlv_19, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); + + this_BEGIN_20=(Token)match(input,RULE_BEGIN,FOLLOW_18); - newCompositeNode(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); - - pushFollow(FOLLOW_5); - lv_spec_14_0=ruleSpecBase(); + newLeafNode(this_BEGIN_20, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); + + // InternalRosParser.g:613:5: ( (lv_actionserver_21_0= ruleActionServer ) )* + loop14: + do { + int alt14=2; + int LA14_0 = input.LA(1); - state._fsp--; + if ( (LA14_0==RULE_ID||LA14_0==RULE_STRING) ) { + alt14=1; + } - if (current==null) { - current = createModelElementForParent(grammarAccess.getAmentPackageRule()); - } - add( - current, - "spec", - lv_spec_14_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); - afterParserOrEnumRuleCall(); - + switch (alt14) { + case 1 : + // InternalRosParser.g:614:6: (lv_actionserver_21_0= ruleActionServer ) + { + // InternalRosParser.g:614:6: (lv_actionserver_21_0= ruleActionServer ) + // InternalRosParser.g:615:7: lv_actionserver_21_0= ruleActionServer + { - } + newCompositeNode(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); + + pushFollow(FOLLOW_18); + lv_actionserver_21_0=ruleActionServer(); + state._fsp--; - } - // InternalRos.g:1059:4: (otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) )* - loop25: - do { - int alt25=2; - int LA25_0 = input.LA(1); + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "actionserver", + lv_actionserver_21_0, + "de.fraunhofer.ipa.ros.Ros.ActionServer"); + afterParserOrEnumRuleCall(); + - if ( (LA25_0==27) ) { - alt25=1; - } + } - switch (alt25) { - case 1 : - // InternalRos.g:1060:5: otherlv_15= ',' ( (lv_spec_16_0= ruleSpecBase ) ) - { - otherlv_15=(Token)match(input,27,FOLLOW_10); + } + break; - newLeafNode(otherlv_15, grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); - - // InternalRos.g:1064:5: ( (lv_spec_16_0= ruleSpecBase ) ) - // InternalRos.g:1065:6: (lv_spec_16_0= ruleSpecBase ) - { - // InternalRos.g:1065:6: (lv_spec_16_0= ruleSpecBase ) - // InternalRos.g:1066:7: lv_spec_16_0= ruleSpecBase - { + default : + break loop14; + } + } while (true); - newCompositeNode(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); - - pushFollow(FOLLOW_5); - lv_spec_16_0=ruleSpecBase(); + this_END_22=(Token)match(input,RULE_END,FOLLOW_17); - state._fsp--; + newLeafNode(this_END_22, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); + + } - if (current==null) { - current = createModelElementForParent(grammarAccess.getAmentPackageRule()); - } - add( - current, - "spec", - lv_spec_16_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); - afterParserOrEnumRuleCall(); - - } + } + break; + case 6 : + // InternalRosParser.g:638:4: (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) + { + // InternalRosParser.g:638:4: (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) + // InternalRosParser.g:639:5: otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END + { + otherlv_23=(Token)match(input,Actionclient,FOLLOW_5); + newLeafNode(otherlv_23, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); + + this_BEGIN_24=(Token)match(input,RULE_BEGIN,FOLLOW_18); - } + newLeafNode(this_BEGIN_24, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); + + // InternalRosParser.g:647:5: ( (lv_actionclient_25_0= ruleActionClient ) )* + loop15: + do { + int alt15=2; + int LA15_0 = input.LA(1); + if ( (LA15_0==RULE_ID||LA15_0==RULE_STRING) ) { + alt15=1; + } - } - break; - default : - break loop25; - } - } while (true); + switch (alt15) { + case 1 : + // InternalRosParser.g:648:6: (lv_actionclient_25_0= ruleActionClient ) + { + // InternalRosParser.g:648:6: (lv_actionclient_25_0= ruleActionClient ) + // InternalRosParser.g:649:7: lv_actionclient_25_0= ruleActionClient + { - otherlv_17=(Token)match(input,28,FOLLOW_11); + newCompositeNode(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); + + pushFollow(FOLLOW_18); + lv_actionclient_25_0=ruleActionClient(); - newLeafNode(otherlv_17, grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_6_4()); - + state._fsp--; - } - break; - } + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "actionclient", + lv_actionclient_25_0, + "de.fraunhofer.ipa.ros.Ros.ActionClient"); + afterParserOrEnumRuleCall(); + - // InternalRos.g:1089:3: ( ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* )? - int alt28=2; - int LA28_0 = input.LA(1); + } - if ( (LA28_0==33) ) { - alt28=1; - } - switch (alt28) { - case 1 : - // InternalRos.g:1090:4: ( (lv_artifact_18_0= ruleArtifact ) ) (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* - { - // InternalRos.g:1090:4: ( (lv_artifact_18_0= ruleArtifact ) ) - // InternalRos.g:1091:5: (lv_artifact_18_0= ruleArtifact ) - { - // InternalRos.g:1091:5: (lv_artifact_18_0= ruleArtifact ) - // InternalRos.g:1092:6: lv_artifact_18_0= ruleArtifact - { - newCompositeNode(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); - - pushFollow(FOLLOW_5); - lv_artifact_18_0=ruleArtifact(); + } + break; - state._fsp--; + default : + break loop15; + } + } while (true); + this_END_26=(Token)match(input,RULE_END,FOLLOW_17); - if (current==null) { - current = createModelElementForParent(grammarAccess.getAmentPackageRule()); - } - add( - current, - "artifact", - lv_artifact_18_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); - afterParserOrEnumRuleCall(); - + newLeafNode(this_END_26, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); + - } + } - } + } + break; + case 7 : + // InternalRosParser.g:672:4: (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) + { + // InternalRosParser.g:672:4: (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) + // InternalRosParser.g:673:5: otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END + { + otherlv_27=(Token)match(input,Parameters,FOLLOW_5); - // InternalRos.g:1109:4: (otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) )* - loop27: - do { - int alt27=2; - int LA27_0 = input.LA(1); + newLeafNode(otherlv_27, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); + + this_BEGIN_28=(Token)match(input,RULE_BEGIN,FOLLOW_18); - if ( (LA27_0==27) ) { - alt27=1; - } + newLeafNode(this_BEGIN_28, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); + + // InternalRosParser.g:681:5: ( (lv_parameter_29_0= ruleParameter ) )* + loop16: + do { + int alt16=2; + int LA16_0 = input.LA(1); + if ( (LA16_0==RULE_ID||LA16_0==RULE_STRING) ) { + alt16=1; + } - switch (alt27) { - case 1 : - // InternalRos.g:1110:5: otherlv_19= ',' ( (lv_artifact_20_0= ruleArtifact ) ) - { - otherlv_19=(Token)match(input,27,FOLLOW_12); - newLeafNode(otherlv_19, grammarAccess.getAmentPackageAccess().getCommaKeyword_7_1_0()); - - // InternalRos.g:1114:5: ( (lv_artifact_20_0= ruleArtifact ) ) - // InternalRos.g:1115:6: (lv_artifact_20_0= ruleArtifact ) - { - // InternalRos.g:1115:6: (lv_artifact_20_0= ruleArtifact ) - // InternalRos.g:1116:7: lv_artifact_20_0= ruleArtifact - { + switch (alt16) { + case 1 : + // InternalRosParser.g:682:6: (lv_parameter_29_0= ruleParameter ) + { + // InternalRosParser.g:682:6: (lv_parameter_29_0= ruleParameter ) + // InternalRosParser.g:683:7: lv_parameter_29_0= ruleParameter + { - newCompositeNode(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); - - pushFollow(FOLLOW_5); - lv_artifact_20_0=ruleArtifact(); + newCompositeNode(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); + + pushFollow(FOLLOW_18); + lv_parameter_29_0=ruleParameter(); - state._fsp--; + state._fsp--; - if (current==null) { - current = createModelElementForParent(grammarAccess.getAmentPackageRule()); - } - add( - current, - "artifact", - lv_artifact_20_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); - afterParserOrEnumRuleCall(); - + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "parameter", + lv_parameter_29_0, + "de.fraunhofer.ipa.ros.Ros.Parameter"); + afterParserOrEnumRuleCall(); + - } + } - } + } + break; + default : + break loop16; + } + } while (true); - } - break; + this_END_30=(Token)match(input,RULE_END,FOLLOW_17); - default : - break loop27; - } - } while (true); + newLeafNode(this_END_30, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); + + } - } - break; - } + } + break; + + default : + break loop17; + } + } while (true); - otherlv_21=(Token)match(input,28,FOLLOW_2); + this_END_31=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_21, grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_8()); + newLeafNode(this_END_31, grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); } @@ -2947,28 +1853,28 @@ public final EObject ruleAmentPackage() throws RecognitionException { } return current; } - // $ANTLR end "ruleAmentPackage" + // $ANTLR end "ruleNode" - // $ANTLR start "entryRuleServiceSpec" - // InternalRos.g:1143:1: entryRuleServiceSpec returns [EObject current=null] : iv_ruleServiceSpec= ruleServiceSpec EOF ; - public final EObject entryRuleServiceSpec() throws RecognitionException { + // $ANTLR start "entryRuleSpecBase" + // InternalRosParser.g:714:1: entryRuleSpecBase returns [EObject current=null] : iv_ruleSpecBase= ruleSpecBase EOF ; + public final EObject entryRuleSpecBase() throws RecognitionException { EObject current = null; - EObject iv_ruleServiceSpec = null; + EObject iv_ruleSpecBase = null; try { - // InternalRos.g:1143:52: (iv_ruleServiceSpec= ruleServiceSpec EOF ) - // InternalRos.g:1144:2: iv_ruleServiceSpec= ruleServiceSpec EOF + // InternalRosParser.g:714:49: (iv_ruleSpecBase= ruleSpecBase EOF ) + // InternalRosParser.g:715:2: iv_ruleSpecBase= ruleSpecBase EOF { - newCompositeNode(grammarAccess.getServiceSpecRule()); + newCompositeNode(grammarAccess.getSpecBaseRule()); pushFollow(FOLLOW_1); - iv_ruleServiceSpec=ruleServiceSpec(); + iv_ruleSpecBase=ruleSpecBase(); state._fsp--; - current =iv_ruleServiceSpec; + current =iv_ruleSpecBase; match(input,EOF,FOLLOW_2); } @@ -2983,194 +1889,108 @@ public final EObject entryRuleServiceSpec() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleServiceSpec" + // $ANTLR end "entryRuleSpecBase" - // $ANTLR start "ruleServiceSpec" - // InternalRos.g:1150:1: ruleServiceSpec returns [EObject current=null] : ( () otherlv_1= 'ServiceSpec' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'request' ( (lv_request_5_0= ruleMessageDefinition ) ) )? (otherlv_6= 'response' ( (lv_response_7_0= ruleMessageDefinition ) ) )? otherlv_8= '}' ) ; - public final EObject ruleServiceSpec() throws RecognitionException { + // $ANTLR start "ruleSpecBase" + // InternalRosParser.g:721:1: ruleSpecBase returns [EObject current=null] : (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) ; + public final EObject ruleSpecBase() throws RecognitionException { EObject current = null; - Token otherlv_1=null; - Token otherlv_3=null; - Token otherlv_4=null; - Token otherlv_6=null; - Token otherlv_8=null; - AntlrDatatypeRuleToken lv_name_2_0 = null; + EObject this_TopicSpec_0 = null; - EObject lv_request_5_0 = null; + EObject this_ServiceSpec_1 = null; - EObject lv_response_7_0 = null; + EObject this_ActionSpec_2 = null; enterRule(); try { - // InternalRos.g:1156:2: ( ( () otherlv_1= 'ServiceSpec' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'request' ( (lv_request_5_0= ruleMessageDefinition ) ) )? (otherlv_6= 'response' ( (lv_response_7_0= ruleMessageDefinition ) ) )? otherlv_8= '}' ) ) - // InternalRos.g:1157:2: ( () otherlv_1= 'ServiceSpec' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'request' ( (lv_request_5_0= ruleMessageDefinition ) ) )? (otherlv_6= 'response' ( (lv_response_7_0= ruleMessageDefinition ) ) )? otherlv_8= '}' ) + // InternalRosParser.g:727:2: ( (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) ) + // InternalRosParser.g:728:2: (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) { - // InternalRos.g:1157:2: ( () otherlv_1= 'ServiceSpec' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'request' ( (lv_request_5_0= ruleMessageDefinition ) ) )? (otherlv_6= 'response' ( (lv_response_7_0= ruleMessageDefinition ) ) )? otherlv_8= '}' ) - // InternalRos.g:1158:3: () otherlv_1= 'ServiceSpec' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'request' ( (lv_request_5_0= ruleMessageDefinition ) ) )? (otherlv_6= 'response' ( (lv_response_7_0= ruleMessageDefinition ) ) )? otherlv_8= '}' - { - // InternalRos.g:1158:3: () - // InternalRos.g:1159:4: - { - - current = forceCreateModelElement( - grammarAccess.getServiceSpecAccess().getServiceSpecAction_0(), - current); - - - } - - otherlv_1=(Token)match(input,37,FOLLOW_7); - - newLeafNode(otherlv_1, grammarAccess.getServiceSpecAccess().getServiceSpecKeyword_1()); - - // InternalRos.g:1169:3: ( (lv_name_2_0= ruleEString ) ) - // InternalRos.g:1170:4: (lv_name_2_0= ruleEString ) - { - // InternalRos.g:1170:4: (lv_name_2_0= ruleEString ) - // InternalRos.g:1171:5: lv_name_2_0= ruleEString - { - - newCompositeNode(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); - - pushFollow(FOLLOW_3); - lv_name_2_0=ruleEString(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getServiceSpecRule()); - } - set( - current, - "name", - lv_name_2_0, - "de.fraunhofer.ipa.ros.Ros.EString"); - afterParserOrEnumRuleCall(); - - - } - + // InternalRosParser.g:728:2: (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) + int alt18=3; + switch ( input.LA(1) ) { + case Msg: + { + alt18=1; + } + break; + case Srv: + { + alt18=2; + } + break; + case Action_1: + { + alt18=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + throw nvae; } - otherlv_3=(Token)match(input,26,FOLLOW_19); - - newLeafNode(otherlv_3, grammarAccess.getServiceSpecAccess().getLeftCurlyBracketKeyword_3()); - - // InternalRos.g:1192:3: (otherlv_4= 'request' ( (lv_request_5_0= ruleMessageDefinition ) ) )? - int alt29=2; - int LA29_0 = input.LA(1); - - if ( (LA29_0==38) ) { - alt29=1; - } - switch (alt29) { + switch (alt18) { case 1 : - // InternalRos.g:1193:4: otherlv_4= 'request' ( (lv_request_5_0= ruleMessageDefinition ) ) + // InternalRosParser.g:729:3: this_TopicSpec_0= ruleTopicSpec { - otherlv_4=(Token)match(input,38,FOLLOW_3); - newLeafNode(otherlv_4, grammarAccess.getServiceSpecAccess().getRequestKeyword_4_0()); - - // InternalRos.g:1197:4: ( (lv_request_5_0= ruleMessageDefinition ) ) - // InternalRos.g:1198:5: (lv_request_5_0= ruleMessageDefinition ) - { - // InternalRos.g:1198:5: (lv_request_5_0= ruleMessageDefinition ) - // InternalRos.g:1199:6: lv_request_5_0= ruleMessageDefinition - { - - newCompositeNode(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_4_1_0()); - - pushFollow(FOLLOW_20); - lv_request_5_0=ruleMessageDefinition(); + newCompositeNode(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_TopicSpec_0=ruleTopicSpec(); state._fsp--; - if (current==null) { - current = createModelElementForParent(grammarAccess.getServiceSpecRule()); - } - set( - current, - "request", - lv_request_5_0, - "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); - afterParserOrEnumRuleCall(); - - - } - - - } - + current = this_TopicSpec_0; + afterParserOrEnumRuleCall(); + } break; - - } - - // InternalRos.g:1217:3: (otherlv_6= 'response' ( (lv_response_7_0= ruleMessageDefinition ) ) )? - int alt30=2; - int LA30_0 = input.LA(1); - - if ( (LA30_0==39) ) { - alt30=1; - } - switch (alt30) { - case 1 : - // InternalRos.g:1218:4: otherlv_6= 'response' ( (lv_response_7_0= ruleMessageDefinition ) ) - { - otherlv_6=(Token)match(input,39,FOLLOW_3); - - newLeafNode(otherlv_6, grammarAccess.getServiceSpecAccess().getResponseKeyword_5_0()); - - // InternalRos.g:1222:4: ( (lv_response_7_0= ruleMessageDefinition ) ) - // InternalRos.g:1223:5: (lv_response_7_0= ruleMessageDefinition ) - { - // InternalRos.g:1223:5: (lv_response_7_0= ruleMessageDefinition ) - // InternalRos.g:1224:6: lv_response_7_0= ruleMessageDefinition + case 2 : + // InternalRosParser.g:738:3: this_ServiceSpec_1= ruleServiceSpec { - newCompositeNode(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_5_1_0()); - - pushFollow(FOLLOW_15); - lv_response_7_0=ruleMessageDefinition(); + newCompositeNode(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_ServiceSpec_1=ruleServiceSpec(); state._fsp--; - if (current==null) { - current = createModelElementForParent(grammarAccess.getServiceSpecRule()); - } - set( - current, - "response", - lv_response_7_0, - "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); - afterParserOrEnumRuleCall(); - - - } - + current = this_ServiceSpec_1; + afterParserOrEnumRuleCall(); + } + break; + case 3 : + // InternalRosParser.g:747:3: this_ActionSpec_2= ruleActionSpec + { + newCompositeNode(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_ActionSpec_2=ruleActionSpec(); - } - break; + state._fsp--; - } - otherlv_8=(Token)match(input,28,FOLLOW_2); + current = this_ActionSpec_2; + afterParserOrEnumRuleCall(); + - newLeafNode(otherlv_8, grammarAccess.getServiceSpecAccess().getRightCurlyBracketKeyword_6()); - + } + break; } @@ -3190,11 +2010,11 @@ public final EObject ruleServiceSpec() throws RecognitionException { } return current; } - // $ANTLR end "ruleServiceSpec" + // $ANTLR end "ruleSpecBase" // $ANTLR start "entryRuleTopicSpec" - // InternalRos.g:1250:1: entryRuleTopicSpec returns [EObject current=null] : iv_ruleTopicSpec= ruleTopicSpec EOF ; + // InternalRosParser.g:759:1: entryRuleTopicSpec returns [EObject current=null] : iv_ruleTopicSpec= ruleTopicSpec EOF ; public final EObject entryRuleTopicSpec() throws RecognitionException { EObject current = null; @@ -3202,8 +2022,8 @@ public final EObject entryRuleTopicSpec() throws RecognitionException { try { - // InternalRos.g:1250:50: (iv_ruleTopicSpec= ruleTopicSpec EOF ) - // InternalRos.g:1251:2: iv_ruleTopicSpec= ruleTopicSpec EOF + // InternalRosParser.g:759:50: (iv_ruleTopicSpec= ruleTopicSpec EOF ) + // InternalRosParser.g:760:2: iv_ruleTopicSpec= ruleTopicSpec EOF { newCompositeNode(grammarAccess.getTopicSpecRule()); pushFollow(FOLLOW_1); @@ -3230,33 +2050,35 @@ public final EObject entryRuleTopicSpec() throws RecognitionException { // $ANTLR start "ruleTopicSpec" - // InternalRos.g:1257:1: ruleTopicSpec returns [EObject current=null] : ( () otherlv_1= 'TopicSpec' ( ( (lv_name_2_1= ruleEString | lv_name_2_2= 'Header' | lv_name_2_3= 'String' ) ) ) otherlv_3= '{' (otherlv_4= 'message' ( (lv_message_5_0= ruleMessageDefinition ) ) )? otherlv_6= '}' ) ; + // InternalRosParser.g:766:1: ruleTopicSpec returns [EObject current=null] : ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) ; public final EObject ruleTopicSpec() throws RecognitionException { EObject current = null; Token otherlv_1=null; Token lv_name_2_2=null; Token lv_name_2_3=null; - Token otherlv_3=null; + Token this_BEGIN_3=null; Token otherlv_4=null; - Token otherlv_6=null; + Token this_BEGIN_5=null; + Token this_END_7=null; + Token this_END_8=null; AntlrDatatypeRuleToken lv_name_2_1 = null; - EObject lv_message_5_0 = null; + EObject lv_message_6_0 = null; enterRule(); try { - // InternalRos.g:1263:2: ( ( () otherlv_1= 'TopicSpec' ( ( (lv_name_2_1= ruleEString | lv_name_2_2= 'Header' | lv_name_2_3= 'String' ) ) ) otherlv_3= '{' (otherlv_4= 'message' ( (lv_message_5_0= ruleMessageDefinition ) ) )? otherlv_6= '}' ) ) - // InternalRos.g:1264:2: ( () otherlv_1= 'TopicSpec' ( ( (lv_name_2_1= ruleEString | lv_name_2_2= 'Header' | lv_name_2_3= 'String' ) ) ) otherlv_3= '{' (otherlv_4= 'message' ( (lv_message_5_0= ruleMessageDefinition ) ) )? otherlv_6= '}' ) + // InternalRosParser.g:772:2: ( ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) ) + // InternalRosParser.g:773:2: ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) { - // InternalRos.g:1264:2: ( () otherlv_1= 'TopicSpec' ( ( (lv_name_2_1= ruleEString | lv_name_2_2= 'Header' | lv_name_2_3= 'String' ) ) ) otherlv_3= '{' (otherlv_4= 'message' ( (lv_message_5_0= ruleMessageDefinition ) ) )? otherlv_6= '}' ) - // InternalRos.g:1265:3: () otherlv_1= 'TopicSpec' ( ( (lv_name_2_1= ruleEString | lv_name_2_2= 'Header' | lv_name_2_3= 'String' ) ) ) otherlv_3= '{' (otherlv_4= 'message' ( (lv_message_5_0= ruleMessageDefinition ) ) )? otherlv_6= '}' + // InternalRosParser.g:773:2: ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) + // InternalRosParser.g:774:3: () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END { - // InternalRos.g:1265:3: () - // InternalRos.g:1266:4: + // InternalRosParser.g:774:3: () + // InternalRosParser.g:775:4: { current = forceCreateModelElement( @@ -3266,50 +2088,50 @@ public final EObject ruleTopicSpec() throws RecognitionException { } - otherlv_1=(Token)match(input,40,FOLLOW_21); + otherlv_1=(Token)match(input,Msg,FOLLOW_19); - newLeafNode(otherlv_1, grammarAccess.getTopicSpecAccess().getTopicSpecKeyword_1()); + newLeafNode(otherlv_1, grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); - // InternalRos.g:1276:3: ( ( (lv_name_2_1= ruleEString | lv_name_2_2= 'Header' | lv_name_2_3= 'String' ) ) ) - // InternalRos.g:1277:4: ( (lv_name_2_1= ruleEString | lv_name_2_2= 'Header' | lv_name_2_3= 'String' ) ) + // InternalRosParser.g:785:3: ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) + // InternalRosParser.g:786:4: ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) { - // InternalRos.g:1277:4: ( (lv_name_2_1= ruleEString | lv_name_2_2= 'Header' | lv_name_2_3= 'String' ) ) - // InternalRos.g:1278:5: (lv_name_2_1= ruleEString | lv_name_2_2= 'Header' | lv_name_2_3= 'String' ) + // InternalRosParser.g:786:4: ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) + // InternalRosParser.g:787:5: (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) { - // InternalRos.g:1278:5: (lv_name_2_1= ruleEString | lv_name_2_2= 'Header' | lv_name_2_3= 'String' ) - int alt31=3; + // InternalRosParser.g:787:5: (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) + int alt19=3; switch ( input.LA(1) ) { - case RULE_STRING: case RULE_ID: + case RULE_STRING: { - alt31=1; + alt19=1; } break; - case 41: + case Header: { - alt31=2; + alt19=2; } break; - case 42: + case String: { - alt31=3; + alt19=3; } break; default: NoViableAltException nvae = - new NoViableAltException("", 31, 0, input); + new NoViableAltException("", 19, 0, input); throw nvae; } - switch (alt31) { + switch (alt19) { case 1 : - // InternalRos.g:1279:6: lv_name_2_1= ruleEString + // InternalRosParser.g:788:6: lv_name_2_1= ruleEString { newCompositeNode(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); - pushFollow(FOLLOW_3); + pushFollow(FOLLOW_5); lv_name_2_1=ruleEString(); state._fsp--; @@ -3329,9 +2151,9 @@ public final EObject ruleTopicSpec() throws RecognitionException { } break; case 2 : - // InternalRos.g:1295:6: lv_name_2_2= 'Header' + // InternalRosParser.g:804:6: lv_name_2_2= Header { - lv_name_2_2=(Token)match(input,41,FOLLOW_3); + lv_name_2_2=(Token)match(input,Header,FOLLOW_5); newLeafNode(lv_name_2_2, grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); @@ -3345,9 +2167,9 @@ public final EObject ruleTopicSpec() throws RecognitionException { } break; case 3 : - // InternalRos.g:1306:6: lv_name_2_3= 'String' + // InternalRosParser.g:815:6: lv_name_2_3= String { - lv_name_2_3=(Token)match(input,42,FOLLOW_3); + lv_name_2_3=(Token)match(input,String,FOLLOW_5); newLeafNode(lv_name_2_3, grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); @@ -3369,36 +2191,40 @@ public final EObject ruleTopicSpec() throws RecognitionException { } - otherlv_3=(Token)match(input,26,FOLLOW_22); + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_20); - newLeafNode(otherlv_3, grammarAccess.getTopicSpecAccess().getLeftCurlyBracketKeyword_3()); + newLeafNode(this_BEGIN_3, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); - // InternalRos.g:1323:3: (otherlv_4= 'message' ( (lv_message_5_0= ruleMessageDefinition ) ) )? - int alt32=2; - int LA32_0 = input.LA(1); + otherlv_4=(Token)match(input,Message_1,FOLLOW_21); - if ( (LA32_0==43) ) { - alt32=1; + newLeafNode(otherlv_4, grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); + + // InternalRosParser.g:836:3: (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0==RULE_BEGIN) ) { + alt20=1; } - switch (alt32) { + switch (alt20) { case 1 : - // InternalRos.g:1324:4: otherlv_4= 'message' ( (lv_message_5_0= ruleMessageDefinition ) ) + // InternalRosParser.g:837:4: this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END { - otherlv_4=(Token)match(input,43,FOLLOW_3); + this_BEGIN_5=(Token)match(input,RULE_BEGIN,FOLLOW_22); - newLeafNode(otherlv_4, grammarAccess.getTopicSpecAccess().getMessageKeyword_4_0()); + newLeafNode(this_BEGIN_5, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); - // InternalRos.g:1328:4: ( (lv_message_5_0= ruleMessageDefinition ) ) - // InternalRos.g:1329:5: (lv_message_5_0= ruleMessageDefinition ) + // InternalRosParser.g:841:4: ( (lv_message_6_0= ruleMessageDefinition ) ) + // InternalRosParser.g:842:5: (lv_message_6_0= ruleMessageDefinition ) { - // InternalRos.g:1329:5: (lv_message_5_0= ruleMessageDefinition ) - // InternalRos.g:1330:6: lv_message_5_0= ruleMessageDefinition + // InternalRosParser.g:842:5: (lv_message_6_0= ruleMessageDefinition ) + // InternalRosParser.g:843:6: lv_message_6_0= ruleMessageDefinition { - newCompositeNode(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_4_1_0()); + newCompositeNode(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); - pushFollow(FOLLOW_15); - lv_message_5_0=ruleMessageDefinition(); + pushFollow(FOLLOW_14); + lv_message_6_0=ruleMessageDefinition(); state._fsp--; @@ -3409,7 +2235,7 @@ public final EObject ruleTopicSpec() throws RecognitionException { set( current, "message", - lv_message_5_0, + lv_message_6_0, "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); afterParserOrEnumRuleCall(); @@ -3419,15 +2245,19 @@ public final EObject ruleTopicSpec() throws RecognitionException { } + this_END_7=(Token)match(input,RULE_END,FOLLOW_14); + + newLeafNode(this_END_7, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); + } break; } - otherlv_6=(Token)match(input,28,FOLLOW_2); + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_6, grammarAccess.getTopicSpecAccess().getRightCurlyBracketKeyword_5()); + newLeafNode(this_END_8, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); } @@ -3451,25 +2281,25 @@ public final EObject ruleTopicSpec() throws RecognitionException { // $ANTLR end "ruleTopicSpec" - // $ANTLR start "entryRuleActionSpec" - // InternalRos.g:1356:1: entryRuleActionSpec returns [EObject current=null] : iv_ruleActionSpec= ruleActionSpec EOF ; - public final EObject entryRuleActionSpec() throws RecognitionException { + // $ANTLR start "entryRuleServiceSpec" + // InternalRosParser.g:873:1: entryRuleServiceSpec returns [EObject current=null] : iv_ruleServiceSpec= ruleServiceSpec EOF ; + public final EObject entryRuleServiceSpec() throws RecognitionException { EObject current = null; - EObject iv_ruleActionSpec = null; + EObject iv_ruleServiceSpec = null; try { - // InternalRos.g:1356:51: (iv_ruleActionSpec= ruleActionSpec EOF ) - // InternalRos.g:1357:2: iv_ruleActionSpec= ruleActionSpec EOF + // InternalRosParser.g:873:52: (iv_ruleServiceSpec= ruleServiceSpec EOF ) + // InternalRosParser.g:874:2: iv_ruleServiceSpec= ruleServiceSpec EOF { - newCompositeNode(grammarAccess.getActionSpecRule()); + newCompositeNode(grammarAccess.getServiceSpecRule()); pushFollow(FOLLOW_1); - iv_ruleActionSpec=ruleActionSpec(); + iv_ruleServiceSpec=ruleServiceSpec(); state._fsp--; - current =iv_ruleActionSpec; + current =iv_ruleServiceSpec; match(input,EOF,FOLLOW_2); } @@ -3484,71 +2314,72 @@ public final EObject entryRuleActionSpec() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleActionSpec" + // $ANTLR end "entryRuleServiceSpec" - // $ANTLR start "ruleActionSpec" - // InternalRos.g:1363:1: ruleActionSpec returns [EObject current=null] : ( () otherlv_1= 'ActionSpec' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'goal' ( (lv_goal_5_0= ruleMessageDefinition ) ) )? (otherlv_6= 'result' ( (lv_result_7_0= ruleMessageDefinition ) ) )? (otherlv_8= 'feedback' ( (lv_feedback_9_0= ruleMessageDefinition ) ) )? otherlv_10= '}' ) ; - public final EObject ruleActionSpec() throws RecognitionException { + // $ANTLR start "ruleServiceSpec" + // InternalRosParser.g:880:1: ruleServiceSpec returns [EObject current=null] : ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) ; + public final EObject ruleServiceSpec() throws RecognitionException { EObject current = null; Token otherlv_1=null; - Token otherlv_3=null; + Token this_BEGIN_3=null; Token otherlv_4=null; - Token otherlv_6=null; + Token this_BEGIN_5=null; + Token this_END_7=null; Token otherlv_8=null; - Token otherlv_10=null; + Token this_BEGIN_9=null; + Token this_END_11=null; + Token this_END_12=null; AntlrDatatypeRuleToken lv_name_2_0 = null; - EObject lv_goal_5_0 = null; - - EObject lv_result_7_0 = null; + EObject lv_request_6_0 = null; - EObject lv_feedback_9_0 = null; + EObject lv_response_10_0 = null; enterRule(); try { - // InternalRos.g:1369:2: ( ( () otherlv_1= 'ActionSpec' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'goal' ( (lv_goal_5_0= ruleMessageDefinition ) ) )? (otherlv_6= 'result' ( (lv_result_7_0= ruleMessageDefinition ) ) )? (otherlv_8= 'feedback' ( (lv_feedback_9_0= ruleMessageDefinition ) ) )? otherlv_10= '}' ) ) - // InternalRos.g:1370:2: ( () otherlv_1= 'ActionSpec' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'goal' ( (lv_goal_5_0= ruleMessageDefinition ) ) )? (otherlv_6= 'result' ( (lv_result_7_0= ruleMessageDefinition ) ) )? (otherlv_8= 'feedback' ( (lv_feedback_9_0= ruleMessageDefinition ) ) )? otherlv_10= '}' ) + // InternalRosParser.g:886:2: ( ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) ) + // InternalRosParser.g:887:2: ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) { - // InternalRos.g:1370:2: ( () otherlv_1= 'ActionSpec' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'goal' ( (lv_goal_5_0= ruleMessageDefinition ) ) )? (otherlv_6= 'result' ( (lv_result_7_0= ruleMessageDefinition ) ) )? (otherlv_8= 'feedback' ( (lv_feedback_9_0= ruleMessageDefinition ) ) )? otherlv_10= '}' ) - // InternalRos.g:1371:3: () otherlv_1= 'ActionSpec' ( (lv_name_2_0= ruleEString ) ) otherlv_3= '{' (otherlv_4= 'goal' ( (lv_goal_5_0= ruleMessageDefinition ) ) )? (otherlv_6= 'result' ( (lv_result_7_0= ruleMessageDefinition ) ) )? (otherlv_8= 'feedback' ( (lv_feedback_9_0= ruleMessageDefinition ) ) )? otherlv_10= '}' + // InternalRosParser.g:887:2: ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) + // InternalRosParser.g:888:3: () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END { - // InternalRos.g:1371:3: () - // InternalRos.g:1372:4: + // InternalRosParser.g:888:3: () + // InternalRosParser.g:889:4: { current = forceCreateModelElement( - grammarAccess.getActionSpecAccess().getActionSpecAction_0(), + grammarAccess.getServiceSpecAccess().getServiceSpecAction_0(), current); } - otherlv_1=(Token)match(input,44,FOLLOW_7); + otherlv_1=(Token)match(input,Srv,FOLLOW_7); - newLeafNode(otherlv_1, grammarAccess.getActionSpecAccess().getActionSpecKeyword_1()); + newLeafNode(otherlv_1, grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); - // InternalRos.g:1382:3: ( (lv_name_2_0= ruleEString ) ) - // InternalRos.g:1383:4: (lv_name_2_0= ruleEString ) + // InternalRosParser.g:899:3: ( (lv_name_2_0= ruleEString ) ) + // InternalRosParser.g:900:4: (lv_name_2_0= ruleEString ) { - // InternalRos.g:1383:4: (lv_name_2_0= ruleEString ) - // InternalRos.g:1384:5: lv_name_2_0= ruleEString + // InternalRosParser.g:900:4: (lv_name_2_0= ruleEString ) + // InternalRosParser.g:901:5: lv_name_2_0= ruleEString { - newCompositeNode(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + newCompositeNode(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); - pushFollow(FOLLOW_3); + pushFollow(FOLLOW_5); lv_name_2_0=ruleEString(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getActionSpecRule()); + current = createModelElementForParent(grammarAccess.getServiceSpecRule()); } set( current, @@ -3563,99 +2394,51 @@ public final EObject ruleActionSpec() throws RecognitionException { } - otherlv_3=(Token)match(input,26,FOLLOW_23); + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_23); - newLeafNode(otherlv_3, grammarAccess.getActionSpecAccess().getLeftCurlyBracketKeyword_3()); + newLeafNode(this_BEGIN_3, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); - // InternalRos.g:1405:3: (otherlv_4= 'goal' ( (lv_goal_5_0= ruleMessageDefinition ) ) )? - int alt33=2; - int LA33_0 = input.LA(1); - - if ( (LA33_0==45) ) { - alt33=1; - } - switch (alt33) { - case 1 : - // InternalRos.g:1406:4: otherlv_4= 'goal' ( (lv_goal_5_0= ruleMessageDefinition ) ) - { - otherlv_4=(Token)match(input,45,FOLLOW_3); - - newLeafNode(otherlv_4, grammarAccess.getActionSpecAccess().getGoalKeyword_4_0()); - - // InternalRos.g:1410:4: ( (lv_goal_5_0= ruleMessageDefinition ) ) - // InternalRos.g:1411:5: (lv_goal_5_0= ruleMessageDefinition ) - { - // InternalRos.g:1411:5: (lv_goal_5_0= ruleMessageDefinition ) - // InternalRos.g:1412:6: lv_goal_5_0= ruleMessageDefinition - { - - newCompositeNode(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_4_1_0()); - - pushFollow(FOLLOW_24); - lv_goal_5_0=ruleMessageDefinition(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getActionSpecRule()); - } - set( - current, - "goal", - lv_goal_5_0, - "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); - afterParserOrEnumRuleCall(); - - - } - - - } - - - } - break; - - } + otherlv_4=(Token)match(input,Request,FOLLOW_24); - // InternalRos.g:1430:3: (otherlv_6= 'result' ( (lv_result_7_0= ruleMessageDefinition ) ) )? - int alt34=2; - int LA34_0 = input.LA(1); + newLeafNode(otherlv_4, grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); + + // InternalRosParser.g:926:3: (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? + int alt21=2; + int LA21_0 = input.LA(1); - if ( (LA34_0==46) ) { - alt34=1; + if ( (LA21_0==RULE_BEGIN) ) { + alt21=1; } - switch (alt34) { + switch (alt21) { case 1 : - // InternalRos.g:1431:4: otherlv_6= 'result' ( (lv_result_7_0= ruleMessageDefinition ) ) + // InternalRosParser.g:927:4: this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END { - otherlv_6=(Token)match(input,46,FOLLOW_3); + this_BEGIN_5=(Token)match(input,RULE_BEGIN,FOLLOW_22); - newLeafNode(otherlv_6, grammarAccess.getActionSpecAccess().getResultKeyword_5_0()); + newLeafNode(this_BEGIN_5, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); - // InternalRos.g:1435:4: ( (lv_result_7_0= ruleMessageDefinition ) ) - // InternalRos.g:1436:5: (lv_result_7_0= ruleMessageDefinition ) + // InternalRosParser.g:931:4: ( (lv_request_6_0= ruleMessageDefinition ) ) + // InternalRosParser.g:932:5: (lv_request_6_0= ruleMessageDefinition ) { - // InternalRos.g:1436:5: (lv_result_7_0= ruleMessageDefinition ) - // InternalRos.g:1437:6: lv_result_7_0= ruleMessageDefinition + // InternalRosParser.g:932:5: (lv_request_6_0= ruleMessageDefinition ) + // InternalRosParser.g:933:6: lv_request_6_0= ruleMessageDefinition { - newCompositeNode(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_5_1_0()); + newCompositeNode(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); - pushFollow(FOLLOW_25); - lv_result_7_0=ruleMessageDefinition(); + pushFollow(FOLLOW_14); + lv_request_6_0=ruleMessageDefinition(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getActionSpecRule()); + current = createModelElementForParent(grammarAccess.getServiceSpecRule()); } set( current, - "result", - lv_result_7_0, + "request", + lv_request_6_0, "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); afterParserOrEnumRuleCall(); @@ -3665,263 +2448,79 @@ public final EObject ruleActionSpec() throws RecognitionException { } + this_END_7=(Token)match(input,RULE_END,FOLLOW_25); - } - break; - - } - - // InternalRos.g:1455:3: (otherlv_8= 'feedback' ( (lv_feedback_9_0= ruleMessageDefinition ) ) )? - int alt35=2; - int LA35_0 = input.LA(1); - - if ( (LA35_0==47) ) { - alt35=1; - } - switch (alt35) { - case 1 : - // InternalRos.g:1456:4: otherlv_8= 'feedback' ( (lv_feedback_9_0= ruleMessageDefinition ) ) - { - otherlv_8=(Token)match(input,47,FOLLOW_3); - - newLeafNode(otherlv_8, grammarAccess.getActionSpecAccess().getFeedbackKeyword_6_0()); + newLeafNode(this_END_7, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); - // InternalRos.g:1460:4: ( (lv_feedback_9_0= ruleMessageDefinition ) ) - // InternalRos.g:1461:5: (lv_feedback_9_0= ruleMessageDefinition ) - { - // InternalRos.g:1461:5: (lv_feedback_9_0= ruleMessageDefinition ) - // InternalRos.g:1462:6: lv_feedback_9_0= ruleMessageDefinition - { - - newCompositeNode(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_6_1_0()); - - pushFollow(FOLLOW_15); - lv_feedback_9_0=ruleMessageDefinition(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getActionSpecRule()); - } - set( - current, - "feedback", - lv_feedback_9_0, - "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); - afterParserOrEnumRuleCall(); - - - } - - - } - } break; } - otherlv_10=(Token)match(input,28,FOLLOW_2); - - newLeafNode(otherlv_10, grammarAccess.getActionSpecAccess().getRightCurlyBracketKeyword_7()); - - - } - - - } - - - leaveRule(); - - } - - catch (RecognitionException re) { - recover(input,re); - appendSkippedTokens(); - } - finally { - } - return current; - } - // $ANTLR end "ruleActionSpec" - - - // $ANTLR start "entryRuleMessageDefinition" - // InternalRos.g:1488:1: entryRuleMessageDefinition returns [EObject current=null] : iv_ruleMessageDefinition= ruleMessageDefinition EOF ; - public final EObject entryRuleMessageDefinition() throws RecognitionException { - EObject current = null; - - EObject iv_ruleMessageDefinition = null; - - - try { - // InternalRos.g:1488:58: (iv_ruleMessageDefinition= ruleMessageDefinition EOF ) - // InternalRos.g:1489:2: iv_ruleMessageDefinition= ruleMessageDefinition EOF - { - newCompositeNode(grammarAccess.getMessageDefinitionRule()); - pushFollow(FOLLOW_1); - iv_ruleMessageDefinition=ruleMessageDefinition(); - - state._fsp--; - - current =iv_ruleMessageDefinition; - match(input,EOF,FOLLOW_2); - - } - - } - - catch (RecognitionException re) { - recover(input,re); - appendSkippedTokens(); - } - finally { - } - return current; - } - // $ANTLR end "entryRuleMessageDefinition" - - - // $ANTLR start "ruleMessageDefinition" - // InternalRos.g:1495:1: ruleMessageDefinition returns [EObject current=null] : ( () otherlv_1= '{' ( ( (lv_MessagePart_2_0= ruleMessagePart ) ) ( (lv_MessagePart_3_0= ruleMessagePart ) )* )? otherlv_4= '}' ) ; - public final EObject ruleMessageDefinition() throws RecognitionException { - EObject current = null; - - Token otherlv_1=null; - Token otherlv_4=null; - EObject lv_MessagePart_2_0 = null; - - EObject lv_MessagePart_3_0 = null; - - - - enterRule(); - - try { - // InternalRos.g:1501:2: ( ( () otherlv_1= '{' ( ( (lv_MessagePart_2_0= ruleMessagePart ) ) ( (lv_MessagePart_3_0= ruleMessagePart ) )* )? otherlv_4= '}' ) ) - // InternalRos.g:1502:2: ( () otherlv_1= '{' ( ( (lv_MessagePart_2_0= ruleMessagePart ) ) ( (lv_MessagePart_3_0= ruleMessagePart ) )* )? otherlv_4= '}' ) - { - // InternalRos.g:1502:2: ( () otherlv_1= '{' ( ( (lv_MessagePart_2_0= ruleMessagePart ) ) ( (lv_MessagePart_3_0= ruleMessagePart ) )* )? otherlv_4= '}' ) - // InternalRos.g:1503:3: () otherlv_1= '{' ( ( (lv_MessagePart_2_0= ruleMessagePart ) ) ( (lv_MessagePart_3_0= ruleMessagePart ) )* )? otherlv_4= '}' - { - // InternalRos.g:1503:3: () - // InternalRos.g:1504:4: - { - - current = forceCreateModelElement( - grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0(), - current); - - - } - - otherlv_1=(Token)match(input,26,FOLLOW_26); + otherlv_8=(Token)match(input,Response,FOLLOW_21); - newLeafNode(otherlv_1, grammarAccess.getMessageDefinitionAccess().getLeftCurlyBracketKeyword_1()); + newLeafNode(otherlv_8, grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); - // InternalRos.g:1514:3: ( ( (lv_MessagePart_2_0= ruleMessagePart ) ) ( (lv_MessagePart_3_0= ruleMessagePart ) )* )? - int alt37=2; - int LA37_0 = input.LA(1); + // InternalRosParser.g:959:3: (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? + int alt22=2; + int LA22_0 = input.LA(1); - if ( ((LA37_0>=RULE_STRING && LA37_0<=RULE_ID)||LA37_0==41||(LA37_0>=85 && LA37_0<=112)) ) { - alt37=1; + if ( (LA22_0==RULE_BEGIN) ) { + alt22=1; } - switch (alt37) { + switch (alt22) { case 1 : - // InternalRos.g:1515:4: ( (lv_MessagePart_2_0= ruleMessagePart ) ) ( (lv_MessagePart_3_0= ruleMessagePart ) )* + // InternalRosParser.g:960:4: this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END { - // InternalRos.g:1515:4: ( (lv_MessagePart_2_0= ruleMessagePart ) ) - // InternalRos.g:1516:5: (lv_MessagePart_2_0= ruleMessagePart ) - { - // InternalRos.g:1516:5: (lv_MessagePart_2_0= ruleMessagePart ) - // InternalRos.g:1517:6: lv_MessagePart_2_0= ruleMessagePart - { - - newCompositeNode(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_0_0()); - - pushFollow(FOLLOW_26); - lv_MessagePart_2_0=ruleMessagePart(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getMessageDefinitionRule()); - } - add( - current, - "MessagePart", - lv_MessagePart_2_0, - "de.fraunhofer.ipa.ros.Ros.MessagePart"); - afterParserOrEnumRuleCall(); - - - } - - - } - - // InternalRos.g:1534:4: ( (lv_MessagePart_3_0= ruleMessagePart ) )* - loop36: - do { - int alt36=2; - int LA36_0 = input.LA(1); - - if ( ((LA36_0>=RULE_STRING && LA36_0<=RULE_ID)||LA36_0==41||(LA36_0>=85 && LA36_0<=112)) ) { - alt36=1; - } - + this_BEGIN_9=(Token)match(input,RULE_BEGIN,FOLLOW_22); - switch (alt36) { - case 1 : - // InternalRos.g:1535:5: (lv_MessagePart_3_0= ruleMessagePart ) - { - // InternalRos.g:1535:5: (lv_MessagePart_3_0= ruleMessagePart ) - // InternalRos.g:1536:6: lv_MessagePart_3_0= ruleMessagePart - { + newLeafNode(this_BEGIN_9, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); + + // InternalRosParser.g:964:4: ( (lv_response_10_0= ruleMessageDefinition ) ) + // InternalRosParser.g:965:5: (lv_response_10_0= ruleMessageDefinition ) + { + // InternalRosParser.g:965:5: (lv_response_10_0= ruleMessageDefinition ) + // InternalRosParser.g:966:6: lv_response_10_0= ruleMessageDefinition + { - newCompositeNode(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_1_0()); - - pushFollow(FOLLOW_26); - lv_MessagePart_3_0=ruleMessagePart(); + newCompositeNode(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_14); + lv_response_10_0=ruleMessageDefinition(); - state._fsp--; + state._fsp--; - if (current==null) { - current = createModelElementForParent(grammarAccess.getMessageDefinitionRule()); - } - add( - current, - "MessagePart", - lv_MessagePart_3_0, - "de.fraunhofer.ipa.ros.Ros.MessagePart"); - afterParserOrEnumRuleCall(); - + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + current, + "response", + lv_response_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + - } + } - } - break; + } - default : - break loop36; - } - } while (true); + this_END_11=(Token)match(input,RULE_END,FOLLOW_14); + newLeafNode(this_END_11, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); + } break; } - otherlv_4=(Token)match(input,28,FOLLOW_2); + this_END_12=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_4, grammarAccess.getMessageDefinitionAccess().getRightCurlyBracketKeyword_3()); + newLeafNode(this_END_12, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); } @@ -3942,28 +2541,28 @@ public final EObject ruleMessageDefinition() throws RecognitionException { } return current; } - // $ANTLR end "ruleMessageDefinition" + // $ANTLR end "ruleServiceSpec" - // $ANTLR start "entryRuleNode" - // InternalRos.g:1562:1: entryRuleNode returns [EObject current=null] : iv_ruleNode= ruleNode EOF ; - public final EObject entryRuleNode() throws RecognitionException { + // $ANTLR start "entryRuleActionSpec" + // InternalRosParser.g:996:1: entryRuleActionSpec returns [EObject current=null] : iv_ruleActionSpec= ruleActionSpec EOF ; + public final EObject entryRuleActionSpec() throws RecognitionException { EObject current = null; - EObject iv_ruleNode = null; + EObject iv_ruleActionSpec = null; try { - // InternalRos.g:1562:45: (iv_ruleNode= ruleNode EOF ) - // InternalRos.g:1563:2: iv_ruleNode= ruleNode EOF + // InternalRosParser.g:996:51: (iv_ruleActionSpec= ruleActionSpec EOF ) + // InternalRosParser.g:997:2: iv_ruleActionSpec= ruleActionSpec EOF { - newCompositeNode(grammarAccess.getNodeRule()); + newCompositeNode(grammarAccess.getActionSpecRule()); pushFollow(FOLLOW_1); - iv_ruleNode=ruleNode(); + iv_ruleActionSpec=ruleActionSpec(); state._fsp--; - current =iv_ruleNode; + current =iv_ruleActionSpec; match(input,EOF,FOLLOW_2); } @@ -3978,122 +2577,83 @@ public final EObject entryRuleNode() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleNode" + // $ANTLR end "entryRuleActionSpec" - // $ANTLR start "ruleNode" - // InternalRos.g:1569:1: ruleNode returns [EObject current=null] : (otherlv_0= 'Node' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleRosNames ) ) (otherlv_4= 'ServiceServers' otherlv_5= '{' ( (lv_serviceserver_6_0= ruleServiceServer ) ) (otherlv_7= ',' ( (lv_serviceserver_8_0= ruleServiceServer ) ) )* otherlv_9= '}' )? (otherlv_10= 'Publishers' otherlv_11= '{' ( (lv_publisher_12_0= rulePublisher ) ) (otherlv_13= ',' ( (lv_publisher_14_0= rulePublisher ) ) )* otherlv_15= '}' )? (otherlv_16= 'Subscribers' otherlv_17= '{' ( (lv_subscriber_18_0= ruleSubscriber ) ) (otherlv_19= ',' ( (lv_subscriber_20_0= ruleSubscriber ) ) )* otherlv_21= '}' )? (otherlv_22= 'ServiceClients' otherlv_23= '{' ( (lv_serviceclient_24_0= ruleServiceClient ) ) (otherlv_25= ',' ( (lv_serviceclient_26_0= ruleServiceClient ) ) )* otherlv_27= '}' )? (otherlv_28= 'ActionServers' otherlv_29= '{' ( (lv_actionserver_30_0= ruleActionServer ) ) (otherlv_31= ',' ( (lv_actionserver_32_0= ruleActionServer ) ) )* otherlv_33= '}' )? (otherlv_34= 'ActionClients' otherlv_35= '{' ( (lv_actionclient_36_0= ruleActionClient ) ) (otherlv_37= ',' ( (lv_actionclient_38_0= ruleActionClient ) ) )* otherlv_39= '}' )? (otherlv_40= 'Parameters' otherlv_41= '{' ( (lv_parameter_42_0= ruleParameter ) ) (otherlv_43= ',' ( (lv_parameter_44_0= ruleParameter ) ) )* otherlv_45= '}' )? otherlv_46= '}' ) ; - public final EObject ruleNode() throws RecognitionException { + // $ANTLR start "ruleActionSpec" + // InternalRosParser.g:1003:1: ruleActionSpec returns [EObject current=null] : ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) ; + public final EObject ruleActionSpec() throws RecognitionException { EObject current = null; - Token otherlv_0=null; Token otherlv_1=null; - Token otherlv_2=null; + Token this_BEGIN_3=null; Token otherlv_4=null; - Token otherlv_5=null; - Token otherlv_7=null; - Token otherlv_9=null; - Token otherlv_10=null; - Token otherlv_11=null; - Token otherlv_13=null; - Token otherlv_15=null; - Token otherlv_16=null; - Token otherlv_17=null; - Token otherlv_19=null; - Token otherlv_21=null; - Token otherlv_22=null; - Token otherlv_23=null; - Token otherlv_25=null; - Token otherlv_27=null; - Token otherlv_28=null; - Token otherlv_29=null; - Token otherlv_31=null; - Token otherlv_33=null; - Token otherlv_34=null; - Token otherlv_35=null; - Token otherlv_37=null; - Token otherlv_39=null; - Token otherlv_40=null; - Token otherlv_41=null; - Token otherlv_43=null; - Token otherlv_45=null; - Token otherlv_46=null; - AntlrDatatypeRuleToken lv_name_3_0 = null; - - EObject lv_serviceserver_6_0 = null; - - EObject lv_serviceserver_8_0 = null; - - EObject lv_publisher_12_0 = null; - - EObject lv_publisher_14_0 = null; - - EObject lv_subscriber_18_0 = null; - - EObject lv_subscriber_20_0 = null; - - EObject lv_serviceclient_24_0 = null; - - EObject lv_serviceclient_26_0 = null; - - EObject lv_actionserver_30_0 = null; - - EObject lv_actionserver_32_0 = null; - - EObject lv_actionclient_36_0 = null; + Token this_BEGIN_5=null; + Token this_END_7=null; + Token otherlv_8=null; + Token this_BEGIN_9=null; + Token this_END_11=null; + Token otherlv_12=null; + Token this_BEGIN_13=null; + Token this_END_15=null; + Token this_END_16=null; + AntlrDatatypeRuleToken lv_name_2_0 = null; - EObject lv_actionclient_38_0 = null; + EObject lv_goal_6_0 = null; - EObject lv_parameter_42_0 = null; + EObject lv_result_10_0 = null; - EObject lv_parameter_44_0 = null; + EObject lv_feedback_14_0 = null; enterRule(); try { - // InternalRos.g:1575:2: ( (otherlv_0= 'Node' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleRosNames ) ) (otherlv_4= 'ServiceServers' otherlv_5= '{' ( (lv_serviceserver_6_0= ruleServiceServer ) ) (otherlv_7= ',' ( (lv_serviceserver_8_0= ruleServiceServer ) ) )* otherlv_9= '}' )? (otherlv_10= 'Publishers' otherlv_11= '{' ( (lv_publisher_12_0= rulePublisher ) ) (otherlv_13= ',' ( (lv_publisher_14_0= rulePublisher ) ) )* otherlv_15= '}' )? (otherlv_16= 'Subscribers' otherlv_17= '{' ( (lv_subscriber_18_0= ruleSubscriber ) ) (otherlv_19= ',' ( (lv_subscriber_20_0= ruleSubscriber ) ) )* otherlv_21= '}' )? (otherlv_22= 'ServiceClients' otherlv_23= '{' ( (lv_serviceclient_24_0= ruleServiceClient ) ) (otherlv_25= ',' ( (lv_serviceclient_26_0= ruleServiceClient ) ) )* otherlv_27= '}' )? (otherlv_28= 'ActionServers' otherlv_29= '{' ( (lv_actionserver_30_0= ruleActionServer ) ) (otherlv_31= ',' ( (lv_actionserver_32_0= ruleActionServer ) ) )* otherlv_33= '}' )? (otherlv_34= 'ActionClients' otherlv_35= '{' ( (lv_actionclient_36_0= ruleActionClient ) ) (otherlv_37= ',' ( (lv_actionclient_38_0= ruleActionClient ) ) )* otherlv_39= '}' )? (otherlv_40= 'Parameters' otherlv_41= '{' ( (lv_parameter_42_0= ruleParameter ) ) (otherlv_43= ',' ( (lv_parameter_44_0= ruleParameter ) ) )* otherlv_45= '}' )? otherlv_46= '}' ) ) - // InternalRos.g:1576:2: (otherlv_0= 'Node' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleRosNames ) ) (otherlv_4= 'ServiceServers' otherlv_5= '{' ( (lv_serviceserver_6_0= ruleServiceServer ) ) (otherlv_7= ',' ( (lv_serviceserver_8_0= ruleServiceServer ) ) )* otherlv_9= '}' )? (otherlv_10= 'Publishers' otherlv_11= '{' ( (lv_publisher_12_0= rulePublisher ) ) (otherlv_13= ',' ( (lv_publisher_14_0= rulePublisher ) ) )* otherlv_15= '}' )? (otherlv_16= 'Subscribers' otherlv_17= '{' ( (lv_subscriber_18_0= ruleSubscriber ) ) (otherlv_19= ',' ( (lv_subscriber_20_0= ruleSubscriber ) ) )* otherlv_21= '}' )? (otherlv_22= 'ServiceClients' otherlv_23= '{' ( (lv_serviceclient_24_0= ruleServiceClient ) ) (otherlv_25= ',' ( (lv_serviceclient_26_0= ruleServiceClient ) ) )* otherlv_27= '}' )? (otherlv_28= 'ActionServers' otherlv_29= '{' ( (lv_actionserver_30_0= ruleActionServer ) ) (otherlv_31= ',' ( (lv_actionserver_32_0= ruleActionServer ) ) )* otherlv_33= '}' )? (otherlv_34= 'ActionClients' otherlv_35= '{' ( (lv_actionclient_36_0= ruleActionClient ) ) (otherlv_37= ',' ( (lv_actionclient_38_0= ruleActionClient ) ) )* otherlv_39= '}' )? (otherlv_40= 'Parameters' otherlv_41= '{' ( (lv_parameter_42_0= ruleParameter ) ) (otherlv_43= ',' ( (lv_parameter_44_0= ruleParameter ) ) )* otherlv_45= '}' )? otherlv_46= '}' ) + // InternalRosParser.g:1009:2: ( ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) ) + // InternalRosParser.g:1010:2: ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) { - // InternalRos.g:1576:2: (otherlv_0= 'Node' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleRosNames ) ) (otherlv_4= 'ServiceServers' otherlv_5= '{' ( (lv_serviceserver_6_0= ruleServiceServer ) ) (otherlv_7= ',' ( (lv_serviceserver_8_0= ruleServiceServer ) ) )* otherlv_9= '}' )? (otherlv_10= 'Publishers' otherlv_11= '{' ( (lv_publisher_12_0= rulePublisher ) ) (otherlv_13= ',' ( (lv_publisher_14_0= rulePublisher ) ) )* otherlv_15= '}' )? (otherlv_16= 'Subscribers' otherlv_17= '{' ( (lv_subscriber_18_0= ruleSubscriber ) ) (otherlv_19= ',' ( (lv_subscriber_20_0= ruleSubscriber ) ) )* otherlv_21= '}' )? (otherlv_22= 'ServiceClients' otherlv_23= '{' ( (lv_serviceclient_24_0= ruleServiceClient ) ) (otherlv_25= ',' ( (lv_serviceclient_26_0= ruleServiceClient ) ) )* otherlv_27= '}' )? (otherlv_28= 'ActionServers' otherlv_29= '{' ( (lv_actionserver_30_0= ruleActionServer ) ) (otherlv_31= ',' ( (lv_actionserver_32_0= ruleActionServer ) ) )* otherlv_33= '}' )? (otherlv_34= 'ActionClients' otherlv_35= '{' ( (lv_actionclient_36_0= ruleActionClient ) ) (otherlv_37= ',' ( (lv_actionclient_38_0= ruleActionClient ) ) )* otherlv_39= '}' )? (otherlv_40= 'Parameters' otherlv_41= '{' ( (lv_parameter_42_0= ruleParameter ) ) (otherlv_43= ',' ( (lv_parameter_44_0= ruleParameter ) ) )* otherlv_45= '}' )? otherlv_46= '}' ) - // InternalRos.g:1577:3: otherlv_0= 'Node' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleRosNames ) ) (otherlv_4= 'ServiceServers' otherlv_5= '{' ( (lv_serviceserver_6_0= ruleServiceServer ) ) (otherlv_7= ',' ( (lv_serviceserver_8_0= ruleServiceServer ) ) )* otherlv_9= '}' )? (otherlv_10= 'Publishers' otherlv_11= '{' ( (lv_publisher_12_0= rulePublisher ) ) (otherlv_13= ',' ( (lv_publisher_14_0= rulePublisher ) ) )* otherlv_15= '}' )? (otherlv_16= 'Subscribers' otherlv_17= '{' ( (lv_subscriber_18_0= ruleSubscriber ) ) (otherlv_19= ',' ( (lv_subscriber_20_0= ruleSubscriber ) ) )* otherlv_21= '}' )? (otherlv_22= 'ServiceClients' otherlv_23= '{' ( (lv_serviceclient_24_0= ruleServiceClient ) ) (otherlv_25= ',' ( (lv_serviceclient_26_0= ruleServiceClient ) ) )* otherlv_27= '}' )? (otherlv_28= 'ActionServers' otherlv_29= '{' ( (lv_actionserver_30_0= ruleActionServer ) ) (otherlv_31= ',' ( (lv_actionserver_32_0= ruleActionServer ) ) )* otherlv_33= '}' )? (otherlv_34= 'ActionClients' otherlv_35= '{' ( (lv_actionclient_36_0= ruleActionClient ) ) (otherlv_37= ',' ( (lv_actionclient_38_0= ruleActionClient ) ) )* otherlv_39= '}' )? (otherlv_40= 'Parameters' otherlv_41= '{' ( (lv_parameter_42_0= ruleParameter ) ) (otherlv_43= ',' ( (lv_parameter_44_0= ruleParameter ) ) )* otherlv_45= '}' )? otherlv_46= '}' + // InternalRosParser.g:1010:2: ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) + // InternalRosParser.g:1011:3: () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END + { + // InternalRosParser.g:1011:3: () + // InternalRosParser.g:1012:4: { - otherlv_0=(Token)match(input,48,FOLLOW_3); - newLeafNode(otherlv_0, grammarAccess.getNodeAccess().getNodeKeyword_0()); - - otherlv_1=(Token)match(input,26,FOLLOW_27); + current = forceCreateModelElement( + grammarAccess.getActionSpecAccess().getActionSpecAction_0(), + current); + - newLeafNode(otherlv_1, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_1()); - - otherlv_2=(Token)match(input,49,FOLLOW_13); + } + + otherlv_1=(Token)match(input,Action_1,FOLLOW_7); - newLeafNode(otherlv_2, grammarAccess.getNodeAccess().getNameKeyword_2()); + newLeafNode(otherlv_1, grammarAccess.getActionSpecAccess().getActionKeyword_1()); - // InternalRos.g:1589:3: ( (lv_name_3_0= ruleRosNames ) ) - // InternalRos.g:1590:4: (lv_name_3_0= ruleRosNames ) + // InternalRosParser.g:1022:3: ( (lv_name_2_0= ruleEString ) ) + // InternalRosParser.g:1023:4: (lv_name_2_0= ruleEString ) { - // InternalRos.g:1590:4: (lv_name_3_0= ruleRosNames ) - // InternalRos.g:1591:5: lv_name_3_0= ruleRosNames + // InternalRosParser.g:1023:4: (lv_name_2_0= ruleEString ) + // InternalRosParser.g:1024:5: lv_name_2_0= ruleEString { - newCompositeNode(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_3_0()); + newCompositeNode(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); - pushFollow(FOLLOW_28); - lv_name_3_0=ruleRosNames(); + pushFollow(FOLLOW_5); + lv_name_2_0=ruleEString(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); + current = createModelElementForParent(grammarAccess.getActionSpecRule()); } set( current, "name", - lv_name_3_0, - "de.fraunhofer.ipa.ros.Ros.RosNames"); + lv_name_2_0, + "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); @@ -4102,48 +2662,52 @@ public final EObject ruleNode() throws RecognitionException { } - // InternalRos.g:1608:3: (otherlv_4= 'ServiceServers' otherlv_5= '{' ( (lv_serviceserver_6_0= ruleServiceServer ) ) (otherlv_7= ',' ( (lv_serviceserver_8_0= ruleServiceServer ) ) )* otherlv_9= '}' )? - int alt39=2; - int LA39_0 = input.LA(1); + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_26); + + newLeafNode(this_BEGIN_3, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Goal_1,FOLLOW_27); + + newLeafNode(otherlv_4, grammarAccess.getActionSpecAccess().getGoalKeyword_4()); + + // InternalRosParser.g:1049:3: (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? + int alt23=2; + int LA23_0 = input.LA(1); - if ( (LA39_0==50) ) { - alt39=1; + if ( (LA23_0==RULE_BEGIN) ) { + alt23=1; } - switch (alt39) { + switch (alt23) { case 1 : - // InternalRos.g:1609:4: otherlv_4= 'ServiceServers' otherlv_5= '{' ( (lv_serviceserver_6_0= ruleServiceServer ) ) (otherlv_7= ',' ( (lv_serviceserver_8_0= ruleServiceServer ) ) )* otherlv_9= '}' + // InternalRosParser.g:1050:4: this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END { - otherlv_4=(Token)match(input,50,FOLLOW_3); - - newLeafNode(otherlv_4, grammarAccess.getNodeAccess().getServiceServersKeyword_4_0()); - - otherlv_5=(Token)match(input,26,FOLLOW_29); + this_BEGIN_5=(Token)match(input,RULE_BEGIN,FOLLOW_22); - newLeafNode(otherlv_5, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_4_1()); + newLeafNode(this_BEGIN_5, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); - // InternalRos.g:1617:4: ( (lv_serviceserver_6_0= ruleServiceServer ) ) - // InternalRos.g:1618:5: (lv_serviceserver_6_0= ruleServiceServer ) + // InternalRosParser.g:1054:4: ( (lv_goal_6_0= ruleMessageDefinition ) ) + // InternalRosParser.g:1055:5: (lv_goal_6_0= ruleMessageDefinition ) { - // InternalRos.g:1618:5: (lv_serviceserver_6_0= ruleServiceServer ) - // InternalRos.g:1619:6: lv_serviceserver_6_0= ruleServiceServer + // InternalRosParser.g:1055:5: (lv_goal_6_0= ruleMessageDefinition ) + // InternalRosParser.g:1056:6: lv_goal_6_0= ruleMessageDefinition { - newCompositeNode(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_2_0()); + newCompositeNode(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); - pushFollow(FOLLOW_5); - lv_serviceserver_6_0=ruleServiceServer(); + pushFollow(FOLLOW_14); + lv_goal_6_0=ruleMessageDefinition(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); + current = createModelElementForParent(grammarAccess.getActionSpecRule()); } - add( + set( current, - "serviceserver", - lv_serviceserver_6_0, - "de.fraunhofer.ipa.ros.Ros.ServiceServer"); + "goal", + lv_goal_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); afterParserOrEnumRuleCall(); @@ -4152,68 +2716,69 @@ public final EObject ruleNode() throws RecognitionException { } - // InternalRos.g:1636:4: (otherlv_7= ',' ( (lv_serviceserver_8_0= ruleServiceServer ) ) )* - loop38: - do { - int alt38=2; - int LA38_0 = input.LA(1); + this_END_7=(Token)match(input,RULE_END,FOLLOW_28); - if ( (LA38_0==27) ) { - alt38=1; - } + newLeafNode(this_END_7, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); + + } + break; - switch (alt38) { - case 1 : - // InternalRos.g:1637:5: otherlv_7= ',' ( (lv_serviceserver_8_0= ruleServiceServer ) ) - { - otherlv_7=(Token)match(input,27,FOLLOW_29); + } - newLeafNode(otherlv_7, grammarAccess.getNodeAccess().getCommaKeyword_4_3_0()); - - // InternalRos.g:1641:5: ( (lv_serviceserver_8_0= ruleServiceServer ) ) - // InternalRos.g:1642:6: (lv_serviceserver_8_0= ruleServiceServer ) - { - // InternalRos.g:1642:6: (lv_serviceserver_8_0= ruleServiceServer ) - // InternalRos.g:1643:7: lv_serviceserver_8_0= ruleServiceServer - { + otherlv_8=(Token)match(input,Result_1,FOLLOW_29); - newCompositeNode(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_3_1_0()); - - pushFollow(FOLLOW_5); - lv_serviceserver_8_0=ruleServiceServer(); + newLeafNode(otherlv_8, grammarAccess.getActionSpecAccess().getResultKeyword_6()); + + // InternalRosParser.g:1082:3: (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? + int alt24=2; + int LA24_0 = input.LA(1); - state._fsp--; + if ( (LA24_0==RULE_BEGIN) ) { + alt24=1; + } + switch (alt24) { + case 1 : + // InternalRosParser.g:1083:4: this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END + { + this_BEGIN_9=(Token)match(input,RULE_BEGIN,FOLLOW_22); + newLeafNode(this_BEGIN_9, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); + + // InternalRosParser.g:1087:4: ( (lv_result_10_0= ruleMessageDefinition ) ) + // InternalRosParser.g:1088:5: (lv_result_10_0= ruleMessageDefinition ) + { + // InternalRosParser.g:1088:5: (lv_result_10_0= ruleMessageDefinition ) + // InternalRosParser.g:1089:6: lv_result_10_0= ruleMessageDefinition + { - if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - current, - "serviceserver", - lv_serviceserver_8_0, - "de.fraunhofer.ipa.ros.Ros.ServiceServer"); - afterParserOrEnumRuleCall(); - + newCompositeNode(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_14); + lv_result_10_0=ruleMessageDefinition(); - } + state._fsp--; - } + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + current, + "result", + lv_result_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + } - } - break; - default : - break loop38; - } - } while (true); + } - otherlv_9=(Token)match(input,28,FOLLOW_30); + this_END_11=(Token)match(input,RULE_END,FOLLOW_30); - newLeafNode(otherlv_9, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_4_4()); + newLeafNode(this_END_11, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); } @@ -4221,48 +2786,48 @@ public final EObject ruleNode() throws RecognitionException { } - // InternalRos.g:1666:3: (otherlv_10= 'Publishers' otherlv_11= '{' ( (lv_publisher_12_0= rulePublisher ) ) (otherlv_13= ',' ( (lv_publisher_14_0= rulePublisher ) ) )* otherlv_15= '}' )? - int alt41=2; - int LA41_0 = input.LA(1); + otherlv_12=(Token)match(input,Feedback_1,FOLLOW_21); - if ( (LA41_0==51) ) { - alt41=1; + newLeafNode(otherlv_12, grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + + // InternalRosParser.g:1115:3: (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0==RULE_BEGIN) ) { + alt25=1; } - switch (alt41) { + switch (alt25) { case 1 : - // InternalRos.g:1667:4: otherlv_10= 'Publishers' otherlv_11= '{' ( (lv_publisher_12_0= rulePublisher ) ) (otherlv_13= ',' ( (lv_publisher_14_0= rulePublisher ) ) )* otherlv_15= '}' + // InternalRosParser.g:1116:4: this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END { - otherlv_10=(Token)match(input,51,FOLLOW_3); - - newLeafNode(otherlv_10, grammarAccess.getNodeAccess().getPublishersKeyword_5_0()); - - otherlv_11=(Token)match(input,26,FOLLOW_31); + this_BEGIN_13=(Token)match(input,RULE_BEGIN,FOLLOW_22); - newLeafNode(otherlv_11, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_5_1()); + newLeafNode(this_BEGIN_13, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); - // InternalRos.g:1675:4: ( (lv_publisher_12_0= rulePublisher ) ) - // InternalRos.g:1676:5: (lv_publisher_12_0= rulePublisher ) + // InternalRosParser.g:1120:4: ( (lv_feedback_14_0= ruleMessageDefinition ) ) + // InternalRosParser.g:1121:5: (lv_feedback_14_0= ruleMessageDefinition ) { - // InternalRos.g:1676:5: (lv_publisher_12_0= rulePublisher ) - // InternalRos.g:1677:6: lv_publisher_12_0= rulePublisher + // InternalRosParser.g:1121:5: (lv_feedback_14_0= ruleMessageDefinition ) + // InternalRosParser.g:1122:6: lv_feedback_14_0= ruleMessageDefinition { - newCompositeNode(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_2_0()); + newCompositeNode(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); - pushFollow(FOLLOW_5); - lv_publisher_12_0=rulePublisher(); + pushFollow(FOLLOW_14); + lv_feedback_14_0=ruleMessageDefinition(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); + current = createModelElementForParent(grammarAccess.getActionSpecRule()); } - add( + set( current, - "publisher", - lv_publisher_12_0, - "de.fraunhofer.ipa.ros.Ros.Publisher"); + "feedback", + lv_feedback_14_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); afterParserOrEnumRuleCall(); @@ -4271,355 +2836,359 @@ public final EObject ruleNode() throws RecognitionException { } - // InternalRos.g:1694:4: (otherlv_13= ',' ( (lv_publisher_14_0= rulePublisher ) ) )* - loop40: - do { - int alt40=2; - int LA40_0 = input.LA(1); + this_END_15=(Token)match(input,RULE_END,FOLLOW_14); - if ( (LA40_0==27) ) { - alt40=1; - } + newLeafNode(this_END_15, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); + + } + break; - switch (alt40) { - case 1 : - // InternalRos.g:1695:5: otherlv_13= ',' ( (lv_publisher_14_0= rulePublisher ) ) - { - otherlv_13=(Token)match(input,27,FOLLOW_31); + } - newLeafNode(otherlv_13, grammarAccess.getNodeAccess().getCommaKeyword_5_3_0()); - - // InternalRos.g:1699:5: ( (lv_publisher_14_0= rulePublisher ) ) - // InternalRos.g:1700:6: (lv_publisher_14_0= rulePublisher ) - { - // InternalRos.g:1700:6: (lv_publisher_14_0= rulePublisher ) - // InternalRos.g:1701:7: lv_publisher_14_0= rulePublisher - { + this_END_16=(Token)match(input,RULE_END,FOLLOW_2); - newCompositeNode(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_3_1_0()); - - pushFollow(FOLLOW_5); - lv_publisher_14_0=rulePublisher(); + newLeafNode(this_END_16, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); + - state._fsp--; + } - if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - current, - "publisher", - lv_publisher_14_0, - "de.fraunhofer.ipa.ros.Ros.Publisher"); - afterParserOrEnumRuleCall(); - + } - } + leaveRule(); - } + } + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleActionSpec" - } - break; - default : - break loop40; - } - } while (true); + // $ANTLR start "entryRuleMessageDefinition" + // InternalRosParser.g:1152:1: entryRuleMessageDefinition returns [EObject current=null] : iv_ruleMessageDefinition= ruleMessageDefinition EOF ; + public final EObject entryRuleMessageDefinition() throws RecognitionException { + EObject current = null; - otherlv_15=(Token)match(input,28,FOLLOW_32); + EObject iv_ruleMessageDefinition = null; - newLeafNode(otherlv_15, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_5_4()); - - } - break; + try { + // InternalRosParser.g:1152:58: (iv_ruleMessageDefinition= ruleMessageDefinition EOF ) + // InternalRosParser.g:1153:2: iv_ruleMessageDefinition= ruleMessageDefinition EOF + { + newCompositeNode(grammarAccess.getMessageDefinitionRule()); + pushFollow(FOLLOW_1); + iv_ruleMessageDefinition=ruleMessageDefinition(); + + state._fsp--; + + current =iv_ruleMessageDefinition; + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); } + finally { + } + return current; + } + // $ANTLR end "entryRuleMessageDefinition" + + + // $ANTLR start "ruleMessageDefinition" + // InternalRosParser.g:1159:1: ruleMessageDefinition returns [EObject current=null] : ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) ; + public final EObject ruleMessageDefinition() throws RecognitionException { + EObject current = null; + + EObject lv_MessagePart_1_0 = null; + + + + enterRule(); + + try { + // InternalRosParser.g:1165:2: ( ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) ) + // InternalRosParser.g:1166:2: ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) + { + // InternalRosParser.g:1166:2: ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) + // InternalRosParser.g:1167:3: () ( (lv_MessagePart_1_0= ruleMessagePart ) )* + { + // InternalRosParser.g:1167:3: () + // InternalRosParser.g:1168:4: + { - // InternalRos.g:1724:3: (otherlv_16= 'Subscribers' otherlv_17= '{' ( (lv_subscriber_18_0= ruleSubscriber ) ) (otherlv_19= ',' ( (lv_subscriber_20_0= ruleSubscriber ) ) )* otherlv_21= '}' )? - int alt43=2; - int LA43_0 = input.LA(1); + current = forceCreateModelElement( + grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0(), + current); + - if ( (LA43_0==52) ) { - alt43=1; } - switch (alt43) { - case 1 : - // InternalRos.g:1725:4: otherlv_16= 'Subscribers' otherlv_17= '{' ( (lv_subscriber_18_0= ruleSubscriber ) ) (otherlv_19= ',' ( (lv_subscriber_20_0= ruleSubscriber ) ) )* otherlv_21= '}' - { - otherlv_16=(Token)match(input,52,FOLLOW_3); - newLeafNode(otherlv_16, grammarAccess.getNodeAccess().getSubscribersKeyword_6_0()); - - otherlv_17=(Token)match(input,26,FOLLOW_33); + // InternalRosParser.g:1174:3: ( (lv_MessagePart_1_0= ruleMessagePart ) )* + loop26: + do { + int alt26=2; + int LA26_0 = input.LA(1); - newLeafNode(otherlv_17, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_6_1()); - - // InternalRos.g:1733:4: ( (lv_subscriber_18_0= ruleSubscriber ) ) - // InternalRos.g:1734:5: (lv_subscriber_18_0= ruleSubscriber ) - { - // InternalRos.g:1734:5: (lv_subscriber_18_0= ruleSubscriber ) - // InternalRos.g:1735:6: lv_subscriber_18_0= ruleSubscriber - { + if ( ((LA26_0>=Float32_1 && LA26_0<=Float64_1)||LA26_0==Duration||(LA26_0>=String_2 && LA26_0<=Uint64_1)||(LA26_0>=Float32 && LA26_0<=Int64_1)||LA26_0==Uint8_1||LA26_0==Header||(LA26_0>=Bool_1 && LA26_0<=Int8_1)||(LA26_0>=String_1 && LA26_0<=Uint64)||(LA26_0>=Int16 && LA26_0<=Int64)||LA26_0==Uint8||(LA26_0>=Bool && LA26_0<=Byte)||LA26_0==Int8||LA26_0==Time||LA26_0==RULE_ID||LA26_0==RULE_STRING) ) { + alt26=1; + } - newCompositeNode(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_2_0()); - - pushFollow(FOLLOW_5); - lv_subscriber_18_0=ruleSubscriber(); - state._fsp--; + switch (alt26) { + case 1 : + // InternalRosParser.g:1175:4: (lv_MessagePart_1_0= ruleMessagePart ) + { + // InternalRosParser.g:1175:4: (lv_MessagePart_1_0= ruleMessagePart ) + // InternalRosParser.g:1176:5: lv_MessagePart_1_0= ruleMessagePart + { + newCompositeNode(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); + + pushFollow(FOLLOW_31); + lv_MessagePart_1_0=ruleMessagePart(); - if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - current, - "subscriber", - lv_subscriber_18_0, - "de.fraunhofer.ipa.ros.Ros.Subscriber"); - afterParserOrEnumRuleCall(); - + state._fsp--; - } + if (current==null) { + current = createModelElementForParent(grammarAccess.getMessageDefinitionRule()); + } + add( + current, + "MessagePart", + lv_MessagePart_1_0, + "de.fraunhofer.ipa.ros.Ros.MessagePart"); + afterParserOrEnumRuleCall(); + - } + } - // InternalRos.g:1752:4: (otherlv_19= ',' ( (lv_subscriber_20_0= ruleSubscriber ) ) )* - loop42: - do { - int alt42=2; - int LA42_0 = input.LA(1); - if ( (LA42_0==27) ) { - alt42=1; - } + } + break; + default : + break loop26; + } + } while (true); - switch (alt42) { - case 1 : - // InternalRos.g:1753:5: otherlv_19= ',' ( (lv_subscriber_20_0= ruleSubscriber ) ) - { - otherlv_19=(Token)match(input,27,FOLLOW_33); - newLeafNode(otherlv_19, grammarAccess.getNodeAccess().getCommaKeyword_6_3_0()); - - // InternalRos.g:1757:5: ( (lv_subscriber_20_0= ruleSubscriber ) ) - // InternalRos.g:1758:6: (lv_subscriber_20_0= ruleSubscriber ) - { - // InternalRos.g:1758:6: (lv_subscriber_20_0= ruleSubscriber ) - // InternalRos.g:1759:7: lv_subscriber_20_0= ruleSubscriber - { + } - newCompositeNode(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_3_1_0()); - - pushFollow(FOLLOW_5); - lv_subscriber_20_0=ruleSubscriber(); - state._fsp--; + } - if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - current, - "subscriber", - lv_subscriber_20_0, - "de.fraunhofer.ipa.ros.Ros.Subscriber"); - afterParserOrEnumRuleCall(); - + leaveRule(); - } + } + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMessageDefinition" - } + // $ANTLR start "entryRulePublisher" + // InternalRosParser.g:1197:1: entryRulePublisher returns [EObject current=null] : iv_rulePublisher= rulePublisher EOF ; + public final EObject entryRulePublisher() throws RecognitionException { + EObject current = null; - } - break; + EObject iv_rulePublisher = null; - default : - break loop42; - } - } while (true); - otherlv_21=(Token)match(input,28,FOLLOW_34); + try { + // InternalRosParser.g:1197:50: (iv_rulePublisher= rulePublisher EOF ) + // InternalRosParser.g:1198:2: iv_rulePublisher= rulePublisher EOF + { + newCompositeNode(grammarAccess.getPublisherRule()); + pushFollow(FOLLOW_1); + iv_rulePublisher=rulePublisher(); - newLeafNode(otherlv_21, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_6_4()); - + state._fsp--; - } - break; + current =iv_rulePublisher; + match(input,EOF,FOLLOW_2); } - // InternalRos.g:1782:3: (otherlv_22= 'ServiceClients' otherlv_23= '{' ( (lv_serviceclient_24_0= ruleServiceClient ) ) (otherlv_25= ',' ( (lv_serviceclient_26_0= ruleServiceClient ) ) )* otherlv_27= '}' )? - int alt45=2; - int LA45_0 = input.LA(1); + } - if ( (LA45_0==53) ) { - alt45=1; + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); } - switch (alt45) { - case 1 : - // InternalRos.g:1783:4: otherlv_22= 'ServiceClients' otherlv_23= '{' ( (lv_serviceclient_24_0= ruleServiceClient ) ) (otherlv_25= ',' ( (lv_serviceclient_26_0= ruleServiceClient ) ) )* otherlv_27= '}' - { - otherlv_22=(Token)match(input,53,FOLLOW_3); + finally { + } + return current; + } + // $ANTLR end "entryRulePublisher" - newLeafNode(otherlv_22, grammarAccess.getNodeAccess().getServiceClientsKeyword_7_0()); - - otherlv_23=(Token)match(input,26,FOLLOW_35); - newLeafNode(otherlv_23, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_7_1()); - - // InternalRos.g:1791:4: ( (lv_serviceclient_24_0= ruleServiceClient ) ) - // InternalRos.g:1792:5: (lv_serviceclient_24_0= ruleServiceClient ) - { - // InternalRos.g:1792:5: (lv_serviceclient_24_0= ruleServiceClient ) - // InternalRos.g:1793:6: lv_serviceclient_24_0= ruleServiceClient - { + // $ANTLR start "rulePublisher" + // InternalRosParser.g:1204:1: rulePublisher returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ; + public final EObject rulePublisher() throws RecognitionException { + EObject current = null; - newCompositeNode(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_2_0()); - - pushFollow(FOLLOW_5); - lv_serviceclient_24_0=ruleServiceClient(); + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; - state._fsp--; + EObject lv_namespace_7_0 = null; - if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - current, - "serviceclient", - lv_serviceclient_24_0, - "de.fraunhofer.ipa.ros.Ros.ServiceClient"); - afterParserOrEnumRuleCall(); - - } + enterRule(); + try { + // InternalRosParser.g:1210:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRosParser.g:1211:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + { + // InternalRosParser.g:1211:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRosParser.g:1212:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END + { + // InternalRosParser.g:1212:3: () + // InternalRosParser.g:1213:4: + { - } + current = forceCreateModelElement( + grammarAccess.getPublisherAccess().getPublisherAction_0(), + current); + - // InternalRos.g:1810:4: (otherlv_25= ',' ( (lv_serviceclient_26_0= ruleServiceClient ) ) )* - loop44: - do { - int alt44=2; - int LA44_0 = input.LA(1); + } - if ( (LA44_0==27) ) { - alt44=1; - } + // InternalRosParser.g:1219:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRosParser.g:1220:4: (lv_name_1_0= ruleEString ) + { + // InternalRosParser.g:1220:4: (lv_name_1_0= ruleEString ) + // InternalRosParser.g:1221:5: lv_name_1_0= ruleEString + { + newCompositeNode(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_4); + lv_name_1_0=ruleEString(); - switch (alt44) { - case 1 : - // InternalRos.g:1811:5: otherlv_25= ',' ( (lv_serviceclient_26_0= ruleServiceClient ) ) - { - otherlv_25=(Token)match(input,27,FOLLOW_35); + state._fsp--; - newLeafNode(otherlv_25, grammarAccess.getNodeAccess().getCommaKeyword_7_3_0()); - - // InternalRos.g:1815:5: ( (lv_serviceclient_26_0= ruleServiceClient ) ) - // InternalRos.g:1816:6: (lv_serviceclient_26_0= ruleServiceClient ) - { - // InternalRos.g:1816:6: (lv_serviceclient_26_0= ruleServiceClient ) - // InternalRos.g:1817:7: lv_serviceclient_26_0= ruleServiceClient - { - newCompositeNode(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_3_1_0()); - - pushFollow(FOLLOW_5); - lv_serviceclient_26_0=ruleServiceClient(); + if (current==null) { + current = createModelElementForParent(grammarAccess.getPublisherRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + - state._fsp--; + } - if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - current, - "serviceclient", - lv_serviceclient_26_0, - "de.fraunhofer.ipa.ros.Ros.ServiceClient"); - afterParserOrEnumRuleCall(); - + } - } + otherlv_2=(Token)match(input,Colon,FOLLOW_5); + newLeafNode(otherlv_2, grammarAccess.getPublisherAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_32); - } + newLeafNode(this_BEGIN_3, grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_7); + newLeafNode(otherlv_4, grammarAccess.getPublisherAccess().getTypeKeyword_4()); + + // InternalRosParser.g:1250:3: ( ( ruleEString ) ) + // InternalRosParser.g:1251:4: ( ruleEString ) + { + // InternalRosParser.g:1251:4: ( ruleEString ) + // InternalRosParser.g:1252:5: ruleEString + { - } - break; + if (current==null) { + current = createModelElement(grammarAccess.getPublisherRule()); + } + - default : - break loop44; - } - } while (true); + newCompositeNode(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + + pushFollow(FOLLOW_33); + ruleEString(); - otherlv_27=(Token)match(input,28,FOLLOW_36); + state._fsp--; - newLeafNode(otherlv_27, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_7_4()); - - } - break; + afterParserOrEnumRuleCall(); + } - // InternalRos.g:1840:3: (otherlv_28= 'ActionServers' otherlv_29= '{' ( (lv_actionserver_30_0= ruleActionServer ) ) (otherlv_31= ',' ( (lv_actionserver_32_0= ruleActionServer ) ) )* otherlv_33= '}' )? - int alt47=2; - int LA47_0 = input.LA(1); - if ( (LA47_0==54) ) { - alt47=1; } - switch (alt47) { + + // InternalRosParser.g:1266:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt27=2; + int LA27_0 = input.LA(1); + + if ( (LA27_0==Ns) ) { + alt27=1; + } + switch (alt27) { case 1 : - // InternalRos.g:1841:4: otherlv_28= 'ActionServers' otherlv_29= '{' ( (lv_actionserver_30_0= ruleActionServer ) ) (otherlv_31= ',' ( (lv_actionserver_32_0= ruleActionServer ) ) )* otherlv_33= '}' + // InternalRosParser.g:1267:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) { - otherlv_28=(Token)match(input,54,FOLLOW_3); - - newLeafNode(otherlv_28, grammarAccess.getNodeAccess().getActionServersKeyword_8_0()); - - otherlv_29=(Token)match(input,26,FOLLOW_37); + otherlv_6=(Token)match(input,Ns,FOLLOW_34); - newLeafNode(otherlv_29, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_8_1()); + newLeafNode(otherlv_6, grammarAccess.getPublisherAccess().getNsKeyword_6_0()); - // InternalRos.g:1849:4: ( (lv_actionserver_30_0= ruleActionServer ) ) - // InternalRos.g:1850:5: (lv_actionserver_30_0= ruleActionServer ) + // InternalRosParser.g:1271:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRosParser.g:1272:5: (lv_namespace_7_0= ruleNamespace ) { - // InternalRos.g:1850:5: (lv_actionserver_30_0= ruleActionServer ) - // InternalRos.g:1851:6: lv_actionserver_30_0= ruleActionServer + // InternalRosParser.g:1272:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRosParser.g:1273:6: lv_namespace_7_0= ruleNamespace { - newCompositeNode(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_2_0()); + newCompositeNode(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); - pushFollow(FOLLOW_5); - lv_actionserver_30_0=ruleActionServer(); + pushFollow(FOLLOW_14); + lv_namespace_7_0=ruleNamespace(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); + current = createModelElementForParent(grammarAccess.getPublisherRule()); } - add( + set( current, - "actionserver", - lv_actionserver_30_0, - "de.fraunhofer.ipa.ros.Ros.ActionServer"); + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); afterParserOrEnumRuleCall(); @@ -4628,236 +3197,219 @@ public final EObject ruleNode() throws RecognitionException { } - // InternalRos.g:1868:4: (otherlv_31= ',' ( (lv_actionserver_32_0= ruleActionServer ) ) )* - loop46: - do { - int alt46=2; - int LA46_0 = input.LA(1); - if ( (LA46_0==27) ) { - alt46=1; - } + } + break; + } - switch (alt46) { - case 1 : - // InternalRos.g:1869:5: otherlv_31= ',' ( (lv_actionserver_32_0= ruleActionServer ) ) - { - otherlv_31=(Token)match(input,27,FOLLOW_37); + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_31, grammarAccess.getNodeAccess().getCommaKeyword_8_3_0()); - - // InternalRos.g:1873:5: ( (lv_actionserver_32_0= ruleActionServer ) ) - // InternalRos.g:1874:6: (lv_actionserver_32_0= ruleActionServer ) - { - // InternalRos.g:1874:6: (lv_actionserver_32_0= ruleActionServer ) - // InternalRos.g:1875:7: lv_actionserver_32_0= ruleActionServer - { + newLeafNode(this_END_8, grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); + - newCompositeNode(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_3_1_0()); - - pushFollow(FOLLOW_5); - lv_actionserver_32_0=ruleActionServer(); + } - state._fsp--; + } - if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - current, - "actionserver", - lv_actionserver_32_0, - "de.fraunhofer.ipa.ros.Ros.ActionServer"); - afterParserOrEnumRuleCall(); - - } + leaveRule(); + } - } + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePublisher" - } - break; + // $ANTLR start "entryRuleSubscriber" + // InternalRosParser.g:1299:1: entryRuleSubscriber returns [EObject current=null] : iv_ruleSubscriber= ruleSubscriber EOF ; + public final EObject entryRuleSubscriber() throws RecognitionException { + EObject current = null; - default : - break loop46; - } - } while (true); + EObject iv_ruleSubscriber = null; + + + try { + // InternalRosParser.g:1299:51: (iv_ruleSubscriber= ruleSubscriber EOF ) + // InternalRosParser.g:1300:2: iv_ruleSubscriber= ruleSubscriber EOF + { + newCompositeNode(grammarAccess.getSubscriberRule()); + pushFollow(FOLLOW_1); + iv_ruleSubscriber=ruleSubscriber(); + + state._fsp--; - otherlv_33=(Token)match(input,28,FOLLOW_38); + current =iv_ruleSubscriber; + match(input,EOF,FOLLOW_2); - newLeafNode(otherlv_33, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_8_4()); - + } - } - break; + } + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); } + finally { + } + return current; + } + // $ANTLR end "entryRuleSubscriber" - // InternalRos.g:1898:3: (otherlv_34= 'ActionClients' otherlv_35= '{' ( (lv_actionclient_36_0= ruleActionClient ) ) (otherlv_37= ',' ( (lv_actionclient_38_0= ruleActionClient ) ) )* otherlv_39= '}' )? - int alt49=2; - int LA49_0 = input.LA(1); - if ( (LA49_0==55) ) { - alt49=1; - } - switch (alt49) { - case 1 : - // InternalRos.g:1899:4: otherlv_34= 'ActionClients' otherlv_35= '{' ( (lv_actionclient_36_0= ruleActionClient ) ) (otherlv_37= ',' ( (lv_actionclient_38_0= ruleActionClient ) ) )* otherlv_39= '}' - { - otherlv_34=(Token)match(input,55,FOLLOW_3); + // $ANTLR start "ruleSubscriber" + // InternalRosParser.g:1306:1: ruleSubscriber returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ; + public final EObject ruleSubscriber() throws RecognitionException { + EObject current = null; - newLeafNode(otherlv_34, grammarAccess.getNodeAccess().getActionClientsKeyword_9_0()); - - otherlv_35=(Token)match(input,26,FOLLOW_39); + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; - newLeafNode(otherlv_35, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_9_1()); - - // InternalRos.g:1907:4: ( (lv_actionclient_36_0= ruleActionClient ) ) - // InternalRos.g:1908:5: (lv_actionclient_36_0= ruleActionClient ) - { - // InternalRos.g:1908:5: (lv_actionclient_36_0= ruleActionClient ) - // InternalRos.g:1909:6: lv_actionclient_36_0= ruleActionClient - { + EObject lv_namespace_7_0 = null; - newCompositeNode(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_2_0()); - - pushFollow(FOLLOW_5); - lv_actionclient_36_0=ruleActionClient(); - state._fsp--; + enterRule(); - if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - current, - "actionclient", - lv_actionclient_36_0, - "de.fraunhofer.ipa.ros.Ros.ActionClient"); - afterParserOrEnumRuleCall(); - + try { + // InternalRosParser.g:1312:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRosParser.g:1313:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + { + // InternalRosParser.g:1313:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRosParser.g:1314:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END + { + // InternalRosParser.g:1314:3: () + // InternalRosParser.g:1315:4: + { - } + current = forceCreateModelElement( + grammarAccess.getSubscriberAccess().getSubscriberAction_0(), + current); + + } - } + // InternalRosParser.g:1321:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRosParser.g:1322:4: (lv_name_1_0= ruleEString ) + { + // InternalRosParser.g:1322:4: (lv_name_1_0= ruleEString ) + // InternalRosParser.g:1323:5: lv_name_1_0= ruleEString + { - // InternalRos.g:1926:4: (otherlv_37= ',' ( (lv_actionclient_38_0= ruleActionClient ) ) )* - loop48: - do { - int alt48=2; - int LA48_0 = input.LA(1); + newCompositeNode(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_4); + lv_name_1_0=ruleEString(); - if ( (LA48_0==27) ) { - alt48=1; - } + state._fsp--; - switch (alt48) { - case 1 : - // InternalRos.g:1927:5: otherlv_37= ',' ( (lv_actionclient_38_0= ruleActionClient ) ) - { - otherlv_37=(Token)match(input,27,FOLLOW_39); + if (current==null) { + current = createModelElementForParent(grammarAccess.getSubscriberRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + - newLeafNode(otherlv_37, grammarAccess.getNodeAccess().getCommaKeyword_9_3_0()); - - // InternalRos.g:1931:5: ( (lv_actionclient_38_0= ruleActionClient ) ) - // InternalRos.g:1932:6: (lv_actionclient_38_0= ruleActionClient ) - { - // InternalRos.g:1932:6: (lv_actionclient_38_0= ruleActionClient ) - // InternalRos.g:1933:7: lv_actionclient_38_0= ruleActionClient - { + } - newCompositeNode(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_3_1_0()); - - pushFollow(FOLLOW_5); - lv_actionclient_38_0=ruleActionClient(); - state._fsp--; + } + otherlv_2=(Token)match(input,Colon,FOLLOW_5); - if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - current, - "actionclient", - lv_actionclient_38_0, - "de.fraunhofer.ipa.ros.Ros.ActionClient"); - afterParserOrEnumRuleCall(); - + newLeafNode(otherlv_2, grammarAccess.getSubscriberAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_32); - } + newLeafNode(this_BEGIN_3, grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_7); + newLeafNode(otherlv_4, grammarAccess.getSubscriberAccess().getTypeKeyword_4()); + + // InternalRosParser.g:1352:3: ( ( ruleEString ) ) + // InternalRosParser.g:1353:4: ( ruleEString ) + { + // InternalRosParser.g:1353:4: ( ruleEString ) + // InternalRosParser.g:1354:5: ruleEString + { - } + if (current==null) { + current = createModelElement(grammarAccess.getSubscriberRule()); + } + + newCompositeNode(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + + pushFollow(FOLLOW_33); + ruleEString(); - } - break; + state._fsp--; - default : - break loop48; - } - } while (true); - otherlv_39=(Token)match(input,28,FOLLOW_40); + afterParserOrEnumRuleCall(); + - newLeafNode(otherlv_39, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_9_4()); - + } - } - break; } - // InternalRos.g:1956:3: (otherlv_40= 'Parameters' otherlv_41= '{' ( (lv_parameter_42_0= ruleParameter ) ) (otherlv_43= ',' ( (lv_parameter_44_0= ruleParameter ) ) )* otherlv_45= '}' )? - int alt51=2; - int LA51_0 = input.LA(1); + // InternalRosParser.g:1368:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt28=2; + int LA28_0 = input.LA(1); - if ( (LA51_0==56) ) { - alt51=1; + if ( (LA28_0==Ns) ) { + alt28=1; } - switch (alt51) { + switch (alt28) { case 1 : - // InternalRos.g:1957:4: otherlv_40= 'Parameters' otherlv_41= '{' ( (lv_parameter_42_0= ruleParameter ) ) (otherlv_43= ',' ( (lv_parameter_44_0= ruleParameter ) ) )* otherlv_45= '}' + // InternalRosParser.g:1369:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) { - otherlv_40=(Token)match(input,56,FOLLOW_3); - - newLeafNode(otherlv_40, grammarAccess.getNodeAccess().getParametersKeyword_10_0()); - - otherlv_41=(Token)match(input,26,FOLLOW_41); + otherlv_6=(Token)match(input,Ns,FOLLOW_34); - newLeafNode(otherlv_41, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_10_1()); + newLeafNode(otherlv_6, grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); - // InternalRos.g:1965:4: ( (lv_parameter_42_0= ruleParameter ) ) - // InternalRos.g:1966:5: (lv_parameter_42_0= ruleParameter ) + // InternalRosParser.g:1373:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRosParser.g:1374:5: (lv_namespace_7_0= ruleNamespace ) { - // InternalRos.g:1966:5: (lv_parameter_42_0= ruleParameter ) - // InternalRos.g:1967:6: lv_parameter_42_0= ruleParameter + // InternalRosParser.g:1374:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRosParser.g:1375:6: lv_namespace_7_0= ruleNamespace { - newCompositeNode(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_2_0()); + newCompositeNode(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); - pushFollow(FOLLOW_5); - lv_parameter_42_0=ruleParameter(); + pushFollow(FOLLOW_14); + lv_namespace_7_0=ruleNamespace(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); + current = createModelElementForParent(grammarAccess.getSubscriberRule()); } - add( + set( current, - "parameter", - lv_parameter_42_0, - "de.fraunhofer.ipa.ros.Ros.Parameter"); + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); afterParserOrEnumRuleCall(); @@ -4866,78 +3418,15 @@ public final EObject ruleNode() throws RecognitionException { } - // InternalRos.g:1984:4: (otherlv_43= ',' ( (lv_parameter_44_0= ruleParameter ) ) )* - loop50: - do { - int alt50=2; - int LA50_0 = input.LA(1); - - if ( (LA50_0==27) ) { - alt50=1; - } - - - switch (alt50) { - case 1 : - // InternalRos.g:1985:5: otherlv_43= ',' ( (lv_parameter_44_0= ruleParameter ) ) - { - otherlv_43=(Token)match(input,27,FOLLOW_41); - - newLeafNode(otherlv_43, grammarAccess.getNodeAccess().getCommaKeyword_10_3_0()); - - // InternalRos.g:1989:5: ( (lv_parameter_44_0= ruleParameter ) ) - // InternalRos.g:1990:6: (lv_parameter_44_0= ruleParameter ) - { - // InternalRos.g:1990:6: (lv_parameter_44_0= ruleParameter ) - // InternalRos.g:1991:7: lv_parameter_44_0= ruleParameter - { - - newCompositeNode(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_3_1_0()); - - pushFollow(FOLLOW_5); - lv_parameter_44_0=ruleParameter(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - current, - "parameter", - lv_parameter_44_0, - "de.fraunhofer.ipa.ros.Ros.Parameter"); - afterParserOrEnumRuleCall(); - - - } - - - } - - - } - break; - - default : - break loop50; - } - } while (true); - - otherlv_45=(Token)match(input,28,FOLLOW_15); - - newLeafNode(otherlv_45, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_10_4()); - } break; } - otherlv_46=(Token)match(input,28,FOLLOW_2); + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_46, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_11()); + newLeafNode(this_END_8, grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); } @@ -4958,11 +3447,11 @@ public final EObject ruleNode() throws RecognitionException { } return current; } - // $ANTLR end "ruleNode" + // $ANTLR end "ruleSubscriber" // $ANTLR start "entryRuleServiceServer" - // InternalRos.g:2022:1: entryRuleServiceServer returns [EObject current=null] : iv_ruleServiceServer= ruleServiceServer EOF ; + // InternalRosParser.g:1401:1: entryRuleServiceServer returns [EObject current=null] : iv_ruleServiceServer= ruleServiceServer EOF ; public final EObject entryRuleServiceServer() throws RecognitionException { EObject current = null; @@ -4970,8 +3459,8 @@ public final EObject entryRuleServiceServer() throws RecognitionException { try { - // InternalRos.g:2022:54: (iv_ruleServiceServer= ruleServiceServer EOF ) - // InternalRos.g:2023:2: iv_ruleServiceServer= ruleServiceServer EOF + // InternalRosParser.g:1401:54: (iv_ruleServiceServer= ruleServiceServer EOF ) + // InternalRosParser.g:1402:2: iv_ruleServiceServer= ruleServiceServer EOF { newCompositeNode(grammarAccess.getServiceServerRule()); pushFollow(FOLLOW_1); @@ -4998,17 +3487,16 @@ public final EObject entryRuleServiceServer() throws RecognitionException { // $ANTLR start "ruleServiceServer" - // InternalRos.g:2029:1: ruleServiceServer returns [EObject current=null] : (otherlv_0= 'ServiceServer' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'service' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ; + // InternalRosParser.g:1408:1: ruleServiceServer returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ; public final EObject ruleServiceServer() throws RecognitionException { EObject current = null; - Token otherlv_0=null; - Token otherlv_1=null; Token otherlv_2=null; + Token this_BEGIN_3=null; Token otherlv_4=null; Token otherlv_6=null; - Token otherlv_8=null; - AntlrDatatypeRuleToken lv_name_3_0 = null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; EObject lv_namespace_7_0 = null; @@ -5017,35 +3505,34 @@ public final EObject ruleServiceServer() throws RecognitionException { enterRule(); try { - // InternalRos.g:2035:2: ( (otherlv_0= 'ServiceServer' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'service' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ) - // InternalRos.g:2036:2: (otherlv_0= 'ServiceServer' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'service' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) + // InternalRosParser.g:1414:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRosParser.g:1415:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + { + // InternalRosParser.g:1415:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRosParser.g:1416:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END { - // InternalRos.g:2036:2: (otherlv_0= 'ServiceServer' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'service' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) - // InternalRos.g:2037:3: otherlv_0= 'ServiceServer' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'service' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' + // InternalRosParser.g:1416:3: () + // InternalRosParser.g:1417:4: { - otherlv_0=(Token)match(input,57,FOLLOW_3); - newLeafNode(otherlv_0, grammarAccess.getServiceServerAccess().getServiceServerKeyword_0()); - - otherlv_1=(Token)match(input,26,FOLLOW_27); + current = forceCreateModelElement( + grammarAccess.getServiceServerAccess().getServiceServerAction_0(), + current); + - newLeafNode(otherlv_1, grammarAccess.getServiceServerAccess().getLeftCurlyBracketKeyword_1()); - - otherlv_2=(Token)match(input,49,FOLLOW_7); + } - newLeafNode(otherlv_2, grammarAccess.getServiceServerAccess().getNameKeyword_2()); - - // InternalRos.g:2049:3: ( (lv_name_3_0= ruleEString ) ) - // InternalRos.g:2050:4: (lv_name_3_0= ruleEString ) + // InternalRosParser.g:1423:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRosParser.g:1424:4: (lv_name_1_0= ruleEString ) { - // InternalRos.g:2050:4: (lv_name_3_0= ruleEString ) - // InternalRos.g:2051:5: lv_name_3_0= ruleEString + // InternalRosParser.g:1424:4: (lv_name_1_0= ruleEString ) + // InternalRosParser.g:1425:5: lv_name_1_0= ruleEString { - newCompositeNode(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_3_0()); + newCompositeNode(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); - pushFollow(FOLLOW_42); - lv_name_3_0=ruleEString(); + pushFollow(FOLLOW_4); + lv_name_1_0=ruleEString(); state._fsp--; @@ -5056,7 +3543,7 @@ public final EObject ruleServiceServer() throws RecognitionException { set( current, "name", - lv_name_3_0, + lv_name_1_0, "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); @@ -5066,15 +3553,23 @@ public final EObject ruleServiceServer() throws RecognitionException { } - otherlv_4=(Token)match(input,58,FOLLOW_7); + otherlv_2=(Token)match(input,Colon,FOLLOW_5); + + newLeafNode(otherlv_2, grammarAccess.getServiceServerAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_32); + + newLeafNode(this_BEGIN_3, grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_7); - newLeafNode(otherlv_4, grammarAccess.getServiceServerAccess().getServiceKeyword_4()); + newLeafNode(otherlv_4, grammarAccess.getServiceServerAccess().getTypeKeyword_4()); - // InternalRos.g:2072:3: ( ( ruleEString ) ) - // InternalRos.g:2073:4: ( ruleEString ) + // InternalRosParser.g:1454:3: ( ( ruleEString ) ) + // InternalRosParser.g:1455:4: ( ruleEString ) { - // InternalRos.g:2073:4: ( ruleEString ) - // InternalRos.g:2074:5: ruleEString + // InternalRosParser.g:1455:4: ( ruleEString ) + // InternalRosParser.g:1456:5: ruleEString { if (current==null) { @@ -5084,7 +3579,7 @@ public final EObject ruleServiceServer() throws RecognitionException { newCompositeNode(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); - pushFollow(FOLLOW_43); + pushFollow(FOLLOW_33); ruleEString(); state._fsp--; @@ -5098,31 +3593,31 @@ public final EObject ruleServiceServer() throws RecognitionException { } - // InternalRos.g:2088:3: (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? - int alt52=2; - int LA52_0 = input.LA(1); + // InternalRosParser.g:1470:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt29=2; + int LA29_0 = input.LA(1); - if ( (LA52_0==59) ) { - alt52=1; + if ( (LA29_0==Ns) ) { + alt29=1; } - switch (alt52) { + switch (alt29) { case 1 : - // InternalRos.g:2089:4: otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRosParser.g:1471:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) { - otherlv_6=(Token)match(input,59,FOLLOW_44); + otherlv_6=(Token)match(input,Ns,FOLLOW_34); - newLeafNode(otherlv_6, grammarAccess.getServiceServerAccess().getNamespaceKeyword_6_0()); + newLeafNode(otherlv_6, grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); - // InternalRos.g:2093:4: ( (lv_namespace_7_0= ruleNamespace ) ) - // InternalRos.g:2094:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRosParser.g:1475:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRosParser.g:1476:5: (lv_namespace_7_0= ruleNamespace ) { - // InternalRos.g:2094:5: (lv_namespace_7_0= ruleNamespace ) - // InternalRos.g:2095:6: lv_namespace_7_0= ruleNamespace + // InternalRosParser.g:1476:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRosParser.g:1477:6: lv_namespace_7_0= ruleNamespace { newCompositeNode(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); - pushFollow(FOLLOW_15); + pushFollow(FOLLOW_14); lv_namespace_7_0=ruleNamespace(); state._fsp--; @@ -5150,9 +3645,9 @@ public final EObject ruleServiceServer() throws RecognitionException { } - otherlv_8=(Token)match(input,28,FOLLOW_2); + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_8, grammarAccess.getServiceServerAccess().getRightCurlyBracketKeyword_7()); + newLeafNode(this_END_8, grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); } @@ -5176,25 +3671,25 @@ public final EObject ruleServiceServer() throws RecognitionException { // $ANTLR end "ruleServiceServer" - // $ANTLR start "entryRulePublisher" - // InternalRos.g:2121:1: entryRulePublisher returns [EObject current=null] : iv_rulePublisher= rulePublisher EOF ; - public final EObject entryRulePublisher() throws RecognitionException { + // $ANTLR start "entryRuleServiceClient" + // InternalRosParser.g:1503:1: entryRuleServiceClient returns [EObject current=null] : iv_ruleServiceClient= ruleServiceClient EOF ; + public final EObject entryRuleServiceClient() throws RecognitionException { EObject current = null; - EObject iv_rulePublisher = null; + EObject iv_ruleServiceClient = null; try { - // InternalRos.g:2121:50: (iv_rulePublisher= rulePublisher EOF ) - // InternalRos.g:2122:2: iv_rulePublisher= rulePublisher EOF + // InternalRosParser.g:1503:54: (iv_ruleServiceClient= ruleServiceClient EOF ) + // InternalRosParser.g:1504:2: iv_ruleServiceClient= ruleServiceClient EOF { - newCompositeNode(grammarAccess.getPublisherRule()); + newCompositeNode(grammarAccess.getServiceClientRule()); pushFollow(FOLLOW_1); - iv_rulePublisher=rulePublisher(); + iv_ruleServiceClient=ruleServiceClient(); state._fsp--; - current =iv_rulePublisher; + current =iv_ruleServiceClient; match(input,EOF,FOLLOW_2); } @@ -5209,21 +3704,20 @@ public final EObject entryRulePublisher() throws RecognitionException { } return current; } - // $ANTLR end "entryRulePublisher" + // $ANTLR end "entryRuleServiceClient" - // $ANTLR start "rulePublisher" - // InternalRos.g:2128:1: rulePublisher returns [EObject current=null] : (otherlv_0= 'Publisher' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'message' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ; - public final EObject rulePublisher() throws RecognitionException { + // $ANTLR start "ruleServiceClient" + // InternalRosParser.g:1510:1: ruleServiceClient returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ; + public final EObject ruleServiceClient() throws RecognitionException { EObject current = null; - Token otherlv_0=null; - Token otherlv_1=null; Token otherlv_2=null; + Token this_BEGIN_3=null; Token otherlv_4=null; Token otherlv_6=null; - Token otherlv_8=null; - AntlrDatatypeRuleToken lv_name_3_0 = null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; EObject lv_namespace_7_0 = null; @@ -5232,46 +3726,45 @@ public final EObject rulePublisher() throws RecognitionException { enterRule(); try { - // InternalRos.g:2134:2: ( (otherlv_0= 'Publisher' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'message' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ) - // InternalRos.g:2135:2: (otherlv_0= 'Publisher' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'message' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) + // InternalRosParser.g:1516:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRosParser.g:1517:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + { + // InternalRosParser.g:1517:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRosParser.g:1518:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END { - // InternalRos.g:2135:2: (otherlv_0= 'Publisher' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'message' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) - // InternalRos.g:2136:3: otherlv_0= 'Publisher' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'message' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' + // InternalRosParser.g:1518:3: () + // InternalRosParser.g:1519:4: { - otherlv_0=(Token)match(input,60,FOLLOW_3); - newLeafNode(otherlv_0, grammarAccess.getPublisherAccess().getPublisherKeyword_0()); - - otherlv_1=(Token)match(input,26,FOLLOW_27); + current = forceCreateModelElement( + grammarAccess.getServiceClientAccess().getServiceClientAction_0(), + current); + - newLeafNode(otherlv_1, grammarAccess.getPublisherAccess().getLeftCurlyBracketKeyword_1()); - - otherlv_2=(Token)match(input,49,FOLLOW_7); + } - newLeafNode(otherlv_2, grammarAccess.getPublisherAccess().getNameKeyword_2()); - - // InternalRos.g:2148:3: ( (lv_name_3_0= ruleEString ) ) - // InternalRos.g:2149:4: (lv_name_3_0= ruleEString ) + // InternalRosParser.g:1525:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRosParser.g:1526:4: (lv_name_1_0= ruleEString ) { - // InternalRos.g:2149:4: (lv_name_3_0= ruleEString ) - // InternalRos.g:2150:5: lv_name_3_0= ruleEString + // InternalRosParser.g:1526:4: (lv_name_1_0= ruleEString ) + // InternalRosParser.g:1527:5: lv_name_1_0= ruleEString { - newCompositeNode(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_3_0()); + newCompositeNode(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); - pushFollow(FOLLOW_45); - lv_name_3_0=ruleEString(); + pushFollow(FOLLOW_4); + lv_name_1_0=ruleEString(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getPublisherRule()); + current = createModelElementForParent(grammarAccess.getServiceClientRule()); } set( current, "name", - lv_name_3_0, + lv_name_1_0, "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); @@ -5281,25 +3774,33 @@ public final EObject rulePublisher() throws RecognitionException { } - otherlv_4=(Token)match(input,43,FOLLOW_7); + otherlv_2=(Token)match(input,Colon,FOLLOW_5); + + newLeafNode(otherlv_2, grammarAccess.getServiceClientAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_32); + + newLeafNode(this_BEGIN_3, grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_7); - newLeafNode(otherlv_4, grammarAccess.getPublisherAccess().getMessageKeyword_4()); + newLeafNode(otherlv_4, grammarAccess.getServiceClientAccess().getTypeKeyword_4()); - // InternalRos.g:2171:3: ( ( ruleEString ) ) - // InternalRos.g:2172:4: ( ruleEString ) + // InternalRosParser.g:1556:3: ( ( ruleEString ) ) + // InternalRosParser.g:1557:4: ( ruleEString ) { - // InternalRos.g:2172:4: ( ruleEString ) - // InternalRos.g:2173:5: ruleEString + // InternalRosParser.g:1557:4: ( ruleEString ) + // InternalRosParser.g:1558:5: ruleEString { if (current==null) { - current = createModelElement(grammarAccess.getPublisherRule()); + current = createModelElement(grammarAccess.getServiceClientRule()); } - newCompositeNode(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + newCompositeNode(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); - pushFollow(FOLLOW_43); + pushFollow(FOLLOW_33); ruleEString(); state._fsp--; @@ -5313,38 +3814,38 @@ public final EObject rulePublisher() throws RecognitionException { } - // InternalRos.g:2187:3: (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? - int alt53=2; - int LA53_0 = input.LA(1); + // InternalRosParser.g:1572:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt30=2; + int LA30_0 = input.LA(1); - if ( (LA53_0==59) ) { - alt53=1; + if ( (LA30_0==Ns) ) { + alt30=1; } - switch (alt53) { + switch (alt30) { case 1 : - // InternalRos.g:2188:4: otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRosParser.g:1573:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) { - otherlv_6=(Token)match(input,59,FOLLOW_44); + otherlv_6=(Token)match(input,Ns,FOLLOW_34); - newLeafNode(otherlv_6, grammarAccess.getPublisherAccess().getNamespaceKeyword_6_0()); + newLeafNode(otherlv_6, grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); - // InternalRos.g:2192:4: ( (lv_namespace_7_0= ruleNamespace ) ) - // InternalRos.g:2193:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRosParser.g:1577:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRosParser.g:1578:5: (lv_namespace_7_0= ruleNamespace ) { - // InternalRos.g:2193:5: (lv_namespace_7_0= ruleNamespace ) - // InternalRos.g:2194:6: lv_namespace_7_0= ruleNamespace + // InternalRosParser.g:1578:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRosParser.g:1579:6: lv_namespace_7_0= ruleNamespace { - newCompositeNode(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + newCompositeNode(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); - pushFollow(FOLLOW_15); + pushFollow(FOLLOW_14); lv_namespace_7_0=ruleNamespace(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getPublisherRule()); + current = createModelElementForParent(grammarAccess.getServiceClientRule()); } set( current, @@ -5365,9 +3866,9 @@ public final EObject rulePublisher() throws RecognitionException { } - otherlv_8=(Token)match(input,28,FOLLOW_2); + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_8, grammarAccess.getPublisherAccess().getRightCurlyBracketKeyword_7()); + newLeafNode(this_END_8, grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); } @@ -5388,28 +3889,28 @@ public final EObject rulePublisher() throws RecognitionException { } return current; } - // $ANTLR end "rulePublisher" + // $ANTLR end "ruleServiceClient" - // $ANTLR start "entryRuleSubscriber" - // InternalRos.g:2220:1: entryRuleSubscriber returns [EObject current=null] : iv_ruleSubscriber= ruleSubscriber EOF ; - public final EObject entryRuleSubscriber() throws RecognitionException { + // $ANTLR start "entryRuleActionServer" + // InternalRosParser.g:1605:1: entryRuleActionServer returns [EObject current=null] : iv_ruleActionServer= ruleActionServer EOF ; + public final EObject entryRuleActionServer() throws RecognitionException { EObject current = null; - EObject iv_ruleSubscriber = null; + EObject iv_ruleActionServer = null; try { - // InternalRos.g:2220:51: (iv_ruleSubscriber= ruleSubscriber EOF ) - // InternalRos.g:2221:2: iv_ruleSubscriber= ruleSubscriber EOF + // InternalRosParser.g:1605:53: (iv_ruleActionServer= ruleActionServer EOF ) + // InternalRosParser.g:1606:2: iv_ruleActionServer= ruleActionServer EOF { - newCompositeNode(grammarAccess.getSubscriberRule()); + newCompositeNode(grammarAccess.getActionServerRule()); pushFollow(FOLLOW_1); - iv_ruleSubscriber=ruleSubscriber(); + iv_ruleActionServer=ruleActionServer(); state._fsp--; - current =iv_ruleSubscriber; + current =iv_ruleActionServer; match(input,EOF,FOLLOW_2); } @@ -5424,21 +3925,20 @@ public final EObject entryRuleSubscriber() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleSubscriber" + // $ANTLR end "entryRuleActionServer" - // $ANTLR start "ruleSubscriber" - // InternalRos.g:2227:1: ruleSubscriber returns [EObject current=null] : (otherlv_0= 'Subscriber' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'message' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ; - public final EObject ruleSubscriber() throws RecognitionException { + // $ANTLR start "ruleActionServer" + // InternalRosParser.g:1612:1: ruleActionServer returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ; + public final EObject ruleActionServer() throws RecognitionException { EObject current = null; - Token otherlv_0=null; - Token otherlv_1=null; Token otherlv_2=null; + Token this_BEGIN_3=null; Token otherlv_4=null; Token otherlv_6=null; - Token otherlv_8=null; - AntlrDatatypeRuleToken lv_name_3_0 = null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; EObject lv_namespace_7_0 = null; @@ -5447,46 +3947,45 @@ public final EObject ruleSubscriber() throws RecognitionException { enterRule(); try { - // InternalRos.g:2233:2: ( (otherlv_0= 'Subscriber' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'message' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ) - // InternalRos.g:2234:2: (otherlv_0= 'Subscriber' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'message' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) + // InternalRosParser.g:1618:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRosParser.g:1619:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) { - // InternalRos.g:2234:2: (otherlv_0= 'Subscriber' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'message' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) - // InternalRos.g:2235:3: otherlv_0= 'Subscriber' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'message' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' + // InternalRosParser.g:1619:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRosParser.g:1620:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END + { + // InternalRosParser.g:1620:3: () + // InternalRosParser.g:1621:4: { - otherlv_0=(Token)match(input,61,FOLLOW_3); - newLeafNode(otherlv_0, grammarAccess.getSubscriberAccess().getSubscriberKeyword_0()); - - otherlv_1=(Token)match(input,26,FOLLOW_27); + current = forceCreateModelElement( + grammarAccess.getActionServerAccess().getActionServerAction_0(), + current); + - newLeafNode(otherlv_1, grammarAccess.getSubscriberAccess().getLeftCurlyBracketKeyword_1()); - - otherlv_2=(Token)match(input,49,FOLLOW_7); + } - newLeafNode(otherlv_2, grammarAccess.getSubscriberAccess().getNameKeyword_2()); - - // InternalRos.g:2247:3: ( (lv_name_3_0= ruleEString ) ) - // InternalRos.g:2248:4: (lv_name_3_0= ruleEString ) + // InternalRosParser.g:1627:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRosParser.g:1628:4: (lv_name_1_0= ruleEString ) { - // InternalRos.g:2248:4: (lv_name_3_0= ruleEString ) - // InternalRos.g:2249:5: lv_name_3_0= ruleEString + // InternalRosParser.g:1628:4: (lv_name_1_0= ruleEString ) + // InternalRosParser.g:1629:5: lv_name_1_0= ruleEString { - newCompositeNode(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_3_0()); + newCompositeNode(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); - pushFollow(FOLLOW_45); - lv_name_3_0=ruleEString(); + pushFollow(FOLLOW_4); + lv_name_1_0=ruleEString(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getSubscriberRule()); + current = createModelElementForParent(grammarAccess.getActionServerRule()); } set( current, "name", - lv_name_3_0, + lv_name_1_0, "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); @@ -5496,25 +3995,33 @@ public final EObject ruleSubscriber() throws RecognitionException { } - otherlv_4=(Token)match(input,43,FOLLOW_7); + otherlv_2=(Token)match(input,Colon,FOLLOW_5); + + newLeafNode(otherlv_2, grammarAccess.getActionServerAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_32); + + newLeafNode(this_BEGIN_3, grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_7); - newLeafNode(otherlv_4, grammarAccess.getSubscriberAccess().getMessageKeyword_4()); + newLeafNode(otherlv_4, grammarAccess.getActionServerAccess().getTypeKeyword_4()); - // InternalRos.g:2270:3: ( ( ruleEString ) ) - // InternalRos.g:2271:4: ( ruleEString ) + // InternalRosParser.g:1658:3: ( ( ruleEString ) ) + // InternalRosParser.g:1659:4: ( ruleEString ) { - // InternalRos.g:2271:4: ( ruleEString ) - // InternalRos.g:2272:5: ruleEString + // InternalRosParser.g:1659:4: ( ruleEString ) + // InternalRosParser.g:1660:5: ruleEString { if (current==null) { - current = createModelElement(grammarAccess.getSubscriberRule()); + current = createModelElement(grammarAccess.getActionServerRule()); } - newCompositeNode(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + newCompositeNode(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); - pushFollow(FOLLOW_43); + pushFollow(FOLLOW_33); ruleEString(); state._fsp--; @@ -5528,38 +4035,38 @@ public final EObject ruleSubscriber() throws RecognitionException { } - // InternalRos.g:2286:3: (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? - int alt54=2; - int LA54_0 = input.LA(1); + // InternalRosParser.g:1674:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt31=2; + int LA31_0 = input.LA(1); - if ( (LA54_0==59) ) { - alt54=1; + if ( (LA31_0==Ns) ) { + alt31=1; } - switch (alt54) { + switch (alt31) { case 1 : - // InternalRos.g:2287:4: otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRosParser.g:1675:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) { - otherlv_6=(Token)match(input,59,FOLLOW_44); + otherlv_6=(Token)match(input,Ns,FOLLOW_34); - newLeafNode(otherlv_6, grammarAccess.getSubscriberAccess().getNamespaceKeyword_6_0()); + newLeafNode(otherlv_6, grammarAccess.getActionServerAccess().getNsKeyword_6_0()); - // InternalRos.g:2291:4: ( (lv_namespace_7_0= ruleNamespace ) ) - // InternalRos.g:2292:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRosParser.g:1679:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRosParser.g:1680:5: (lv_namespace_7_0= ruleNamespace ) { - // InternalRos.g:2292:5: (lv_namespace_7_0= ruleNamespace ) - // InternalRos.g:2293:6: lv_namespace_7_0= ruleNamespace + // InternalRosParser.g:1680:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRosParser.g:1681:6: lv_namespace_7_0= ruleNamespace { - newCompositeNode(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + newCompositeNode(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); - pushFollow(FOLLOW_15); + pushFollow(FOLLOW_14); lv_namespace_7_0=ruleNamespace(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getSubscriberRule()); + current = createModelElementForParent(grammarAccess.getActionServerRule()); } set( current, @@ -5580,9 +4087,9 @@ public final EObject ruleSubscriber() throws RecognitionException { } - otherlv_8=(Token)match(input,28,FOLLOW_2); + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_8, grammarAccess.getSubscriberAccess().getRightCurlyBracketKeyword_7()); + newLeafNode(this_END_8, grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); } @@ -5603,28 +4110,28 @@ public final EObject ruleSubscriber() throws RecognitionException { } return current; } - // $ANTLR end "ruleSubscriber" + // $ANTLR end "ruleActionServer" - // $ANTLR start "entryRuleServiceClient" - // InternalRos.g:2319:1: entryRuleServiceClient returns [EObject current=null] : iv_ruleServiceClient= ruleServiceClient EOF ; - public final EObject entryRuleServiceClient() throws RecognitionException { + // $ANTLR start "entryRuleActionClient" + // InternalRosParser.g:1707:1: entryRuleActionClient returns [EObject current=null] : iv_ruleActionClient= ruleActionClient EOF ; + public final EObject entryRuleActionClient() throws RecognitionException { EObject current = null; - EObject iv_ruleServiceClient = null; + EObject iv_ruleActionClient = null; try { - // InternalRos.g:2319:54: (iv_ruleServiceClient= ruleServiceClient EOF ) - // InternalRos.g:2320:2: iv_ruleServiceClient= ruleServiceClient EOF + // InternalRosParser.g:1707:53: (iv_ruleActionClient= ruleActionClient EOF ) + // InternalRosParser.g:1708:2: iv_ruleActionClient= ruleActionClient EOF { - newCompositeNode(grammarAccess.getServiceClientRule()); + newCompositeNode(grammarAccess.getActionClientRule()); pushFollow(FOLLOW_1); - iv_ruleServiceClient=ruleServiceClient(); + iv_ruleActionClient=ruleActionClient(); state._fsp--; - current =iv_ruleServiceClient; + current =iv_ruleActionClient; match(input,EOF,FOLLOW_2); } @@ -5639,21 +4146,20 @@ public final EObject entryRuleServiceClient() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleServiceClient" + // $ANTLR end "entryRuleActionClient" - // $ANTLR start "ruleServiceClient" - // InternalRos.g:2326:1: ruleServiceClient returns [EObject current=null] : (otherlv_0= 'ServiceClient' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'service' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ; - public final EObject ruleServiceClient() throws RecognitionException { + // $ANTLR start "ruleActionClient" + // InternalRosParser.g:1714:1: ruleActionClient returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ; + public final EObject ruleActionClient() throws RecognitionException { EObject current = null; - Token otherlv_0=null; - Token otherlv_1=null; Token otherlv_2=null; + Token this_BEGIN_3=null; Token otherlv_4=null; Token otherlv_6=null; - Token otherlv_8=null; - AntlrDatatypeRuleToken lv_name_3_0 = null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; EObject lv_namespace_7_0 = null; @@ -5662,46 +4168,45 @@ public final EObject ruleServiceClient() throws RecognitionException { enterRule(); try { - // InternalRos.g:2332:2: ( (otherlv_0= 'ServiceClient' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'service' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ) - // InternalRos.g:2333:2: (otherlv_0= 'ServiceClient' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'service' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) + // InternalRosParser.g:1720:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRosParser.g:1721:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + { + // InternalRosParser.g:1721:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRosParser.g:1722:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END { - // InternalRos.g:2333:2: (otherlv_0= 'ServiceClient' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'service' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) - // InternalRos.g:2334:3: otherlv_0= 'ServiceClient' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'service' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' + // InternalRosParser.g:1722:3: () + // InternalRosParser.g:1723:4: { - otherlv_0=(Token)match(input,62,FOLLOW_3); - newLeafNode(otherlv_0, grammarAccess.getServiceClientAccess().getServiceClientKeyword_0()); - - otherlv_1=(Token)match(input,26,FOLLOW_27); + current = forceCreateModelElement( + grammarAccess.getActionClientAccess().getActionClientAction_0(), + current); + - newLeafNode(otherlv_1, grammarAccess.getServiceClientAccess().getLeftCurlyBracketKeyword_1()); - - otherlv_2=(Token)match(input,49,FOLLOW_7); + } - newLeafNode(otherlv_2, grammarAccess.getServiceClientAccess().getNameKeyword_2()); - - // InternalRos.g:2346:3: ( (lv_name_3_0= ruleEString ) ) - // InternalRos.g:2347:4: (lv_name_3_0= ruleEString ) + // InternalRosParser.g:1729:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRosParser.g:1730:4: (lv_name_1_0= ruleEString ) { - // InternalRos.g:2347:4: (lv_name_3_0= ruleEString ) - // InternalRos.g:2348:5: lv_name_3_0= ruleEString + // InternalRosParser.g:1730:4: (lv_name_1_0= ruleEString ) + // InternalRosParser.g:1731:5: lv_name_1_0= ruleEString { - newCompositeNode(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_3_0()); + newCompositeNode(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); - pushFollow(FOLLOW_42); - lv_name_3_0=ruleEString(); + pushFollow(FOLLOW_4); + lv_name_1_0=ruleEString(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getServiceClientRule()); + current = createModelElementForParent(grammarAccess.getActionClientRule()); } set( current, "name", - lv_name_3_0, + lv_name_1_0, "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); @@ -5711,25 +4216,33 @@ public final EObject ruleServiceClient() throws RecognitionException { } - otherlv_4=(Token)match(input,58,FOLLOW_7); + otherlv_2=(Token)match(input,Colon,FOLLOW_5); + + newLeafNode(otherlv_2, grammarAccess.getActionClientAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_32); + + newLeafNode(this_BEGIN_3, grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_7); - newLeafNode(otherlv_4, grammarAccess.getServiceClientAccess().getServiceKeyword_4()); + newLeafNode(otherlv_4, grammarAccess.getActionClientAccess().getTypeKeyword_4()); - // InternalRos.g:2369:3: ( ( ruleEString ) ) - // InternalRos.g:2370:4: ( ruleEString ) + // InternalRosParser.g:1760:3: ( ( ruleEString ) ) + // InternalRosParser.g:1761:4: ( ruleEString ) { - // InternalRos.g:2370:4: ( ruleEString ) - // InternalRos.g:2371:5: ruleEString + // InternalRosParser.g:1761:4: ( ruleEString ) + // InternalRosParser.g:1762:5: ruleEString { if (current==null) { - current = createModelElement(grammarAccess.getServiceClientRule()); + current = createModelElement(grammarAccess.getActionClientRule()); } - newCompositeNode(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); + newCompositeNode(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); - pushFollow(FOLLOW_43); + pushFollow(FOLLOW_33); ruleEString(); state._fsp--; @@ -5743,38 +4256,38 @@ public final EObject ruleServiceClient() throws RecognitionException { } - // InternalRos.g:2385:3: (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? - int alt55=2; - int LA55_0 = input.LA(1); + // InternalRosParser.g:1776:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt32=2; + int LA32_0 = input.LA(1); - if ( (LA55_0==59) ) { - alt55=1; + if ( (LA32_0==Ns) ) { + alt32=1; } - switch (alt55) { + switch (alt32) { case 1 : - // InternalRos.g:2386:4: otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRosParser.g:1777:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) { - otherlv_6=(Token)match(input,59,FOLLOW_44); + otherlv_6=(Token)match(input,Ns,FOLLOW_34); - newLeafNode(otherlv_6, grammarAccess.getServiceClientAccess().getNamespaceKeyword_6_0()); + newLeafNode(otherlv_6, grammarAccess.getActionClientAccess().getNsKeyword_6_0()); - // InternalRos.g:2390:4: ( (lv_namespace_7_0= ruleNamespace ) ) - // InternalRos.g:2391:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRosParser.g:1781:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRosParser.g:1782:5: (lv_namespace_7_0= ruleNamespace ) { - // InternalRos.g:2391:5: (lv_namespace_7_0= ruleNamespace ) - // InternalRos.g:2392:6: lv_namespace_7_0= ruleNamespace + // InternalRosParser.g:1782:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRosParser.g:1783:6: lv_namespace_7_0= ruleNamespace { - newCompositeNode(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + newCompositeNode(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); - pushFollow(FOLLOW_15); + pushFollow(FOLLOW_14); lv_namespace_7_0=ruleNamespace(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getServiceClientRule()); + current = createModelElementForParent(grammarAccess.getActionClientRule()); } set( current, @@ -5795,9 +4308,9 @@ public final EObject ruleServiceClient() throws RecognitionException { } - otherlv_8=(Token)match(input,28,FOLLOW_2); + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_8, grammarAccess.getServiceClientAccess().getRightCurlyBracketKeyword_7()); + newLeafNode(this_END_8, grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); } @@ -5818,28 +4331,28 @@ public final EObject ruleServiceClient() throws RecognitionException { } return current; } - // $ANTLR end "ruleServiceClient" + // $ANTLR end "ruleActionClient" - // $ANTLR start "entryRuleActionServer" - // InternalRos.g:2418:1: entryRuleActionServer returns [EObject current=null] : iv_ruleActionServer= ruleActionServer EOF ; - public final EObject entryRuleActionServer() throws RecognitionException { + // $ANTLR start "entryRuleDependency" + // InternalRosParser.g:1809:1: entryRuleDependency returns [EObject current=null] : iv_ruleDependency= ruleDependency EOF ; + public final EObject entryRuleDependency() throws RecognitionException { EObject current = null; - EObject iv_ruleActionServer = null; + EObject iv_ruleDependency = null; try { - // InternalRos.g:2418:53: (iv_ruleActionServer= ruleActionServer EOF ) - // InternalRos.g:2419:2: iv_ruleActionServer= ruleActionServer EOF + // InternalRosParser.g:1809:51: (iv_ruleDependency= ruleDependency EOF ) + // InternalRosParser.g:1810:2: iv_ruleDependency= ruleDependency EOF { - newCompositeNode(grammarAccess.getActionServerRule()); + newCompositeNode(grammarAccess.getDependencyRule()); pushFollow(FOLLOW_1); - iv_ruleActionServer=ruleActionServer(); + iv_ruleDependency=ruleDependency(); state._fsp--; - current =iv_ruleActionServer; + current =iv_ruleDependency; match(input,EOF,FOLLOW_2); } @@ -5854,166 +4367,174 @@ public final EObject entryRuleActionServer() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleActionServer" + // $ANTLR end "entryRuleDependency" - // $ANTLR start "ruleActionServer" - // InternalRos.g:2425:1: ruleActionServer returns [EObject current=null] : (otherlv_0= 'ActionServer' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'action' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ; - public final EObject ruleActionServer() throws RecognitionException { + // $ANTLR start "ruleDependency" + // InternalRosParser.g:1816:1: ruleDependency returns [EObject current=null] : (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) ; + public final EObject ruleDependency() throws RecognitionException { EObject current = null; - Token otherlv_0=null; - Token otherlv_1=null; - Token otherlv_2=null; - Token otherlv_4=null; - Token otherlv_6=null; - Token otherlv_8=null; - AntlrDatatypeRuleToken lv_name_3_0 = null; + EObject this_PackageDependency_0 = null; - EObject lv_namespace_7_0 = null; + EObject this_ExternalDependency_1 = null; enterRule(); try { - // InternalRos.g:2431:2: ( (otherlv_0= 'ActionServer' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'action' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ) - // InternalRos.g:2432:2: (otherlv_0= 'ActionServer' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'action' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) + // InternalRosParser.g:1822:2: ( (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) ) + // InternalRosParser.g:1823:2: (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) { - // InternalRos.g:2432:2: (otherlv_0= 'ActionServer' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'action' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) - // InternalRos.g:2433:3: otherlv_0= 'ActionServer' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'action' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' - { - otherlv_0=(Token)match(input,63,FOLLOW_3); + // InternalRosParser.g:1823:2: (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) + int alt33=2; + int LA33_0 = input.LA(1); - newLeafNode(otherlv_0, grammarAccess.getActionServerAccess().getActionServerKeyword_0()); - - otherlv_1=(Token)match(input,26,FOLLOW_27); + if ( (LA33_0==RULE_ID||LA33_0==RULE_STRING) ) { + alt33=1; + } + else if ( (LA33_0==ExternalDependency) ) { + alt33=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 33, 0, input); - newLeafNode(otherlv_1, grammarAccess.getActionServerAccess().getLeftCurlyBracketKeyword_1()); - - otherlv_2=(Token)match(input,49,FOLLOW_7); + throw nvae; + } + switch (alt33) { + case 1 : + // InternalRosParser.g:1824:3: this_PackageDependency_0= rulePackageDependency + { - newLeafNode(otherlv_2, grammarAccess.getActionServerAccess().getNameKeyword_2()); - - // InternalRos.g:2445:3: ( (lv_name_3_0= ruleEString ) ) - // InternalRos.g:2446:4: (lv_name_3_0= ruleEString ) - { - // InternalRos.g:2446:4: (lv_name_3_0= ruleEString ) - // InternalRos.g:2447:5: lv_name_3_0= ruleEString - { + newCompositeNode(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_PackageDependency_0=rulePackageDependency(); - newCompositeNode(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_3_0()); - - pushFollow(FOLLOW_46); - lv_name_3_0=ruleEString(); + state._fsp--; - state._fsp--; + current = this_PackageDependency_0; + afterParserOrEnumRuleCall(); + - if (current==null) { - current = createModelElementForParent(grammarAccess.getActionServerRule()); - } - set( - current, - "name", - lv_name_3_0, - "de.fraunhofer.ipa.ros.Ros.EString"); - afterParserOrEnumRuleCall(); - + } + break; + case 2 : + // InternalRosParser.g:1833: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; } } - otherlv_4=(Token)match(input,64,FOLLOW_7); - newLeafNode(otherlv_4, grammarAccess.getActionServerAccess().getActionKeyword_4()); - - // InternalRos.g:2468:3: ( ( ruleEString ) ) - // InternalRos.g:2469:4: ( ruleEString ) - { - // InternalRos.g:2469:4: ( ruleEString ) - // InternalRos.g:2470:5: ruleEString - { + leaveRule(); - if (current==null) { - current = createModelElement(grammarAccess.getActionServerRule()); - } - + } - newCompositeNode(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); - - pushFollow(FOLLOW_43); - ruleEString(); + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleDependency" - state._fsp--; + // $ANTLR start "entryRulePackageDependency" + // InternalRosParser.g:1845:1: entryRulePackageDependency returns [EObject current=null] : iv_rulePackageDependency= rulePackageDependency EOF ; + public final EObject entryRulePackageDependency() throws RecognitionException { + EObject current = null; - afterParserOrEnumRuleCall(); - + EObject iv_rulePackageDependency = null; - } + try { + // InternalRosParser.g:1845:58: (iv_rulePackageDependency= rulePackageDependency EOF ) + // InternalRosParser.g:1846:2: iv_rulePackageDependency= rulePackageDependency EOF + { + newCompositeNode(grammarAccess.getPackageDependencyRule()); + pushFollow(FOLLOW_1); + iv_rulePackageDependency=rulePackageDependency(); - } + state._fsp--; - // InternalRos.g:2484:3: (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? - int alt56=2; - int LA56_0 = input.LA(1); + current =iv_rulePackageDependency; + match(input,EOF,FOLLOW_2); - if ( (LA56_0==59) ) { - alt56=1; } - switch (alt56) { - case 1 : - // InternalRos.g:2485:4: otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) - { - otherlv_6=(Token)match(input,59,FOLLOW_44); - newLeafNode(otherlv_6, grammarAccess.getActionServerAccess().getNamespaceKeyword_6_0()); - - // InternalRos.g:2489:4: ( (lv_namespace_7_0= ruleNamespace ) ) - // InternalRos.g:2490:5: (lv_namespace_7_0= ruleNamespace ) - { - // InternalRos.g:2490:5: (lv_namespace_7_0= ruleNamespace ) - // InternalRos.g:2491:6: lv_namespace_7_0= ruleNamespace - { + } - newCompositeNode(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); - - pushFollow(FOLLOW_15); - lv_namespace_7_0=ruleNamespace(); + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePackageDependency" - state._fsp--; + // $ANTLR start "rulePackageDependency" + // InternalRosParser.g:1852:1: rulePackageDependency returns [EObject current=null] : ( ( ruleEString ) ) ; + public final EObject rulePackageDependency() throws RecognitionException { + EObject current = null; - if (current==null) { - current = createModelElementForParent(grammarAccess.getActionServerRule()); - } - set( - current, - "namespace", - lv_namespace_7_0, - "de.fraunhofer.ipa.ros.Ros.Namespace"); - afterParserOrEnumRuleCall(); - - } + enterRule(); + try { + // InternalRosParser.g:1858:2: ( ( ( ruleEString ) ) ) + // InternalRosParser.g:1859:2: ( ( ruleEString ) ) + { + // InternalRosParser.g:1859:2: ( ( ruleEString ) ) + // InternalRosParser.g:1860:3: ( ruleEString ) + { + // InternalRosParser.g:1860:3: ( ruleEString ) + // InternalRosParser.g:1861:4: ruleEString + { - } + if (current==null) { + current = createModelElement(grammarAccess.getPackageDependencyRule()); + } + + newCompositeNode(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); + + pushFollow(FOLLOW_2); + ruleEString(); - } - break; + state._fsp--; - } - otherlv_8=(Token)match(input,28,FOLLOW_2); + afterParserOrEnumRuleCall(); + + + } - newLeafNode(otherlv_8, grammarAccess.getActionServerAccess().getRightCurlyBracketKeyword_7()); - } @@ -6033,28 +4554,28 @@ public final EObject ruleActionServer() throws RecognitionException { } return current; } - // $ANTLR end "ruleActionServer" + // $ANTLR end "rulePackageDependency" - // $ANTLR start "entryRuleActionClient" - // InternalRos.g:2517:1: entryRuleActionClient returns [EObject current=null] : iv_ruleActionClient= ruleActionClient EOF ; - public final EObject entryRuleActionClient() throws RecognitionException { + // $ANTLR start "entryRuleExternalDependency" + // InternalRosParser.g:1878:1: entryRuleExternalDependency returns [EObject current=null] : iv_ruleExternalDependency= ruleExternalDependency EOF ; + public final EObject entryRuleExternalDependency() throws RecognitionException { EObject current = null; - EObject iv_ruleActionClient = null; + EObject iv_ruleExternalDependency = null; try { - // InternalRos.g:2517:53: (iv_ruleActionClient= ruleActionClient EOF ) - // InternalRos.g:2518:2: iv_ruleActionClient= ruleActionClient EOF + // InternalRosParser.g:1878:59: (iv_ruleExternalDependency= ruleExternalDependency EOF ) + // InternalRosParser.g:1879:2: iv_ruleExternalDependency= ruleExternalDependency EOF { - newCompositeNode(grammarAccess.getActionClientRule()); + newCompositeNode(grammarAccess.getExternalDependencyRule()); pushFollow(FOLLOW_1); - iv_ruleActionClient=ruleActionClient(); + iv_ruleExternalDependency=ruleExternalDependency(); state._fsp--; - current =iv_ruleActionClient; + current =iv_ruleExternalDependency; match(input,EOF,FOLLOW_2); } @@ -6069,69 +4590,65 @@ public final EObject entryRuleActionClient() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleActionClient" + // $ANTLR end "entryRuleExternalDependency" - // $ANTLR start "ruleActionClient" - // InternalRos.g:2524:1: ruleActionClient returns [EObject current=null] : (otherlv_0= 'ActionClient' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'action' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ; - public final EObject ruleActionClient() throws RecognitionException { + // $ANTLR start "ruleExternalDependency" + // InternalRosParser.g:1885: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_0=null; Token otherlv_1=null; - Token otherlv_2=null; - Token otherlv_4=null; - Token otherlv_6=null; - Token otherlv_8=null; - AntlrDatatypeRuleToken lv_name_3_0 = null; - - EObject lv_namespace_7_0 = null; + AntlrDatatypeRuleToken lv_name_2_0 = null; enterRule(); try { - // InternalRos.g:2530:2: ( (otherlv_0= 'ActionClient' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'action' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) ) - // InternalRos.g:2531:2: (otherlv_0= 'ActionClient' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'action' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) + // InternalRosParser.g:1891:2: ( ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) ) + // InternalRosParser.g:1892:2: ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) { - // InternalRos.g:2531:2: (otherlv_0= 'ActionClient' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'action' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' ) - // InternalRos.g:2532:3: otherlv_0= 'ActionClient' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) otherlv_4= 'action' ( ( ruleEString ) ) (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? otherlv_8= '}' + // InternalRosParser.g:1892:2: ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) + // InternalRosParser.g:1893:3: () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) + { + // InternalRosParser.g:1893:3: () + // InternalRosParser.g:1894:4: { - otherlv_0=(Token)match(input,65,FOLLOW_3); - newLeafNode(otherlv_0, grammarAccess.getActionClientAccess().getActionClientKeyword_0()); - - otherlv_1=(Token)match(input,26,FOLLOW_27); + current = forceCreateModelElement( + grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0(), + current); + - newLeafNode(otherlv_1, grammarAccess.getActionClientAccess().getLeftCurlyBracketKeyword_1()); - - otherlv_2=(Token)match(input,49,FOLLOW_7); + } - newLeafNode(otherlv_2, grammarAccess.getActionClientAccess().getNameKeyword_2()); + otherlv_1=(Token)match(input,ExternalDependency,FOLLOW_7); + + newLeafNode(otherlv_1, grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); - // InternalRos.g:2544:3: ( (lv_name_3_0= ruleEString ) ) - // InternalRos.g:2545:4: (lv_name_3_0= ruleEString ) + // InternalRosParser.g:1904:3: ( (lv_name_2_0= ruleEString ) ) + // InternalRosParser.g:1905:4: (lv_name_2_0= ruleEString ) { - // InternalRos.g:2545:4: (lv_name_3_0= ruleEString ) - // InternalRos.g:2546:5: lv_name_3_0= ruleEString + // InternalRosParser.g:1905:4: (lv_name_2_0= ruleEString ) + // InternalRosParser.g:1906:5: lv_name_2_0= ruleEString { - newCompositeNode(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_3_0()); + newCompositeNode(grammarAccess.getExternalDependencyAccess().getNameEStringParserRuleCall_2_0()); - pushFollow(FOLLOW_46); - lv_name_3_0=ruleEString(); + pushFollow(FOLLOW_2); + lv_name_2_0=ruleEString(); state._fsp--; if (current==null) { - current = createModelElementForParent(grammarAccess.getActionClientRule()); + current = createModelElementForParent(grammarAccess.getExternalDependencyRule()); } set( current, "name", - lv_name_3_0, + lv_name_2_0, "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); @@ -6141,94 +4658,6 @@ public final EObject ruleActionClient() throws RecognitionException { } - otherlv_4=(Token)match(input,64,FOLLOW_7); - - newLeafNode(otherlv_4, grammarAccess.getActionClientAccess().getActionKeyword_4()); - - // InternalRos.g:2567:3: ( ( ruleEString ) ) - // InternalRos.g:2568:4: ( ruleEString ) - { - // InternalRos.g:2568:4: ( ruleEString ) - // InternalRos.g:2569:5: ruleEString - { - - if (current==null) { - current = createModelElement(grammarAccess.getActionClientRule()); - } - - - newCompositeNode(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); - - pushFollow(FOLLOW_43); - ruleEString(); - - state._fsp--; - - - afterParserOrEnumRuleCall(); - - - } - - - } - - // InternalRos.g:2583:3: (otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) )? - int alt57=2; - int LA57_0 = input.LA(1); - - if ( (LA57_0==59) ) { - alt57=1; - } - switch (alt57) { - case 1 : - // InternalRos.g:2584:4: otherlv_6= 'namespace' ( (lv_namespace_7_0= ruleNamespace ) ) - { - otherlv_6=(Token)match(input,59,FOLLOW_44); - - newLeafNode(otherlv_6, grammarAccess.getActionClientAccess().getNamespaceKeyword_6_0()); - - // InternalRos.g:2588:4: ( (lv_namespace_7_0= ruleNamespace ) ) - // InternalRos.g:2589:5: (lv_namespace_7_0= ruleNamespace ) - { - // InternalRos.g:2589:5: (lv_namespace_7_0= ruleNamespace ) - // InternalRos.g:2590:6: lv_namespace_7_0= ruleNamespace - { - - newCompositeNode(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); - - pushFollow(FOLLOW_15); - lv_namespace_7_0=ruleNamespace(); - - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getActionClientRule()); - } - set( - current, - "namespace", - lv_namespace_7_0, - "de.fraunhofer.ipa.ros.Ros.Namespace"); - afterParserOrEnumRuleCall(); - - - } - - - } - - - } - break; - - } - - otherlv_8=(Token)match(input,28,FOLLOW_2); - - newLeafNode(otherlv_8, grammarAccess.getActionClientAccess().getRightCurlyBracketKeyword_7()); - } @@ -6248,28 +4677,28 @@ public final EObject ruleActionClient() throws RecognitionException { } return current; } - // $ANTLR end "ruleActionClient" + // $ANTLR end "ruleExternalDependency" - // $ANTLR start "entryRuleGraphName" - // InternalRos.g:2616:1: entryRuleGraphName returns [String current=null] : iv_ruleGraphName= ruleGraphName EOF ; - public final String entryRuleGraphName() throws RecognitionException { - String current = null; + // $ANTLR start "entryRuleNamespace" + // InternalRosParser.g:1927:1: entryRuleNamespace returns [EObject current=null] : iv_ruleNamespace= ruleNamespace EOF ; + public final EObject entryRuleNamespace() throws RecognitionException { + EObject current = null; - AntlrDatatypeRuleToken iv_ruleGraphName = null; + EObject iv_ruleNamespace = null; try { - // InternalRos.g:2616:49: (iv_ruleGraphName= ruleGraphName EOF ) - // InternalRos.g:2617:2: iv_ruleGraphName= ruleGraphName EOF + // InternalRosParser.g:1927:50: (iv_ruleNamespace= ruleNamespace EOF ) + // InternalRosParser.g:1928:2: iv_ruleNamespace= ruleNamespace EOF { - newCompositeNode(grammarAccess.getGraphNameRule()); + newCompositeNode(grammarAccess.getNamespaceRule()); pushFollow(FOLLOW_1); - iv_ruleGraphName=ruleGraphName(); + iv_ruleNamespace=ruleNamespace(); state._fsp--; - current =iv_ruleGraphName.getText(); + current =iv_ruleNamespace; match(input,EOF,FOLLOW_2); } @@ -6284,120 +4713,108 @@ public final String entryRuleGraphName() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleGraphName" - - - // $ANTLR start "ruleGraphName" - // InternalRos.g:2623:1: ruleGraphName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= 'GraphName' ; - public final AntlrDatatypeRuleToken ruleGraphName() throws RecognitionException { - AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); - - Token kw=null; - - - enterRule(); - - try { - // InternalRos.g:2629:2: (kw= 'GraphName' ) - // InternalRos.g:2630:2: kw= 'GraphName' - { - kw=(Token)match(input,66,FOLLOW_2); - - current.merge(kw); - newLeafNode(kw, grammarAccess.getGraphNameAccess().getGraphNameKeyword()); - - - } + // $ANTLR end "entryRuleNamespace" - leaveRule(); + // $ANTLR start "ruleNamespace" + // InternalRosParser.g:1934:1: ruleNamespace returns [EObject current=null] : (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) ; + public final EObject ruleNamespace() throws RecognitionException { + EObject current = null; - } + EObject this_GlobalNamespace_0 = null; - catch (RecognitionException re) { - recover(input,re); - appendSkippedTokens(); - } - finally { - } - return current; - } - // $ANTLR end "ruleGraphName" + EObject this_RelativeNamespace_Impl_1 = null; + EObject this_PrivateNamespace_2 = null; - // $ANTLR start "entryRulePackageDependency" - // InternalRos.g:2638:1: entryRulePackageDependency returns [EObject current=null] : iv_rulePackageDependency= rulePackageDependency EOF ; - public final EObject entryRulePackageDependency() throws RecognitionException { - EObject current = null; - EObject iv_rulePackageDependency = null; + enterRule(); try { - // InternalRos.g:2638:58: (iv_rulePackageDependency= rulePackageDependency EOF ) - // InternalRos.g:2639:2: iv_rulePackageDependency= rulePackageDependency EOF + // InternalRosParser.g:1940:2: ( (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) ) + // InternalRosParser.g:1941:2: (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) { - newCompositeNode(grammarAccess.getPackageDependencyRule()); - pushFollow(FOLLOW_1); - iv_rulePackageDependency=rulePackageDependency(); - - state._fsp--; - - current =iv_rulePackageDependency; - match(input,EOF,FOLLOW_2); + // InternalRosParser.g:1941:2: (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) + int alt34=3; + switch ( input.LA(1) ) { + case GlobalNamespace: + { + alt34=1; + } + break; + case RelativeNamespace: + { + alt34=2; + } + break; + case PrivateNamespace: + { + alt34=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 34, 0, input); + throw nvae; } - } + switch (alt34) { + case 1 : + // InternalRosParser.g:1942:3: this_GlobalNamespace_0= ruleGlobalNamespace + { - catch (RecognitionException re) { - recover(input,re); - appendSkippedTokens(); - } - finally { - } - return current; - } - // $ANTLR end "entryRulePackageDependency" + newCompositeNode(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_GlobalNamespace_0=ruleGlobalNamespace(); + state._fsp--; - // $ANTLR start "rulePackageDependency" - // InternalRos.g:2645:1: rulePackageDependency returns [EObject current=null] : ( ( ruleEString ) ) ; - public final EObject rulePackageDependency() throws RecognitionException { - EObject current = null; + current = this_GlobalNamespace_0; + afterParserOrEnumRuleCall(); + - enterRule(); + } + break; + case 2 : + // InternalRosParser.g:1951:3: this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl + { - try { - // InternalRos.g:2651:2: ( ( ( ruleEString ) ) ) - // InternalRos.g:2652:2: ( ( ruleEString ) ) - { - // InternalRos.g:2652:2: ( ( ruleEString ) ) - // InternalRos.g:2653:3: ( ruleEString ) - { - // InternalRos.g:2653:3: ( ruleEString ) - // InternalRos.g:2654:4: ruleEString - { + newCompositeNode(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_RelativeNamespace_Impl_1=ruleRelativeNamespace_Impl(); - if (current==null) { - current = createModelElement(grammarAccess.getPackageDependencyRule()); - } - + state._fsp--; - newCompositeNode(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); - - pushFollow(FOLLOW_2); - ruleEString(); - state._fsp--; + current = this_RelativeNamespace_Impl_1; + afterParserOrEnumRuleCall(); + + } + break; + case 3 : + // InternalRosParser.g:1960:3: this_PrivateNamespace_2= rulePrivateNamespace + { - afterParserOrEnumRuleCall(); - + newCompositeNode(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_PrivateNamespace_2=rulePrivateNamespace(); - } + state._fsp--; + + + current = this_PrivateNamespace_2; + afterParserOrEnumRuleCall(); + + } + break; } @@ -6417,28 +4834,28 @@ public final EObject rulePackageDependency() throws RecognitionException { } return current; } - // $ANTLR end "rulePackageDependency" + // $ANTLR end "ruleNamespace" - // $ANTLR start "entryRuleExternalDependency" - // InternalRos.g:2671:1: entryRuleExternalDependency returns [EObject current=null] : iv_ruleExternalDependency= ruleExternalDependency EOF ; - public final EObject entryRuleExternalDependency() throws RecognitionException { - EObject current = null; + // $ANTLR start "entryRuleGraphName" + // InternalRosParser.g:1972:1: entryRuleGraphName returns [String current=null] : iv_ruleGraphName= ruleGraphName EOF ; + public final String entryRuleGraphName() throws RecognitionException { + String current = null; - EObject iv_ruleExternalDependency = null; + AntlrDatatypeRuleToken iv_ruleGraphName = null; try { - // InternalRos.g:2671:59: (iv_ruleExternalDependency= ruleExternalDependency EOF ) - // InternalRos.g:2672:2: iv_ruleExternalDependency= ruleExternalDependency EOF + // InternalRosParser.g:1972:49: (iv_ruleGraphName= ruleGraphName EOF ) + // InternalRosParser.g:1973:2: iv_ruleGraphName= ruleGraphName EOF { - newCompositeNode(grammarAccess.getExternalDependencyRule()); + newCompositeNode(grammarAccess.getGraphNameRule()); pushFollow(FOLLOW_1); - iv_ruleExternalDependency=ruleExternalDependency(); + iv_ruleGraphName=ruleGraphName(); state._fsp--; - current =iv_ruleExternalDependency; + current =iv_ruleGraphName.getText(); match(input,EOF,FOLLOW_2); } @@ -6453,77 +4870,28 @@ public final EObject entryRuleExternalDependency() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleExternalDependency" - + // $ANTLR end "entryRuleGraphName" - // $ANTLR start "ruleExternalDependency" - // InternalRos.g:2678: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; + // $ANTLR start "ruleGraphName" + // InternalRosParser.g:1979:1: ruleGraphName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= GraphName ; + public final AntlrDatatypeRuleToken ruleGraphName() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + Token kw=null; enterRule(); try { - // InternalRos.g:2684:2: ( ( () otherlv_1= 'ExternalDependency' ( (lv_name_2_0= ruleEString ) ) ) ) - // InternalRos.g:2685:2: ( () otherlv_1= 'ExternalDependency' ( (lv_name_2_0= ruleEString ) ) ) - { - // InternalRos.g:2685:2: ( () otherlv_1= 'ExternalDependency' ( (lv_name_2_0= ruleEString ) ) ) - // InternalRos.g:2686:3: () otherlv_1= 'ExternalDependency' ( (lv_name_2_0= ruleEString ) ) - { - // InternalRos.g:2686:3: () - // InternalRos.g:2687:4: - { - - current = forceCreateModelElement( - grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0(), - current); - - - } - - otherlv_1=(Token)match(input,67,FOLLOW_7); - - newLeafNode(otherlv_1, grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); - - // InternalRos.g:2697:3: ( (lv_name_2_0= ruleEString ) ) - // InternalRos.g:2698:4: (lv_name_2_0= ruleEString ) + // InternalRosParser.g:1985:2: (kw= GraphName ) + // InternalRosParser.g:1986:2: kw= GraphName { - // InternalRos.g:2698:4: (lv_name_2_0= ruleEString ) - // InternalRos.g:2699: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.ros.Ros.EString"); - afterParserOrEnumRuleCall(); - - - } - - - } - - - } + kw=(Token)match(input,GraphName,FOLLOW_2); + current.merge(kw); + newLeafNode(kw, grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + } @@ -6540,11 +4908,11 @@ public final EObject ruleExternalDependency() throws RecognitionException { } return current; } - // $ANTLR end "ruleExternalDependency" + // $ANTLR end "ruleGraphName" // $ANTLR start "entryRuleGlobalNamespace" - // InternalRos.g:2720:1: entryRuleGlobalNamespace returns [EObject current=null] : iv_ruleGlobalNamespace= ruleGlobalNamespace EOF ; + // InternalRosParser.g:1994:1: entryRuleGlobalNamespace returns [EObject current=null] : iv_ruleGlobalNamespace= ruleGlobalNamespace EOF ; public final EObject entryRuleGlobalNamespace() throws RecognitionException { EObject current = null; @@ -6552,8 +4920,8 @@ public final EObject entryRuleGlobalNamespace() throws RecognitionException { try { - // InternalRos.g:2720:56: (iv_ruleGlobalNamespace= ruleGlobalNamespace EOF ) - // InternalRos.g:2721:2: iv_ruleGlobalNamespace= ruleGlobalNamespace EOF + // InternalRosParser.g:1994:56: (iv_ruleGlobalNamespace= ruleGlobalNamespace EOF ) + // InternalRosParser.g:1995:2: iv_ruleGlobalNamespace= ruleGlobalNamespace EOF { newCompositeNode(grammarAccess.getGlobalNamespaceRule()); pushFollow(FOLLOW_1); @@ -6580,34 +4948,31 @@ public final EObject entryRuleGlobalNamespace() throws RecognitionException { // $ANTLR start "ruleGlobalNamespace" - // InternalRos.g:2727:1: ruleGlobalNamespace returns [EObject current=null] : ( () otherlv_1= 'GlobalNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) ; + // InternalRosParser.g:2001:1: ruleGlobalNamespace returns [EObject current=null] : ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ; public final EObject ruleGlobalNamespace() throws RecognitionException { EObject current = null; Token otherlv_1=null; Token otherlv_2=null; - Token otherlv_3=null; Token otherlv_4=null; Token otherlv_6=null; - Token otherlv_8=null; - Token otherlv_9=null; - AntlrDatatypeRuleToken lv_parts_5_0 = null; + AntlrDatatypeRuleToken lv_parts_3_0 = null; - AntlrDatatypeRuleToken lv_parts_7_0 = null; + AntlrDatatypeRuleToken lv_parts_5_0 = null; enterRule(); try { - // InternalRos.g:2733:2: ( ( () otherlv_1= 'GlobalNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) ) - // InternalRos.g:2734:2: ( () otherlv_1= 'GlobalNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) + // InternalRosParser.g:2007:2: ( ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ) + // InternalRosParser.g:2008:2: ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) { - // InternalRos.g:2734:2: ( () otherlv_1= 'GlobalNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) - // InternalRos.g:2735:3: () otherlv_1= 'GlobalNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' + // InternalRosParser.g:2008:2: ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + // InternalRosParser.g:2009:3: () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? { - // InternalRos.g:2735:3: () - // InternalRos.g:2736:4: + // InternalRosParser.g:2009:3: () + // InternalRosParser.g:2010:4: { current = forceCreateModelElement( @@ -6617,44 +4982,36 @@ public final EObject ruleGlobalNamespace() throws RecognitionException { } - otherlv_1=(Token)match(input,68,FOLLOW_3); + otherlv_1=(Token)match(input,GlobalNamespace,FOLLOW_35); newLeafNode(otherlv_1, grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); - otherlv_2=(Token)match(input,26,FOLLOW_47); + // InternalRosParser.g:2020:3: (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + int alt36=2; + int LA36_0 = input.LA(1); - newLeafNode(otherlv_2, grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_2()); - - // InternalRos.g:2750:3: (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? - int alt59=2; - int LA59_0 = input.LA(1); - - if ( (LA59_0==69) ) { - alt59=1; + if ( (LA36_0==LeftSquareBracket) ) { + alt36=1; } - switch (alt59) { + switch (alt36) { case 1 : - // InternalRos.g:2751:4: otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' + // InternalRosParser.g:2021:4: otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket { - otherlv_3=(Token)match(input,69,FOLLOW_3); - - newLeafNode(otherlv_3, grammarAccess.getGlobalNamespaceAccess().getPartsKeyword_3_0()); - - otherlv_4=(Token)match(input,26,FOLLOW_48); + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_36); - newLeafNode(otherlv_4, grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); + newLeafNode(otherlv_2, grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); - // InternalRos.g:2759:4: ( (lv_parts_5_0= ruleGraphName ) ) - // InternalRos.g:2760:5: (lv_parts_5_0= ruleGraphName ) + // InternalRosParser.g:2025:4: ( (lv_parts_3_0= ruleGraphName ) ) + // InternalRosParser.g:2026:5: (lv_parts_3_0= ruleGraphName ) { - // InternalRos.g:2760:5: (lv_parts_5_0= ruleGraphName ) - // InternalRos.g:2761:6: lv_parts_5_0= ruleGraphName + // InternalRosParser.g:2026:5: (lv_parts_3_0= ruleGraphName ) + // InternalRosParser.g:2027:6: lv_parts_3_0= ruleGraphName { - newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); - pushFollow(FOLLOW_5); - lv_parts_5_0=ruleGraphName(); + pushFollow(FOLLOW_13); + lv_parts_3_0=ruleGraphName(); state._fsp--; @@ -6665,7 +5022,7 @@ public final EObject ruleGlobalNamespace() throws RecognitionException { add( current, "parts", - lv_parts_5_0, + lv_parts_3_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); @@ -6675,36 +5032,36 @@ public final EObject ruleGlobalNamespace() throws RecognitionException { } - // InternalRos.g:2778:4: (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* - loop58: + // InternalRosParser.g:2044:4: (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* + loop35: do { - int alt58=2; - int LA58_0 = input.LA(1); + int alt35=2; + int LA35_0 = input.LA(1); - if ( (LA58_0==27) ) { - alt58=1; + if ( (LA35_0==Comma) ) { + alt35=1; } - switch (alt58) { + switch (alt35) { case 1 : - // InternalRos.g:2779:5: otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) + // InternalRosParser.g:2045:5: otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) { - otherlv_6=(Token)match(input,27,FOLLOW_48); + otherlv_4=(Token)match(input,Comma,FOLLOW_36); - newLeafNode(otherlv_6, grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_3_3_0()); + newLeafNode(otherlv_4, grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); - // InternalRos.g:2783:5: ( (lv_parts_7_0= ruleGraphName ) ) - // InternalRos.g:2784:6: (lv_parts_7_0= ruleGraphName ) + // InternalRosParser.g:2049:5: ( (lv_parts_5_0= ruleGraphName ) ) + // InternalRosParser.g:2050:6: (lv_parts_5_0= ruleGraphName ) { - // InternalRos.g:2784:6: (lv_parts_7_0= ruleGraphName ) - // InternalRos.g:2785:7: lv_parts_7_0= ruleGraphName + // InternalRosParser.g:2050:6: (lv_parts_5_0= ruleGraphName ) + // InternalRosParser.g:2051:7: lv_parts_5_0= ruleGraphName { - newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); - pushFollow(FOLLOW_5); - lv_parts_7_0=ruleGraphName(); + pushFollow(FOLLOW_13); + lv_parts_5_0=ruleGraphName(); state._fsp--; @@ -6715,7 +5072,7 @@ public final EObject ruleGlobalNamespace() throws RecognitionException { add( current, "parts", - lv_parts_7_0, + lv_parts_5_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); @@ -6730,13 +5087,13 @@ public final EObject ruleGlobalNamespace() throws RecognitionException { break; default : - break loop58; + break loop35; } } while (true); - otherlv_8=(Token)match(input,28,FOLLOW_15); + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); - newLeafNode(otherlv_8, grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_3_4()); + newLeafNode(otherlv_6, grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); } @@ -6744,10 +5101,6 @@ public final EObject ruleGlobalNamespace() throws RecognitionException { } - otherlv_9=(Token)match(input,28,FOLLOW_2); - - newLeafNode(otherlv_9, grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_4()); - } @@ -6771,7 +5124,7 @@ public final EObject ruleGlobalNamespace() throws RecognitionException { // $ANTLR start "entryRuleRelativeNamespace_Impl" - // InternalRos.g:2816:1: entryRuleRelativeNamespace_Impl returns [EObject current=null] : iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF ; + // InternalRosParser.g:2078:1: entryRuleRelativeNamespace_Impl returns [EObject current=null] : iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF ; public final EObject entryRuleRelativeNamespace_Impl() throws RecognitionException { EObject current = null; @@ -6779,8 +5132,8 @@ public final EObject entryRuleRelativeNamespace_Impl() throws RecognitionExcepti try { - // InternalRos.g:2816:63: (iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF ) - // InternalRos.g:2817:2: iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF + // InternalRosParser.g:2078:63: (iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF ) + // InternalRosParser.g:2079:2: iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF { newCompositeNode(grammarAccess.getRelativeNamespace_ImplRule()); pushFollow(FOLLOW_1); @@ -6807,34 +5160,31 @@ public final EObject entryRuleRelativeNamespace_Impl() throws RecognitionExcepti // $ANTLR start "ruleRelativeNamespace_Impl" - // InternalRos.g:2823:1: ruleRelativeNamespace_Impl returns [EObject current=null] : ( () otherlv_1= 'RelativeNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) ; + // InternalRosParser.g:2085:1: ruleRelativeNamespace_Impl returns [EObject current=null] : ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ; public final EObject ruleRelativeNamespace_Impl() throws RecognitionException { EObject current = null; Token otherlv_1=null; Token otherlv_2=null; - Token otherlv_3=null; Token otherlv_4=null; Token otherlv_6=null; - Token otherlv_8=null; - Token otherlv_9=null; - AntlrDatatypeRuleToken lv_parts_5_0 = null; + AntlrDatatypeRuleToken lv_parts_3_0 = null; - AntlrDatatypeRuleToken lv_parts_7_0 = null; + AntlrDatatypeRuleToken lv_parts_5_0 = null; enterRule(); try { - // InternalRos.g:2829:2: ( ( () otherlv_1= 'RelativeNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) ) - // InternalRos.g:2830:2: ( () otherlv_1= 'RelativeNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) + // InternalRosParser.g:2091:2: ( ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ) + // InternalRosParser.g:2092:2: ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) { - // InternalRos.g:2830:2: ( () otherlv_1= 'RelativeNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) - // InternalRos.g:2831:3: () otherlv_1= 'RelativeNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' + // InternalRosParser.g:2092:2: ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + // InternalRosParser.g:2093:3: () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? { - // InternalRos.g:2831:3: () - // InternalRos.g:2832:4: + // InternalRosParser.g:2093:3: () + // InternalRosParser.g:2094:4: { current = forceCreateModelElement( @@ -6844,44 +5194,36 @@ public final EObject ruleRelativeNamespace_Impl() throws RecognitionException { } - otherlv_1=(Token)match(input,70,FOLLOW_3); + otherlv_1=(Token)match(input,RelativeNamespace,FOLLOW_35); newLeafNode(otherlv_1, grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); - otherlv_2=(Token)match(input,26,FOLLOW_47); + // InternalRosParser.g:2104:3: (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + int alt38=2; + int LA38_0 = input.LA(1); - newLeafNode(otherlv_2, grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_2()); - - // InternalRos.g:2846:3: (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? - int alt61=2; - int LA61_0 = input.LA(1); - - if ( (LA61_0==69) ) { - alt61=1; + if ( (LA38_0==LeftSquareBracket) ) { + alt38=1; } - switch (alt61) { + switch (alt38) { case 1 : - // InternalRos.g:2847:4: otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' + // InternalRosParser.g:2105:4: otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket { - otherlv_3=(Token)match(input,69,FOLLOW_3); - - newLeafNode(otherlv_3, grammarAccess.getRelativeNamespace_ImplAccess().getPartsKeyword_3_0()); - - otherlv_4=(Token)match(input,26,FOLLOW_48); + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_36); - newLeafNode(otherlv_4, grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_3_1()); + newLeafNode(otherlv_2, grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); - // InternalRos.g:2855:4: ( (lv_parts_5_0= ruleGraphName ) ) - // InternalRos.g:2856:5: (lv_parts_5_0= ruleGraphName ) + // InternalRosParser.g:2109:4: ( (lv_parts_3_0= ruleGraphName ) ) + // InternalRosParser.g:2110:5: (lv_parts_3_0= ruleGraphName ) { - // InternalRos.g:2856:5: (lv_parts_5_0= ruleGraphName ) - // InternalRos.g:2857:6: lv_parts_5_0= ruleGraphName + // InternalRosParser.g:2110:5: (lv_parts_3_0= ruleGraphName ) + // InternalRosParser.g:2111:6: lv_parts_3_0= ruleGraphName { - newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_2_0()); + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); - pushFollow(FOLLOW_5); - lv_parts_5_0=ruleGraphName(); + pushFollow(FOLLOW_13); + lv_parts_3_0=ruleGraphName(); state._fsp--; @@ -6892,7 +5234,7 @@ public final EObject ruleRelativeNamespace_Impl() throws RecognitionException { add( current, "parts", - lv_parts_5_0, + lv_parts_3_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); @@ -6902,36 +5244,36 @@ public final EObject ruleRelativeNamespace_Impl() throws RecognitionException { } - // InternalRos.g:2874:4: (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* - loop60: + // InternalRosParser.g:2128:4: (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* + loop37: do { - int alt60=2; - int LA60_0 = input.LA(1); + int alt37=2; + int LA37_0 = input.LA(1); - if ( (LA60_0==27) ) { - alt60=1; + if ( (LA37_0==Comma) ) { + alt37=1; } - switch (alt60) { + switch (alt37) { case 1 : - // InternalRos.g:2875:5: otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) + // InternalRosParser.g:2129:5: otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) { - otherlv_6=(Token)match(input,27,FOLLOW_48); + otherlv_4=(Token)match(input,Comma,FOLLOW_36); - newLeafNode(otherlv_6, grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_3_3_0()); + newLeafNode(otherlv_4, grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); - // InternalRos.g:2879:5: ( (lv_parts_7_0= ruleGraphName ) ) - // InternalRos.g:2880:6: (lv_parts_7_0= ruleGraphName ) + // InternalRosParser.g:2133:5: ( (lv_parts_5_0= ruleGraphName ) ) + // InternalRosParser.g:2134:6: (lv_parts_5_0= ruleGraphName ) { - // InternalRos.g:2880:6: (lv_parts_7_0= ruleGraphName ) - // InternalRos.g:2881:7: lv_parts_7_0= ruleGraphName + // InternalRosParser.g:2134:6: (lv_parts_5_0= ruleGraphName ) + // InternalRosParser.g:2135:7: lv_parts_5_0= ruleGraphName { - newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); - pushFollow(FOLLOW_5); - lv_parts_7_0=ruleGraphName(); + pushFollow(FOLLOW_13); + lv_parts_5_0=ruleGraphName(); state._fsp--; @@ -6942,7 +5284,7 @@ public final EObject ruleRelativeNamespace_Impl() throws RecognitionException { add( current, "parts", - lv_parts_7_0, + lv_parts_5_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); @@ -6957,13 +5299,13 @@ public final EObject ruleRelativeNamespace_Impl() throws RecognitionException { break; default : - break loop60; + break loop37; } } while (true); - otherlv_8=(Token)match(input,28,FOLLOW_15); + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); - newLeafNode(otherlv_8, grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_3_4()); + newLeafNode(otherlv_6, grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); } @@ -6971,10 +5313,6 @@ public final EObject ruleRelativeNamespace_Impl() throws RecognitionException { } - otherlv_9=(Token)match(input,28,FOLLOW_2); - - newLeafNode(otherlv_9, grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_4()); - } @@ -6998,7 +5336,7 @@ public final EObject ruleRelativeNamespace_Impl() throws RecognitionException { // $ANTLR start "entryRulePrivateNamespace" - // InternalRos.g:2912:1: entryRulePrivateNamespace returns [EObject current=null] : iv_rulePrivateNamespace= rulePrivateNamespace EOF ; + // InternalRosParser.g:2162:1: entryRulePrivateNamespace returns [EObject current=null] : iv_rulePrivateNamespace= rulePrivateNamespace EOF ; public final EObject entryRulePrivateNamespace() throws RecognitionException { EObject current = null; @@ -7006,8 +5344,8 @@ public final EObject entryRulePrivateNamespace() throws RecognitionException { try { - // InternalRos.g:2912:57: (iv_rulePrivateNamespace= rulePrivateNamespace EOF ) - // InternalRos.g:2913:2: iv_rulePrivateNamespace= rulePrivateNamespace EOF + // InternalRosParser.g:2162:57: (iv_rulePrivateNamespace= rulePrivateNamespace EOF ) + // InternalRosParser.g:2163:2: iv_rulePrivateNamespace= rulePrivateNamespace EOF { newCompositeNode(grammarAccess.getPrivateNamespaceRule()); pushFollow(FOLLOW_1); @@ -7034,34 +5372,31 @@ public final EObject entryRulePrivateNamespace() throws RecognitionException { // $ANTLR start "rulePrivateNamespace" - // InternalRos.g:2919:1: rulePrivateNamespace returns [EObject current=null] : ( () otherlv_1= 'PrivateNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) ; + // InternalRosParser.g:2169:1: rulePrivateNamespace returns [EObject current=null] : ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ; public final EObject rulePrivateNamespace() throws RecognitionException { EObject current = null; Token otherlv_1=null; Token otherlv_2=null; - Token otherlv_3=null; Token otherlv_4=null; Token otherlv_6=null; - Token otherlv_8=null; - Token otherlv_9=null; - AntlrDatatypeRuleToken lv_parts_5_0 = null; + AntlrDatatypeRuleToken lv_parts_3_0 = null; - AntlrDatatypeRuleToken lv_parts_7_0 = null; + AntlrDatatypeRuleToken lv_parts_5_0 = null; enterRule(); try { - // InternalRos.g:2925:2: ( ( () otherlv_1= 'PrivateNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) ) - // InternalRos.g:2926:2: ( () otherlv_1= 'PrivateNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) + // InternalRosParser.g:2175:2: ( ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ) + // InternalRosParser.g:2176:2: ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) { - // InternalRos.g:2926:2: ( () otherlv_1= 'PrivateNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' ) - // InternalRos.g:2927:3: () otherlv_1= 'PrivateNamespace' otherlv_2= '{' (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? otherlv_9= '}' + // InternalRosParser.g:2176:2: ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + // InternalRosParser.g:2177:3: () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? { - // InternalRos.g:2927:3: () - // InternalRos.g:2928:4: + // InternalRosParser.g:2177:3: () + // InternalRosParser.g:2178:4: { current = forceCreateModelElement( @@ -7071,44 +5406,36 @@ public final EObject rulePrivateNamespace() throws RecognitionException { } - otherlv_1=(Token)match(input,71,FOLLOW_3); + otherlv_1=(Token)match(input,PrivateNamespace,FOLLOW_35); newLeafNode(otherlv_1, grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); - otherlv_2=(Token)match(input,26,FOLLOW_47); + // InternalRosParser.g:2188:3: (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + int alt40=2; + int LA40_0 = input.LA(1); - newLeafNode(otherlv_2, grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_2()); - - // InternalRos.g:2942:3: (otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' )? - int alt63=2; - int LA63_0 = input.LA(1); - - if ( (LA63_0==69) ) { - alt63=1; + if ( (LA40_0==LeftSquareBracket) ) { + alt40=1; } - switch (alt63) { + switch (alt40) { case 1 : - // InternalRos.g:2943:4: otherlv_3= 'parts' otherlv_4= '{' ( (lv_parts_5_0= ruleGraphName ) ) (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* otherlv_8= '}' + // InternalRosParser.g:2189:4: otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket { - otherlv_3=(Token)match(input,69,FOLLOW_3); - - newLeafNode(otherlv_3, grammarAccess.getPrivateNamespaceAccess().getPartsKeyword_3_0()); - - otherlv_4=(Token)match(input,26,FOLLOW_48); + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_36); - newLeafNode(otherlv_4, grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); + newLeafNode(otherlv_2, grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); - // InternalRos.g:2951:4: ( (lv_parts_5_0= ruleGraphName ) ) - // InternalRos.g:2952:5: (lv_parts_5_0= ruleGraphName ) + // InternalRosParser.g:2193:4: ( (lv_parts_3_0= ruleGraphName ) ) + // InternalRosParser.g:2194:5: (lv_parts_3_0= ruleGraphName ) { - // InternalRos.g:2952:5: (lv_parts_5_0= ruleGraphName ) - // InternalRos.g:2953:6: lv_parts_5_0= ruleGraphName + // InternalRosParser.g:2194:5: (lv_parts_3_0= ruleGraphName ) + // InternalRosParser.g:2195:6: lv_parts_3_0= ruleGraphName { - newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); - pushFollow(FOLLOW_5); - lv_parts_5_0=ruleGraphName(); + pushFollow(FOLLOW_13); + lv_parts_3_0=ruleGraphName(); state._fsp--; @@ -7119,7 +5446,7 @@ public final EObject rulePrivateNamespace() throws RecognitionException { add( current, "parts", - lv_parts_5_0, + lv_parts_3_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); @@ -7129,36 +5456,36 @@ public final EObject rulePrivateNamespace() throws RecognitionException { } - // InternalRos.g:2970:4: (otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) )* - loop62: + // InternalRosParser.g:2212:4: (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* + loop39: do { - int alt62=2; - int LA62_0 = input.LA(1); + int alt39=2; + int LA39_0 = input.LA(1); - if ( (LA62_0==27) ) { - alt62=1; + if ( (LA39_0==Comma) ) { + alt39=1; } - switch (alt62) { + switch (alt39) { case 1 : - // InternalRos.g:2971:5: otherlv_6= ',' ( (lv_parts_7_0= ruleGraphName ) ) + // InternalRosParser.g:2213:5: otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) { - otherlv_6=(Token)match(input,27,FOLLOW_48); + otherlv_4=(Token)match(input,Comma,FOLLOW_36); - newLeafNode(otherlv_6, grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_3_3_0()); + newLeafNode(otherlv_4, grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); - // InternalRos.g:2975:5: ( (lv_parts_7_0= ruleGraphName ) ) - // InternalRos.g:2976:6: (lv_parts_7_0= ruleGraphName ) + // InternalRosParser.g:2217:5: ( (lv_parts_5_0= ruleGraphName ) ) + // InternalRosParser.g:2218:6: (lv_parts_5_0= ruleGraphName ) { - // InternalRos.g:2976:6: (lv_parts_7_0= ruleGraphName ) - // InternalRos.g:2977:7: lv_parts_7_0= ruleGraphName + // InternalRosParser.g:2218:6: (lv_parts_5_0= ruleGraphName ) + // InternalRosParser.g:2219:7: lv_parts_5_0= ruleGraphName { - newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); - pushFollow(FOLLOW_5); - lv_parts_7_0=ruleGraphName(); + pushFollow(FOLLOW_13); + lv_parts_5_0=ruleGraphName(); state._fsp--; @@ -7169,7 +5496,7 @@ public final EObject rulePrivateNamespace() throws RecognitionException { add( current, "parts", - lv_parts_7_0, + lv_parts_5_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); @@ -7184,13 +5511,13 @@ public final EObject rulePrivateNamespace() throws RecognitionException { break; default : - break loop62; + break loop39; } } while (true); - otherlv_8=(Token)match(input,28,FOLLOW_15); + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); - newLeafNode(otherlv_8, grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_3_4()); + newLeafNode(otherlv_6, grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); } @@ -7198,10 +5525,6 @@ public final EObject rulePrivateNamespace() throws RecognitionException { } - otherlv_9=(Token)match(input,28,FOLLOW_2); - - newLeafNode(otherlv_9, grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_4()); - } @@ -7225,7 +5548,7 @@ public final EObject rulePrivateNamespace() throws RecognitionException { // $ANTLR start "entryRuleParameter" - // InternalRos.g:3008:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ; + // InternalRosParser.g:2246:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ; public final EObject entryRuleParameter() throws RecognitionException { EObject current = null; @@ -7233,8 +5556,8 @@ public final EObject entryRuleParameter() throws RecognitionException { try { - // InternalRos.g:3008:50: (iv_ruleParameter= ruleParameter EOF ) - // InternalRos.g:3009:2: iv_ruleParameter= ruleParameter EOF + // InternalRosParser.g:2246:50: (iv_ruleParameter= ruleParameter EOF ) + // InternalRosParser.g:2247:2: iv_ruleParameter= ruleParameter EOF { newCompositeNode(grammarAccess.getParameterRule()); pushFollow(FOLLOW_1); @@ -7261,56 +5584,98 @@ public final EObject entryRuleParameter() throws RecognitionException { // $ANTLR start "ruleParameter" - // InternalRos.g:3015:1: ruleParameter returns [EObject current=null] : (otherlv_0= 'Parameter' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) (otherlv_4= 'namespace' ( (lv_namespace_5_0= ruleNamespace ) ) )? otherlv_6= 'type' ( (lv_type_7_0= ruleParameterType ) ) otherlv_8= '}' ) ; + // InternalRosParser.g:2253:1: ruleParameter returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END otherlv_9= RightCurlyBracket ) ; public final EObject ruleParameter() throws RecognitionException { EObject current = null; - Token otherlv_0=null; - Token otherlv_1=null; Token otherlv_2=null; + Token this_BEGIN_3=null; Token otherlv_4=null; Token otherlv_6=null; - Token otherlv_8=null; - AntlrDatatypeRuleToken lv_name_3_0 = null; + Token this_END_8=null; + Token otherlv_9=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; - EObject lv_namespace_5_0 = null; + EObject lv_type_5_0 = null; - EObject lv_type_7_0 = null; + EObject lv_namespace_7_0 = null; enterRule(); try { - // InternalRos.g:3021:2: ( (otherlv_0= 'Parameter' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) (otherlv_4= 'namespace' ( (lv_namespace_5_0= ruleNamespace ) ) )? otherlv_6= 'type' ( (lv_type_7_0= ruleParameterType ) ) otherlv_8= '}' ) ) - // InternalRos.g:3022:2: (otherlv_0= 'Parameter' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) (otherlv_4= 'namespace' ( (lv_namespace_5_0= ruleNamespace ) ) )? otherlv_6= 'type' ( (lv_type_7_0= ruleParameterType ) ) otherlv_8= '}' ) + // InternalRosParser.g:2259:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END otherlv_9= RightCurlyBracket ) ) + // InternalRosParser.g:2260:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END otherlv_9= RightCurlyBracket ) + { + // InternalRosParser.g:2260:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END otherlv_9= RightCurlyBracket ) + // InternalRosParser.g:2261:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END otherlv_9= RightCurlyBracket + { + // InternalRosParser.g:2261:3: () + // InternalRosParser.g:2262:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterAccess().getParameterAction_0(), + current); + + + } + + // InternalRosParser.g:2268:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRosParser.g:2269:4: (lv_name_1_0= ruleEString ) { - // InternalRos.g:3022:2: (otherlv_0= 'Parameter' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) (otherlv_4= 'namespace' ( (lv_namespace_5_0= ruleNamespace ) ) )? otherlv_6= 'type' ( (lv_type_7_0= ruleParameterType ) ) otherlv_8= '}' ) - // InternalRos.g:3023:3: otherlv_0= 'Parameter' otherlv_1= '{' otherlv_2= 'name' ( (lv_name_3_0= ruleEString ) ) (otherlv_4= 'namespace' ( (lv_namespace_5_0= ruleNamespace ) ) )? otherlv_6= 'type' ( (lv_type_7_0= ruleParameterType ) ) otherlv_8= '}' + // InternalRosParser.g:2269:4: (lv_name_1_0= ruleEString ) + // InternalRosParser.g:2270:5: lv_name_1_0= ruleEString { - otherlv_0=(Token)match(input,72,FOLLOW_3); - newLeafNode(otherlv_0, grammarAccess.getParameterAccess().getParameterKeyword_0()); + newCompositeNode(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_4); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_5); + + newLeafNode(otherlv_2, grammarAccess.getParameterAccess().getColonKeyword_2()); - otherlv_1=(Token)match(input,26,FOLLOW_27); + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_37); - newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getLeftCurlyBracketKeyword_1()); + newLeafNode(this_BEGIN_3, grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); - otherlv_2=(Token)match(input,49,FOLLOW_7); + otherlv_4=(Token)match(input,Type,FOLLOW_38); - newLeafNode(otherlv_2, grammarAccess.getParameterAccess().getNameKeyword_2()); + newLeafNode(otherlv_4, grammarAccess.getParameterAccess().getTypeKeyword_4()); - // InternalRos.g:3035:3: ( (lv_name_3_0= ruleEString ) ) - // InternalRos.g:3036:4: (lv_name_3_0= ruleEString ) + // InternalRosParser.g:2299:3: ( (lv_type_5_0= ruleParameterType ) ) + // InternalRosParser.g:2300:4: (lv_type_5_0= ruleParameterType ) { - // InternalRos.g:3036:4: (lv_name_3_0= ruleEString ) - // InternalRos.g:3037:5: lv_name_3_0= ruleEString + // InternalRosParser.g:2300:4: (lv_type_5_0= ruleParameterType ) + // InternalRosParser.g:2301:5: lv_type_5_0= ruleParameterType { - newCompositeNode(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_3_0()); + newCompositeNode(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); - pushFollow(FOLLOW_49); - lv_name_3_0=ruleEString(); + pushFollow(FOLLOW_33); + lv_type_5_0=ruleParameterType(); state._fsp--; @@ -7320,9 +5685,9 @@ public final EObject ruleParameter() throws RecognitionException { } set( current, - "name", - lv_name_3_0, - "de.fraunhofer.ipa.ros.Ros.EString"); + "type", + lv_type_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); afterParserOrEnumRuleCall(); @@ -7331,32 +5696,32 @@ public final EObject ruleParameter() throws RecognitionException { } - // InternalRos.g:3054:3: (otherlv_4= 'namespace' ( (lv_namespace_5_0= ruleNamespace ) ) )? - int alt64=2; - int LA64_0 = input.LA(1); + // InternalRosParser.g:2318:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt41=2; + int LA41_0 = input.LA(1); - if ( (LA64_0==59) ) { - alt64=1; + if ( (LA41_0==Ns) ) { + alt41=1; } - switch (alt64) { + switch (alt41) { case 1 : - // InternalRos.g:3055:4: otherlv_4= 'namespace' ( (lv_namespace_5_0= ruleNamespace ) ) + // InternalRosParser.g:2319:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) { - otherlv_4=(Token)match(input,59,FOLLOW_44); + otherlv_6=(Token)match(input,Ns,FOLLOW_34); - newLeafNode(otherlv_4, grammarAccess.getParameterAccess().getNamespaceKeyword_4_0()); + newLeafNode(otherlv_6, grammarAccess.getParameterAccess().getNsKeyword_6_0()); - // InternalRos.g:3059:4: ( (lv_namespace_5_0= ruleNamespace ) ) - // InternalRos.g:3060:5: (lv_namespace_5_0= ruleNamespace ) + // InternalRosParser.g:2323:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRosParser.g:2324:5: (lv_namespace_7_0= ruleNamespace ) { - // InternalRos.g:3060:5: (lv_namespace_5_0= ruleNamespace ) - // InternalRos.g:3061:6: lv_namespace_5_0= ruleNamespace + // InternalRosParser.g:2324:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRosParser.g:2325:6: lv_namespace_7_0= ruleNamespace { - newCompositeNode(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_4_1_0()); + newCompositeNode(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); - pushFollow(FOLLOW_50); - lv_namespace_5_0=ruleNamespace(); + pushFollow(FOLLOW_14); + lv_namespace_7_0=ruleNamespace(); state._fsp--; @@ -7367,7 +5732,7 @@ public final EObject ruleParameter() throws RecognitionException { set( current, "namespace", - lv_namespace_5_0, + lv_namespace_7_0, "de.fraunhofer.ipa.ros.Ros.Namespace"); afterParserOrEnumRuleCall(); @@ -7383,44 +5748,13 @@ public final EObject ruleParameter() throws RecognitionException { } - otherlv_6=(Token)match(input,73,FOLLOW_51); + this_END_8=(Token)match(input,RULE_END,FOLLOW_39); - newLeafNode(otherlv_6, grammarAccess.getParameterAccess().getTypeKeyword_5()); + newLeafNode(this_END_8, grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); - // InternalRos.g:3083:3: ( (lv_type_7_0= ruleParameterType ) ) - // InternalRos.g:3084:4: (lv_type_7_0= ruleParameterType ) - { - // InternalRos.g:3084:4: (lv_type_7_0= ruleParameterType ) - // InternalRos.g:3085:5: lv_type_7_0= ruleParameterType - { - - newCompositeNode(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_6_0()); - - pushFollow(FOLLOW_15); - lv_type_7_0=ruleParameterType(); + otherlv_9=(Token)match(input,RightCurlyBracket,FOLLOW_2); - state._fsp--; - - - if (current==null) { - current = createModelElementForParent(grammarAccess.getParameterRule()); - } - set( - current, - "type", - lv_type_7_0, - "de.fraunhofer.ipa.ros.Ros.ParameterType"); - afterParserOrEnumRuleCall(); - - - } - - - } - - otherlv_8=(Token)match(input,28,FOLLOW_2); - - newLeafNode(otherlv_8, grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_7()); + newLeafNode(otherlv_9, grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); } @@ -7445,7 +5779,7 @@ public final EObject ruleParameter() throws RecognitionException { // $ANTLR start "entryRuleParameterType" - // InternalRos.g:3110:1: entryRuleParameterType returns [EObject current=null] : iv_ruleParameterType= ruleParameterType EOF ; + // InternalRosParser.g:2355:1: entryRuleParameterType returns [EObject current=null] : iv_ruleParameterType= ruleParameterType EOF ; public final EObject entryRuleParameterType() throws RecognitionException { EObject current = null; @@ -7453,8 +5787,8 @@ public final EObject entryRuleParameterType() throws RecognitionException { try { - // InternalRos.g:3110:54: (iv_ruleParameterType= ruleParameterType EOF ) - // InternalRos.g:3111:2: iv_ruleParameterType= ruleParameterType EOF + // InternalRosParser.g:2355:54: (iv_ruleParameterType= ruleParameterType EOF ) + // InternalRosParser.g:2356:2: iv_ruleParameterType= ruleParameterType EOF { newCompositeNode(grammarAccess.getParameterTypeRule()); pushFollow(FOLLOW_1); @@ -7481,7 +5815,7 @@ public final EObject entryRuleParameterType() throws RecognitionException { // $ANTLR start "ruleParameterType" - // InternalRos.g:3117:1: ruleParameterType returns [EObject current=null] : (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) ; + // InternalRosParser.g:2362:1: ruleParameterType returns [EObject current=null] : (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) ; public final EObject ruleParameterType() throws RecognitionException { EObject current = null; @@ -7506,62 +5840,62 @@ public final EObject ruleParameterType() throws RecognitionException { enterRule(); try { - // InternalRos.g:3123:2: ( (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) ) - // InternalRos.g:3124:2: (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) + // InternalRosParser.g:2368:2: ( (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) ) + // InternalRosParser.g:2369:2: (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) { - // InternalRos.g:3124:2: (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) - int alt65=8; + // InternalRosParser.g:2369:2: (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) + int alt42=8; switch ( input.LA(1) ) { - case 74: + case List: { - alt65=1; + alt42=1; } break; - case 75: + case Struct: { - alt65=2; + alt42=2; } break; - case 76: + case Integer: { - alt65=3; + alt42=3; } break; - case 42: + case String: { - alt65=4; + alt42=4; } break; - case 78: + case Double: { - alt65=5; + alt42=5; } break; - case 79: + case Boolean: { - alt65=6; + alt42=6; } break; - case 80: + case Base64: { - alt65=7; + alt42=7; } break; - case 81: + case Array: { - alt65=8; + alt42=8; } break; default: NoViableAltException nvae = - new NoViableAltException("", 65, 0, input); + new NoViableAltException("", 42, 0, input); throw nvae; } - switch (alt65) { + switch (alt42) { case 1 : - // InternalRos.g:3125:3: this_ParameterListType_0= ruleParameterListType + // InternalRosParser.g:2370:3: this_ParameterListType_0= ruleParameterListType { newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); @@ -7579,7 +5913,7 @@ public final EObject ruleParameterType() throws RecognitionException { } break; case 2 : - // InternalRos.g:3134:3: this_ParameterStructType_1= ruleParameterStructType + // InternalRosParser.g:2379:3: this_ParameterStructType_1= ruleParameterStructType { newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); @@ -7597,7 +5931,7 @@ public final EObject ruleParameterType() throws RecognitionException { } break; case 3 : - // InternalRos.g:3143:3: this_ParameterIntegerType_2= ruleParameterIntegerType + // InternalRosParser.g:2388:3: this_ParameterIntegerType_2= ruleParameterIntegerType { newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); @@ -7615,7 +5949,7 @@ public final EObject ruleParameterType() throws RecognitionException { } break; case 4 : - // InternalRos.g:3152:3: this_ParameterStringType_3= ruleParameterStringType + // InternalRosParser.g:2397:3: this_ParameterStringType_3= ruleParameterStringType { newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); @@ -7633,7 +5967,7 @@ public final EObject ruleParameterType() throws RecognitionException { } break; case 5 : - // InternalRos.g:3161:3: this_ParameterDoubleType_4= ruleParameterDoubleType + // InternalRosParser.g:2406:3: this_ParameterDoubleType_4= ruleParameterDoubleType { newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); @@ -7651,7 +5985,7 @@ public final EObject ruleParameterType() throws RecognitionException { } break; case 6 : - // InternalRos.g:3170:3: this_ParameterBooleanType_5= ruleParameterBooleanType + // InternalRosParser.g:2415:3: this_ParameterBooleanType_5= ruleParameterBooleanType { newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); @@ -7669,7 +6003,7 @@ public final EObject ruleParameterType() throws RecognitionException { } break; case 7 : - // InternalRos.g:3179:3: this_ParameterBase64Type_6= ruleParameterBase64Type + // InternalRosParser.g:2424:3: this_ParameterBase64Type_6= ruleParameterBase64Type { newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); @@ -7687,7 +6021,7 @@ public final EObject ruleParameterType() throws RecognitionException { } break; case 8 : - // InternalRos.g:3188:3: this_ParameterArrayType_7= ruleParameterArrayType + // InternalRosParser.g:2433:3: this_ParameterArrayType_7= ruleParameterArrayType { newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); @@ -7727,7 +6061,7 @@ public final EObject ruleParameterType() throws RecognitionException { // $ANTLR start "entryRuleParameterValue" - // InternalRos.g:3200:1: entryRuleParameterValue returns [EObject current=null] : iv_ruleParameterValue= ruleParameterValue EOF ; + // InternalRosParser.g:2445:1: entryRuleParameterValue returns [EObject current=null] : iv_ruleParameterValue= ruleParameterValue EOF ; public final EObject entryRuleParameterValue() throws RecognitionException { EObject current = null; @@ -7735,8 +6069,8 @@ public final EObject entryRuleParameterValue() throws RecognitionException { try { - // InternalRos.g:3200:55: (iv_ruleParameterValue= ruleParameterValue EOF ) - // InternalRos.g:3201:2: iv_ruleParameterValue= ruleParameterValue EOF + // InternalRosParser.g:2445:55: (iv_ruleParameterValue= ruleParameterValue EOF ) + // InternalRosParser.g:2446:2: iv_ruleParameterValue= ruleParameterValue EOF { newCompositeNode(grammarAccess.getParameterValueRule()); pushFollow(FOLLOW_1); @@ -7763,7 +6097,7 @@ public final EObject entryRuleParameterValue() throws RecognitionException { // $ANTLR start "ruleParameterValue" - // InternalRos.g:3207:1: ruleParameterValue returns [EObject current=null] : (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) ; + // InternalRosParser.g:2452:1: ruleParameterValue returns [EObject current=null] : (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) ; public final EObject ruleParameterValue() throws RecognitionException { EObject current = null; @@ -7786,73 +6120,74 @@ public final EObject ruleParameterValue() throws RecognitionException { enterRule(); try { - // InternalRos.g:3213:2: ( (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) ) - // InternalRos.g:3214:2: (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) + // InternalRosParser.g:2458:2: ( (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) ) + // InternalRosParser.g:2459:2: (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) { - // InternalRos.g:3214:2: (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) - int alt66=7; + // InternalRosParser.g:2459:2: (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) + int alt43=7; switch ( input.LA(1) ) { - case RULE_STRING: case RULE_ID: + case RULE_STRING: { - alt66=1; + alt43=1; } break; case RULE_BINARY: { - alt66=2; + alt43=2; } break; case RULE_DECINT: { - alt66=3; + alt43=3; } break; case RULE_DOUBLE: { - alt66=4; + alt43=4; } break; case RULE_BOOLEAN: { - alt66=5; + alt43=5; } break; - case 26: + case LeftSquareBracket: { - int LA66_6 = input.LA(2); + int LA43_6 = input.LA(2); - if ( ((LA66_6>=RULE_STRING && LA66_6<=RULE_ID)||(LA66_6>=RULE_BINARY && LA66_6<=RULE_DECINT)||(LA66_6>=26 && LA66_6<=28)) ) { - alt66=6; + if ( (LA43_6==ParameterStructMember) ) { + alt43=7; } - else if ( (LA66_6==84) ) { - alt66=7; + else if ( (LA43_6==Comma||(LA43_6>=LeftSquareBracket && LA43_6<=RightSquareBracket)||LA43_6==RULE_ID||LA43_6==RULE_STRING||(LA43_6>=RULE_BINARY && LA43_6<=RULE_DOUBLE)) ) { + alt43=6; } else { NoViableAltException nvae = - new NoViableAltException("", 66, 6, input); + new NoViableAltException("", 43, 6, input); throw nvae; } } break; case EOF: - case 27: - case 28: + case Comma: + case RightSquareBracket: + case RULE_END: { - alt66=7; + alt43=7; } break; default: NoViableAltException nvae = - new NoViableAltException("", 66, 0, input); + new NoViableAltException("", 43, 0, input); throw nvae; } - switch (alt66) { + switch (alt43) { case 1 : - // InternalRos.g:3215:3: this_ParameterString_0= ruleParameterString + // InternalRosParser.g:2460:3: this_ParameterString_0= ruleParameterString { newCompositeNode(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); @@ -7870,7 +6205,7 @@ else if ( (LA66_6==84) ) { } break; case 2 : - // InternalRos.g:3224:3: this_ParameterBase64_1= ruleParameterBase64 + // InternalRosParser.g:2469:3: this_ParameterBase64_1= ruleParameterBase64 { newCompositeNode(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); @@ -7888,7 +6223,7 @@ else if ( (LA66_6==84) ) { } break; case 3 : - // InternalRos.g:3233:3: this_ParameterInteger_2= ruleParameterInteger + // InternalRosParser.g:2478:3: this_ParameterInteger_2= ruleParameterInteger { newCompositeNode(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); @@ -7906,7 +6241,7 @@ else if ( (LA66_6==84) ) { } break; case 4 : - // InternalRos.g:3242:3: this_ParameterDouble_3= ruleParameterDouble + // InternalRosParser.g:2487:3: this_ParameterDouble_3= ruleParameterDouble { newCompositeNode(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); @@ -7924,7 +6259,7 @@ else if ( (LA66_6==84) ) { } break; case 5 : - // InternalRos.g:3251:3: this_ParameterBoolean_4= ruleParameterBoolean + // InternalRosParser.g:2496:3: this_ParameterBoolean_4= ruleParameterBoolean { newCompositeNode(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); @@ -7942,7 +6277,7 @@ else if ( (LA66_6==84) ) { } break; case 6 : - // InternalRos.g:3260:3: this_ParameterList_5= ruleParameterList + // InternalRosParser.g:2505:3: this_ParameterList_5= ruleParameterList { newCompositeNode(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); @@ -7960,7 +6295,7 @@ else if ( (LA66_6==84) ) { } break; case 7 : - // InternalRos.g:3269:3: this_ParameterStruct_6= ruleParameterStruct + // InternalRosParser.g:2514:3: this_ParameterStruct_6= ruleParameterStruct { newCompositeNode(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); @@ -8000,7 +6335,7 @@ else if ( (LA66_6==84) ) { // $ANTLR start "entryRuleParameterListType" - // InternalRos.g:3281:1: entryRuleParameterListType returns [EObject current=null] : iv_ruleParameterListType= ruleParameterListType EOF ; + // InternalRosParser.g:2526:1: entryRuleParameterListType returns [EObject current=null] : iv_ruleParameterListType= ruleParameterListType EOF ; public final EObject entryRuleParameterListType() throws RecognitionException { EObject current = null; @@ -8008,8 +6343,8 @@ public final EObject entryRuleParameterListType() throws RecognitionException { try { - // InternalRos.g:3281:58: (iv_ruleParameterListType= ruleParameterListType EOF ) - // InternalRos.g:3282:2: iv_ruleParameterListType= ruleParameterListType EOF + // InternalRosParser.g:2526:58: (iv_ruleParameterListType= ruleParameterListType EOF ) + // InternalRosParser.g:2527:2: iv_ruleParameterListType= ruleParameterListType EOF { newCompositeNode(grammarAccess.getParameterListTypeRule()); pushFollow(FOLLOW_1); @@ -8036,7 +6371,7 @@ public final EObject entryRuleParameterListType() throws RecognitionException { // $ANTLR start "ruleParameterListType" - // InternalRos.g:3288:1: ruleParameterListType returns [EObject current=null] : ( () otherlv_1= 'List' otherlv_2= '{' ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= ',' ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= '}' ) ; + // InternalRosParser.g:2533:1: ruleParameterListType returns [EObject current=null] : ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) ; public final EObject ruleParameterListType() throws RecognitionException { EObject current = null; @@ -8053,14 +6388,14 @@ public final EObject ruleParameterListType() throws RecognitionException { enterRule(); try { - // InternalRos.g:3294:2: ( ( () otherlv_1= 'List' otherlv_2= '{' ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= ',' ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= '}' ) ) - // InternalRos.g:3295:2: ( () otherlv_1= 'List' otherlv_2= '{' ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= ',' ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= '}' ) + // InternalRosParser.g:2539:2: ( ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) ) + // InternalRosParser.g:2540:2: ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) { - // InternalRos.g:3295:2: ( () otherlv_1= 'List' otherlv_2= '{' ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= ',' ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= '}' ) - // InternalRos.g:3296:3: () otherlv_1= 'List' otherlv_2= '{' ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= ',' ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= '}' + // InternalRosParser.g:2540:2: ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) + // InternalRosParser.g:2541:3: () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket { - // InternalRos.g:3296:3: () - // InternalRos.g:3297:4: + // InternalRosParser.g:2541:3: () + // InternalRosParser.g:2542:4: { current = forceCreateModelElement( @@ -8070,24 +6405,24 @@ public final EObject ruleParameterListType() throws RecognitionException { } - otherlv_1=(Token)match(input,74,FOLLOW_3); + otherlv_1=(Token)match(input,List,FOLLOW_11); newLeafNode(otherlv_1, grammarAccess.getParameterListTypeAccess().getListKeyword_1()); - otherlv_2=(Token)match(input,26,FOLLOW_51); + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_38); - newLeafNode(otherlv_2, grammarAccess.getParameterListTypeAccess().getLeftCurlyBracketKeyword_2()); + newLeafNode(otherlv_2, grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); - // InternalRos.g:3311:3: ( (lv_sequence_3_0= ruleParameterType ) ) - // InternalRos.g:3312:4: (lv_sequence_3_0= ruleParameterType ) + // InternalRosParser.g:2556:3: ( (lv_sequence_3_0= ruleParameterType ) ) + // InternalRosParser.g:2557:4: (lv_sequence_3_0= ruleParameterType ) { - // InternalRos.g:3312:4: (lv_sequence_3_0= ruleParameterType ) - // InternalRos.g:3313:5: lv_sequence_3_0= ruleParameterType + // InternalRosParser.g:2557:4: (lv_sequence_3_0= ruleParameterType ) + // InternalRosParser.g:2558:5: lv_sequence_3_0= ruleParameterType { newCompositeNode(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); - pushFollow(FOLLOW_5); + pushFollow(FOLLOW_13); lv_sequence_3_0=ruleParameterType(); state._fsp--; @@ -8109,35 +6444,35 @@ public final EObject ruleParameterListType() throws RecognitionException { } - // InternalRos.g:3330:3: (otherlv_4= ',' ( (lv_sequence_5_0= ruleParameterType ) ) )* - loop67: + // InternalRosParser.g:2575:3: (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* + loop44: do { - int alt67=2; - int LA67_0 = input.LA(1); + int alt44=2; + int LA44_0 = input.LA(1); - if ( (LA67_0==27) ) { - alt67=1; + if ( (LA44_0==Comma) ) { + alt44=1; } - switch (alt67) { + switch (alt44) { case 1 : - // InternalRos.g:3331:4: otherlv_4= ',' ( (lv_sequence_5_0= ruleParameterType ) ) + // InternalRosParser.g:2576:4: otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) { - otherlv_4=(Token)match(input,27,FOLLOW_51); + otherlv_4=(Token)match(input,Comma,FOLLOW_38); newLeafNode(otherlv_4, grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); - // InternalRos.g:3335:4: ( (lv_sequence_5_0= ruleParameterType ) ) - // InternalRos.g:3336:5: (lv_sequence_5_0= ruleParameterType ) + // InternalRosParser.g:2580:4: ( (lv_sequence_5_0= ruleParameterType ) ) + // InternalRosParser.g:2581:5: (lv_sequence_5_0= ruleParameterType ) { - // InternalRos.g:3336:5: (lv_sequence_5_0= ruleParameterType ) - // InternalRos.g:3337:6: lv_sequence_5_0= ruleParameterType + // InternalRosParser.g:2581:5: (lv_sequence_5_0= ruleParameterType ) + // InternalRosParser.g:2582:6: lv_sequence_5_0= ruleParameterType { newCompositeNode(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); - pushFollow(FOLLOW_5); + pushFollow(FOLLOW_13); lv_sequence_5_0=ruleParameterType(); state._fsp--; @@ -8164,13 +6499,13 @@ public final EObject ruleParameterListType() throws RecognitionException { break; default : - break loop67; + break loop44; } } while (true); - otherlv_6=(Token)match(input,28,FOLLOW_2); + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); - newLeafNode(otherlv_6, grammarAccess.getParameterListTypeAccess().getRightCurlyBracketKeyword_5()); + newLeafNode(otherlv_6, grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); } @@ -8195,7 +6530,7 @@ public final EObject ruleParameterListType() throws RecognitionException { // $ANTLR start "entryRuleParameterStructType" - // InternalRos.g:3363:1: entryRuleParameterStructType returns [EObject current=null] : iv_ruleParameterStructType= ruleParameterStructType EOF ; + // InternalRosParser.g:2608:1: entryRuleParameterStructType returns [EObject current=null] : iv_ruleParameterStructType= ruleParameterStructType EOF ; public final EObject entryRuleParameterStructType() throws RecognitionException { EObject current = null; @@ -8203,8 +6538,8 @@ public final EObject entryRuleParameterStructType() throws RecognitionException try { - // InternalRos.g:3363:60: (iv_ruleParameterStructType= ruleParameterStructType EOF ) - // InternalRos.g:3364:2: iv_ruleParameterStructType= ruleParameterStructType EOF + // InternalRosParser.g:2608:60: (iv_ruleParameterStructType= ruleParameterStructType EOF ) + // InternalRosParser.g:2609:2: iv_ruleParameterStructType= ruleParameterStructType EOF { newCompositeNode(grammarAccess.getParameterStructTypeRule()); pushFollow(FOLLOW_1); @@ -8231,7 +6566,7 @@ public final EObject entryRuleParameterStructType() throws RecognitionException // $ANTLR start "ruleParameterStructType" - // InternalRos.g:3370:1: ruleParameterStructType returns [EObject current=null] : ( () otherlv_1= 'Struct' otherlv_2= '{' ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= ',' ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= '}' ) ; + // InternalRosParser.g:2615:1: ruleParameterStructType returns [EObject current=null] : ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) ; public final EObject ruleParameterStructType() throws RecognitionException { EObject current = null; @@ -8248,14 +6583,14 @@ public final EObject ruleParameterStructType() throws RecognitionException { enterRule(); try { - // InternalRos.g:3376:2: ( ( () otherlv_1= 'Struct' otherlv_2= '{' ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= ',' ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= '}' ) ) - // InternalRos.g:3377:2: ( () otherlv_1= 'Struct' otherlv_2= '{' ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= ',' ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= '}' ) + // InternalRosParser.g:2621:2: ( ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) ) + // InternalRosParser.g:2622:2: ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) { - // InternalRos.g:3377:2: ( () otherlv_1= 'Struct' otherlv_2= '{' ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= ',' ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= '}' ) - // InternalRos.g:3378:3: () otherlv_1= 'Struct' otherlv_2= '{' ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= ',' ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= '}' + // InternalRosParser.g:2622:2: ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) + // InternalRosParser.g:2623:3: () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket { - // InternalRos.g:3378:3: () - // InternalRos.g:3379:4: + // InternalRosParser.g:2623:3: () + // InternalRosParser.g:2624:4: { current = forceCreateModelElement( @@ -8265,24 +6600,24 @@ public final EObject ruleParameterStructType() throws RecognitionException { } - otherlv_1=(Token)match(input,75,FOLLOW_3); + otherlv_1=(Token)match(input,Struct,FOLLOW_11); newLeafNode(otherlv_1, grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); - otherlv_2=(Token)match(input,26,FOLLOW_7); + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_7); - newLeafNode(otherlv_2, grammarAccess.getParameterStructTypeAccess().getLeftCurlyBracketKeyword_2()); + newLeafNode(otherlv_2, grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); - // InternalRos.g:3393:3: ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) - // InternalRos.g:3394:4: (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) + // InternalRosParser.g:2638:3: ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) + // InternalRosParser.g:2639:4: (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) { - // InternalRos.g:3394:4: (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) - // InternalRos.g:3395:5: lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember + // InternalRosParser.g:2639:4: (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) + // InternalRosParser.g:2640:5: lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember { newCompositeNode(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); - pushFollow(FOLLOW_5); + pushFollow(FOLLOW_13); lv_parameterstructypetmember_3_0=ruleParameterStructTypeMember(); state._fsp--; @@ -8304,35 +6639,35 @@ public final EObject ruleParameterStructType() throws RecognitionException { } - // InternalRos.g:3412:3: (otherlv_4= ',' ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* - loop68: + // InternalRosParser.g:2657:3: (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* + loop45: do { - int alt68=2; - int LA68_0 = input.LA(1); + int alt45=2; + int LA45_0 = input.LA(1); - if ( (LA68_0==27) ) { - alt68=1; + if ( (LA45_0==Comma) ) { + alt45=1; } - switch (alt68) { + switch (alt45) { case 1 : - // InternalRos.g:3413:4: otherlv_4= ',' ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) + // InternalRosParser.g:2658:4: otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) { - otherlv_4=(Token)match(input,27,FOLLOW_7); + otherlv_4=(Token)match(input,Comma,FOLLOW_7); newLeafNode(otherlv_4, grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); - // InternalRos.g:3417:4: ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) - // InternalRos.g:3418:5: (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) + // InternalRosParser.g:2662:4: ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) + // InternalRosParser.g:2663:5: (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) { - // InternalRos.g:3418:5: (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) - // InternalRos.g:3419:6: lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember + // InternalRosParser.g:2663:5: (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) + // InternalRosParser.g:2664:6: lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember { newCompositeNode(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); - pushFollow(FOLLOW_5); + pushFollow(FOLLOW_13); lv_parameterstructypetmember_5_0=ruleParameterStructTypeMember(); state._fsp--; @@ -8359,13 +6694,13 @@ public final EObject ruleParameterStructType() throws RecognitionException { break; default : - break loop68; + break loop45; } } while (true); - otherlv_6=(Token)match(input,28,FOLLOW_2); + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); - newLeafNode(otherlv_6, grammarAccess.getParameterStructTypeAccess().getRightCurlyBracketKeyword_5()); + newLeafNode(otherlv_6, grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); } @@ -8390,7 +6725,7 @@ public final EObject ruleParameterStructType() throws RecognitionException { // $ANTLR start "entryRuleParameterIntegerType" - // InternalRos.g:3445:1: entryRuleParameterIntegerType returns [EObject current=null] : iv_ruleParameterIntegerType= ruleParameterIntegerType EOF ; + // InternalRosParser.g:2690:1: entryRuleParameterIntegerType returns [EObject current=null] : iv_ruleParameterIntegerType= ruleParameterIntegerType EOF ; public final EObject entryRuleParameterIntegerType() throws RecognitionException { EObject current = null; @@ -8398,8 +6733,8 @@ public final EObject entryRuleParameterIntegerType() throws RecognitionException try { - // InternalRos.g:3445:61: (iv_ruleParameterIntegerType= ruleParameterIntegerType EOF ) - // InternalRos.g:3446:2: iv_ruleParameterIntegerType= ruleParameterIntegerType EOF + // InternalRosParser.g:2690:61: (iv_ruleParameterIntegerType= ruleParameterIntegerType EOF ) + // InternalRosParser.g:2691:2: iv_ruleParameterIntegerType= ruleParameterIntegerType EOF { newCompositeNode(grammarAccess.getParameterIntegerTypeRule()); pushFollow(FOLLOW_1); @@ -8426,7 +6761,7 @@ public final EObject entryRuleParameterIntegerType() throws RecognitionException // $ANTLR start "ruleParameterIntegerType" - // InternalRos.g:3452:1: ruleParameterIntegerType returns [EObject current=null] : ( () otherlv_1= 'Integer' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterInteger ) ) )? ) ; + // InternalRosParser.g:2697:1: ruleParameterIntegerType returns [EObject current=null] : ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) ; public final EObject ruleParameterIntegerType() throws RecognitionException { EObject current = null; @@ -8439,14 +6774,14 @@ public final EObject ruleParameterIntegerType() throws RecognitionException { enterRule(); try { - // InternalRos.g:3458:2: ( ( () otherlv_1= 'Integer' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterInteger ) ) )? ) ) - // InternalRos.g:3459:2: ( () otherlv_1= 'Integer' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterInteger ) ) )? ) + // InternalRosParser.g:2703:2: ( ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) ) + // InternalRosParser.g:2704:2: ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) { - // InternalRos.g:3459:2: ( () otherlv_1= 'Integer' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterInteger ) ) )? ) - // InternalRos.g:3460:3: () otherlv_1= 'Integer' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterInteger ) ) )? + // InternalRosParser.g:2704:2: ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) + // InternalRosParser.g:2705:3: () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? { - // InternalRos.g:3460:3: () - // InternalRos.g:3461:4: + // InternalRosParser.g:2705:3: () + // InternalRosParser.g:2706:4: { current = forceCreateModelElement( @@ -8456,34 +6791,34 @@ public final EObject ruleParameterIntegerType() throws RecognitionException { } - otherlv_1=(Token)match(input,76,FOLLOW_52); + otherlv_1=(Token)match(input,Integer,FOLLOW_40); newLeafNode(otherlv_1, grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); - // InternalRos.g:3471:3: (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterInteger ) ) )? - int alt69=2; - int LA69_0 = input.LA(1); + // InternalRosParser.g:2716:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? + int alt46=2; + int LA46_0 = input.LA(1); - if ( (LA69_0==77) ) { - int LA69_1 = input.LA(2); + if ( (LA46_0==Default) ) { + int LA46_1 = input.LA(2); - if ( (LA69_1==RULE_DECINT) ) { - alt69=1; + if ( (LA46_1==RULE_DECINT) ) { + alt46=1; } } - switch (alt69) { + switch (alt46) { case 1 : - // InternalRos.g:3472:4: otherlv_2= 'default' ( (lv_default_3_0= ruleParameterInteger ) ) + // InternalRosParser.g:2717:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) { - otherlv_2=(Token)match(input,77,FOLLOW_53); + otherlv_2=(Token)match(input,Default,FOLLOW_41); newLeafNode(otherlv_2, grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); - // InternalRos.g:3476:4: ( (lv_default_3_0= ruleParameterInteger ) ) - // InternalRos.g:3477:5: (lv_default_3_0= ruleParameterInteger ) + // InternalRosParser.g:2721:4: ( (lv_default_3_0= ruleParameterInteger ) ) + // InternalRosParser.g:2722:5: (lv_default_3_0= ruleParameterInteger ) { - // InternalRos.g:3477:5: (lv_default_3_0= ruleParameterInteger ) - // InternalRos.g:3478:6: lv_default_3_0= ruleParameterInteger + // InternalRosParser.g:2722:5: (lv_default_3_0= ruleParameterInteger ) + // InternalRosParser.g:2723:6: lv_default_3_0= ruleParameterInteger { newCompositeNode(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); @@ -8539,7 +6874,7 @@ public final EObject ruleParameterIntegerType() throws RecognitionException { // $ANTLR start "entryRuleParameterStringType" - // InternalRos.g:3500:1: entryRuleParameterStringType returns [EObject current=null] : iv_ruleParameterStringType= ruleParameterStringType EOF ; + // InternalRosParser.g:2745:1: entryRuleParameterStringType returns [EObject current=null] : iv_ruleParameterStringType= ruleParameterStringType EOF ; public final EObject entryRuleParameterStringType() throws RecognitionException { EObject current = null; @@ -8547,8 +6882,8 @@ public final EObject entryRuleParameterStringType() throws RecognitionException try { - // InternalRos.g:3500:60: (iv_ruleParameterStringType= ruleParameterStringType EOF ) - // InternalRos.g:3501:2: iv_ruleParameterStringType= ruleParameterStringType EOF + // InternalRosParser.g:2745:60: (iv_ruleParameterStringType= ruleParameterStringType EOF ) + // InternalRosParser.g:2746:2: iv_ruleParameterStringType= ruleParameterStringType EOF { newCompositeNode(grammarAccess.getParameterStringTypeRule()); pushFollow(FOLLOW_1); @@ -8575,7 +6910,7 @@ public final EObject entryRuleParameterStringType() throws RecognitionException // $ANTLR start "ruleParameterStringType" - // InternalRos.g:3507:1: ruleParameterStringType returns [EObject current=null] : ( () otherlv_1= 'String' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterString ) ) )? ) ; + // InternalRosParser.g:2752:1: ruleParameterStringType returns [EObject current=null] : ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) ; public final EObject ruleParameterStringType() throws RecognitionException { EObject current = null; @@ -8588,14 +6923,14 @@ public final EObject ruleParameterStringType() throws RecognitionException { enterRule(); try { - // InternalRos.g:3513:2: ( ( () otherlv_1= 'String' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterString ) ) )? ) ) - // InternalRos.g:3514:2: ( () otherlv_1= 'String' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterString ) ) )? ) + // InternalRosParser.g:2758:2: ( ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) ) + // InternalRosParser.g:2759:2: ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) { - // InternalRos.g:3514:2: ( () otherlv_1= 'String' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterString ) ) )? ) - // InternalRos.g:3515:3: () otherlv_1= 'String' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterString ) ) )? + // InternalRosParser.g:2759:2: ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) + // InternalRosParser.g:2760:3: () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? { - // InternalRos.g:3515:3: () - // InternalRos.g:3516:4: + // InternalRosParser.g:2760:3: () + // InternalRosParser.g:2761:4: { current = forceCreateModelElement( @@ -8605,34 +6940,34 @@ public final EObject ruleParameterStringType() throws RecognitionException { } - otherlv_1=(Token)match(input,42,FOLLOW_52); + otherlv_1=(Token)match(input,String,FOLLOW_40); newLeafNode(otherlv_1, grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); - // InternalRos.g:3526:3: (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterString ) ) )? - int alt70=2; - int LA70_0 = input.LA(1); + // InternalRosParser.g:2771:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? + int alt47=2; + int LA47_0 = input.LA(1); - if ( (LA70_0==77) ) { - int LA70_1 = input.LA(2); + if ( (LA47_0==Default) ) { + int LA47_1 = input.LA(2); - if ( ((LA70_1>=RULE_STRING && LA70_1<=RULE_ID)) ) { - alt70=1; + if ( (LA47_1==RULE_ID||LA47_1==RULE_STRING) ) { + alt47=1; } } - switch (alt70) { + switch (alt47) { case 1 : - // InternalRos.g:3527:4: otherlv_2= 'default' ( (lv_default_3_0= ruleParameterString ) ) + // InternalRosParser.g:2772:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) { - otherlv_2=(Token)match(input,77,FOLLOW_7); + otherlv_2=(Token)match(input,Default,FOLLOW_7); newLeafNode(otherlv_2, grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); - // InternalRos.g:3531:4: ( (lv_default_3_0= ruleParameterString ) ) - // InternalRos.g:3532:5: (lv_default_3_0= ruleParameterString ) + // InternalRosParser.g:2776:4: ( (lv_default_3_0= ruleParameterString ) ) + // InternalRosParser.g:2777:5: (lv_default_3_0= ruleParameterString ) { - // InternalRos.g:3532:5: (lv_default_3_0= ruleParameterString ) - // InternalRos.g:3533:6: lv_default_3_0= ruleParameterString + // InternalRosParser.g:2777:5: (lv_default_3_0= ruleParameterString ) + // InternalRosParser.g:2778:6: lv_default_3_0= ruleParameterString { newCompositeNode(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); @@ -8688,7 +7023,7 @@ public final EObject ruleParameterStringType() throws RecognitionException { // $ANTLR start "entryRuleParameterDoubleType" - // InternalRos.g:3555:1: entryRuleParameterDoubleType returns [EObject current=null] : iv_ruleParameterDoubleType= ruleParameterDoubleType EOF ; + // InternalRosParser.g:2800:1: entryRuleParameterDoubleType returns [EObject current=null] : iv_ruleParameterDoubleType= ruleParameterDoubleType EOF ; public final EObject entryRuleParameterDoubleType() throws RecognitionException { EObject current = null; @@ -8696,8 +7031,8 @@ public final EObject entryRuleParameterDoubleType() throws RecognitionException try { - // InternalRos.g:3555:60: (iv_ruleParameterDoubleType= ruleParameterDoubleType EOF ) - // InternalRos.g:3556:2: iv_ruleParameterDoubleType= ruleParameterDoubleType EOF + // InternalRosParser.g:2800:60: (iv_ruleParameterDoubleType= ruleParameterDoubleType EOF ) + // InternalRosParser.g:2801:2: iv_ruleParameterDoubleType= ruleParameterDoubleType EOF { newCompositeNode(grammarAccess.getParameterDoubleTypeRule()); pushFollow(FOLLOW_1); @@ -8724,7 +7059,7 @@ public final EObject entryRuleParameterDoubleType() throws RecognitionException // $ANTLR start "ruleParameterDoubleType" - // InternalRos.g:3562:1: ruleParameterDoubleType returns [EObject current=null] : ( () otherlv_1= 'Double' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterDouble ) ) )? ) ; + // InternalRosParser.g:2807:1: ruleParameterDoubleType returns [EObject current=null] : ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) ; public final EObject ruleParameterDoubleType() throws RecognitionException { EObject current = null; @@ -8737,14 +7072,14 @@ public final EObject ruleParameterDoubleType() throws RecognitionException { enterRule(); try { - // InternalRos.g:3568:2: ( ( () otherlv_1= 'Double' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterDouble ) ) )? ) ) - // InternalRos.g:3569:2: ( () otherlv_1= 'Double' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterDouble ) ) )? ) + // InternalRosParser.g:2813:2: ( ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) ) + // InternalRosParser.g:2814:2: ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) { - // InternalRos.g:3569:2: ( () otherlv_1= 'Double' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterDouble ) ) )? ) - // InternalRos.g:3570:3: () otherlv_1= 'Double' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterDouble ) ) )? + // InternalRosParser.g:2814:2: ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) + // InternalRosParser.g:2815:3: () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? { - // InternalRos.g:3570:3: () - // InternalRos.g:3571:4: + // InternalRosParser.g:2815:3: () + // InternalRosParser.g:2816:4: { current = forceCreateModelElement( @@ -8754,34 +7089,34 @@ public final EObject ruleParameterDoubleType() throws RecognitionException { } - otherlv_1=(Token)match(input,78,FOLLOW_52); + otherlv_1=(Token)match(input,Double,FOLLOW_40); newLeafNode(otherlv_1, grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); - // InternalRos.g:3581:3: (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterDouble ) ) )? - int alt71=2; - int LA71_0 = input.LA(1); + // InternalRosParser.g:2826:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? + int alt48=2; + int LA48_0 = input.LA(1); - if ( (LA71_0==77) ) { - int LA71_1 = input.LA(2); + if ( (LA48_0==Default) ) { + int LA48_1 = input.LA(2); - if ( (LA71_1==RULE_DOUBLE) ) { - alt71=1; + if ( (LA48_1==RULE_DOUBLE) ) { + alt48=1; } } - switch (alt71) { + switch (alt48) { case 1 : - // InternalRos.g:3582:4: otherlv_2= 'default' ( (lv_default_3_0= ruleParameterDouble ) ) + // InternalRosParser.g:2827:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) { - otherlv_2=(Token)match(input,77,FOLLOW_54); + otherlv_2=(Token)match(input,Default,FOLLOW_42); newLeafNode(otherlv_2, grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); - // InternalRos.g:3586:4: ( (lv_default_3_0= ruleParameterDouble ) ) - // InternalRos.g:3587:5: (lv_default_3_0= ruleParameterDouble ) + // InternalRosParser.g:2831:4: ( (lv_default_3_0= ruleParameterDouble ) ) + // InternalRosParser.g:2832:5: (lv_default_3_0= ruleParameterDouble ) { - // InternalRos.g:3587:5: (lv_default_3_0= ruleParameterDouble ) - // InternalRos.g:3588:6: lv_default_3_0= ruleParameterDouble + // InternalRosParser.g:2832:5: (lv_default_3_0= ruleParameterDouble ) + // InternalRosParser.g:2833:6: lv_default_3_0= ruleParameterDouble { newCompositeNode(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); @@ -8837,7 +7172,7 @@ public final EObject ruleParameterDoubleType() throws RecognitionException { // $ANTLR start "entryRuleParameterBooleanType" - // InternalRos.g:3610:1: entryRuleParameterBooleanType returns [EObject current=null] : iv_ruleParameterBooleanType= ruleParameterBooleanType EOF ; + // InternalRosParser.g:2855:1: entryRuleParameterBooleanType returns [EObject current=null] : iv_ruleParameterBooleanType= ruleParameterBooleanType EOF ; public final EObject entryRuleParameterBooleanType() throws RecognitionException { EObject current = null; @@ -8845,8 +7180,8 @@ public final EObject entryRuleParameterBooleanType() throws RecognitionException try { - // InternalRos.g:3610:61: (iv_ruleParameterBooleanType= ruleParameterBooleanType EOF ) - // InternalRos.g:3611:2: iv_ruleParameterBooleanType= ruleParameterBooleanType EOF + // InternalRosParser.g:2855:61: (iv_ruleParameterBooleanType= ruleParameterBooleanType EOF ) + // InternalRosParser.g:2856:2: iv_ruleParameterBooleanType= ruleParameterBooleanType EOF { newCompositeNode(grammarAccess.getParameterBooleanTypeRule()); pushFollow(FOLLOW_1); @@ -8873,7 +7208,7 @@ public final EObject entryRuleParameterBooleanType() throws RecognitionException // $ANTLR start "ruleParameterBooleanType" - // InternalRos.g:3617:1: ruleParameterBooleanType returns [EObject current=null] : ( () otherlv_1= 'Boolean' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) ; + // InternalRosParser.g:2862:1: ruleParameterBooleanType returns [EObject current=null] : ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) ; public final EObject ruleParameterBooleanType() throws RecognitionException { EObject current = null; @@ -8886,14 +7221,14 @@ public final EObject ruleParameterBooleanType() throws RecognitionException { enterRule(); try { - // InternalRos.g:3623:2: ( ( () otherlv_1= 'Boolean' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) ) - // InternalRos.g:3624:2: ( () otherlv_1= 'Boolean' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) + // InternalRosParser.g:2868:2: ( ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) ) + // InternalRosParser.g:2869:2: ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) { - // InternalRos.g:3624:2: ( () otherlv_1= 'Boolean' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) - // InternalRos.g:3625:3: () otherlv_1= 'Boolean' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBoolean ) ) )? + // InternalRosParser.g:2869:2: ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) + // InternalRosParser.g:2870:3: () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? { - // InternalRos.g:3625:3: () - // InternalRos.g:3626:4: + // InternalRosParser.g:2870:3: () + // InternalRosParser.g:2871:4: { current = forceCreateModelElement( @@ -8903,34 +7238,34 @@ public final EObject ruleParameterBooleanType() throws RecognitionException { } - otherlv_1=(Token)match(input,79,FOLLOW_52); + otherlv_1=(Token)match(input,Boolean,FOLLOW_40); newLeafNode(otherlv_1, grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); - // InternalRos.g:3636:3: (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBoolean ) ) )? - int alt72=2; - int LA72_0 = input.LA(1); + // InternalRosParser.g:2881:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? + int alt49=2; + int LA49_0 = input.LA(1); - if ( (LA72_0==77) ) { - int LA72_1 = input.LA(2); + if ( (LA49_0==Default) ) { + int LA49_1 = input.LA(2); - if ( (LA72_1==RULE_BOOLEAN) ) { - alt72=1; + if ( (LA49_1==RULE_BOOLEAN) ) { + alt49=1; } } - switch (alt72) { + switch (alt49) { case 1 : - // InternalRos.g:3637:4: otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBoolean ) ) + // InternalRosParser.g:2882:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) { - otherlv_2=(Token)match(input,77,FOLLOW_55); + otherlv_2=(Token)match(input,Default,FOLLOW_43); newLeafNode(otherlv_2, grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); - // InternalRos.g:3641:4: ( (lv_default_3_0= ruleParameterBoolean ) ) - // InternalRos.g:3642:5: (lv_default_3_0= ruleParameterBoolean ) + // InternalRosParser.g:2886:4: ( (lv_default_3_0= ruleParameterBoolean ) ) + // InternalRosParser.g:2887:5: (lv_default_3_0= ruleParameterBoolean ) { - // InternalRos.g:3642:5: (lv_default_3_0= ruleParameterBoolean ) - // InternalRos.g:3643:6: lv_default_3_0= ruleParameterBoolean + // InternalRosParser.g:2887:5: (lv_default_3_0= ruleParameterBoolean ) + // InternalRosParser.g:2888:6: lv_default_3_0= ruleParameterBoolean { newCompositeNode(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); @@ -8986,7 +7321,7 @@ public final EObject ruleParameterBooleanType() throws RecognitionException { // $ANTLR start "entryRuleParameterBase64Type" - // InternalRos.g:3665:1: entryRuleParameterBase64Type returns [EObject current=null] : iv_ruleParameterBase64Type= ruleParameterBase64Type EOF ; + // InternalRosParser.g:2910:1: entryRuleParameterBase64Type returns [EObject current=null] : iv_ruleParameterBase64Type= ruleParameterBase64Type EOF ; public final EObject entryRuleParameterBase64Type() throws RecognitionException { EObject current = null; @@ -8994,8 +7329,8 @@ public final EObject entryRuleParameterBase64Type() throws RecognitionException try { - // InternalRos.g:3665:60: (iv_ruleParameterBase64Type= ruleParameterBase64Type EOF ) - // InternalRos.g:3666:2: iv_ruleParameterBase64Type= ruleParameterBase64Type EOF + // InternalRosParser.g:2910:60: (iv_ruleParameterBase64Type= ruleParameterBase64Type EOF ) + // InternalRosParser.g:2911:2: iv_ruleParameterBase64Type= ruleParameterBase64Type EOF { newCompositeNode(grammarAccess.getParameterBase64TypeRule()); pushFollow(FOLLOW_1); @@ -9022,7 +7357,7 @@ public final EObject entryRuleParameterBase64Type() throws RecognitionException // $ANTLR start "ruleParameterBase64Type" - // InternalRos.g:3672:1: ruleParameterBase64Type returns [EObject current=null] : ( () otherlv_1= 'Base64' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) ; + // InternalRosParser.g:2917:1: ruleParameterBase64Type returns [EObject current=null] : ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) ; public final EObject ruleParameterBase64Type() throws RecognitionException { EObject current = null; @@ -9035,14 +7370,14 @@ public final EObject ruleParameterBase64Type() throws RecognitionException { enterRule(); try { - // InternalRos.g:3678:2: ( ( () otherlv_1= 'Base64' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) ) - // InternalRos.g:3679:2: ( () otherlv_1= 'Base64' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) + // InternalRosParser.g:2923:2: ( ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) ) + // InternalRosParser.g:2924:2: ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) { - // InternalRos.g:3679:2: ( () otherlv_1= 'Base64' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) - // InternalRos.g:3680:3: () otherlv_1= 'Base64' (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBase64 ) ) )? + // InternalRosParser.g:2924:2: ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) + // InternalRosParser.g:2925:3: () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? { - // InternalRos.g:3680:3: () - // InternalRos.g:3681:4: + // InternalRosParser.g:2925:3: () + // InternalRosParser.g:2926:4: { current = forceCreateModelElement( @@ -9052,34 +7387,34 @@ public final EObject ruleParameterBase64Type() throws RecognitionException { } - otherlv_1=(Token)match(input,80,FOLLOW_52); + otherlv_1=(Token)match(input,Base64,FOLLOW_40); newLeafNode(otherlv_1, grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); - // InternalRos.g:3691:3: (otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBase64 ) ) )? - int alt73=2; - int LA73_0 = input.LA(1); + // InternalRosParser.g:2936:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? + int alt50=2; + int LA50_0 = input.LA(1); - if ( (LA73_0==77) ) { - int LA73_1 = input.LA(2); + if ( (LA50_0==Default) ) { + int LA50_1 = input.LA(2); - if ( (LA73_1==RULE_BINARY) ) { - alt73=1; + if ( (LA50_1==RULE_BINARY) ) { + alt50=1; } } - switch (alt73) { + switch (alt50) { case 1 : - // InternalRos.g:3692:4: otherlv_2= 'default' ( (lv_default_3_0= ruleParameterBase64 ) ) + // InternalRosParser.g:2937:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) { - otherlv_2=(Token)match(input,77,FOLLOW_56); + otherlv_2=(Token)match(input,Default,FOLLOW_44); newLeafNode(otherlv_2, grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); - // InternalRos.g:3696:4: ( (lv_default_3_0= ruleParameterBase64 ) ) - // InternalRos.g:3697:5: (lv_default_3_0= ruleParameterBase64 ) + // InternalRosParser.g:2941:4: ( (lv_default_3_0= ruleParameterBase64 ) ) + // InternalRosParser.g:2942:5: (lv_default_3_0= ruleParameterBase64 ) { - // InternalRos.g:3697:5: (lv_default_3_0= ruleParameterBase64 ) - // InternalRos.g:3698:6: lv_default_3_0= ruleParameterBase64 + // InternalRosParser.g:2942:5: (lv_default_3_0= ruleParameterBase64 ) + // InternalRosParser.g:2943:6: lv_default_3_0= ruleParameterBase64 { newCompositeNode(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); @@ -9135,7 +7470,7 @@ public final EObject ruleParameterBase64Type() throws RecognitionException { // $ANTLR start "entryRuleParameterArrayType" - // InternalRos.g:3720:1: entryRuleParameterArrayType returns [EObject current=null] : iv_ruleParameterArrayType= ruleParameterArrayType EOF ; + // InternalRosParser.g:2965:1: entryRuleParameterArrayType returns [EObject current=null] : iv_ruleParameterArrayType= ruleParameterArrayType EOF ; public final EObject entryRuleParameterArrayType() throws RecognitionException { EObject current = null; @@ -9143,8 +7478,8 @@ public final EObject entryRuleParameterArrayType() throws RecognitionException { try { - // InternalRos.g:3720:59: (iv_ruleParameterArrayType= ruleParameterArrayType EOF ) - // InternalRos.g:3721:2: iv_ruleParameterArrayType= ruleParameterArrayType EOF + // InternalRosParser.g:2965:59: (iv_ruleParameterArrayType= ruleParameterArrayType EOF ) + // InternalRosParser.g:2966:2: iv_ruleParameterArrayType= ruleParameterArrayType EOF { newCompositeNode(grammarAccess.getParameterArrayTypeRule()); pushFollow(FOLLOW_1); @@ -9171,15 +7506,15 @@ public final EObject entryRuleParameterArrayType() throws RecognitionException { // $ANTLR start "ruleParameterArrayType" - // InternalRos.g:3727:1: ruleParameterArrayType returns [EObject current=null] : (otherlv_0= 'Array' otherlv_1= '{' otherlv_2= 'type' ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= 'default' ( (lv_default_5_0= ruleParameterList ) ) )? otherlv_6= '}' ) ; + // InternalRosParser.g:2972:1: ruleParameterArrayType returns [EObject current=null] : (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) ; public final EObject ruleParameterArrayType() throws RecognitionException { EObject current = null; Token otherlv_0=null; - Token otherlv_1=null; + Token this_BEGIN_1=null; Token otherlv_2=null; Token otherlv_4=null; - Token otherlv_6=null; + Token this_END_6=null; EObject lv_type_3_0 = null; EObject lv_default_5_0 = null; @@ -9189,34 +7524,34 @@ public final EObject ruleParameterArrayType() throws RecognitionException { enterRule(); try { - // InternalRos.g:3733:2: ( (otherlv_0= 'Array' otherlv_1= '{' otherlv_2= 'type' ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= 'default' ( (lv_default_5_0= ruleParameterList ) ) )? otherlv_6= '}' ) ) - // InternalRos.g:3734:2: (otherlv_0= 'Array' otherlv_1= '{' otherlv_2= 'type' ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= 'default' ( (lv_default_5_0= ruleParameterList ) ) )? otherlv_6= '}' ) + // InternalRosParser.g:2978:2: ( (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) ) + // InternalRosParser.g:2979:2: (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) { - // InternalRos.g:3734:2: (otherlv_0= 'Array' otherlv_1= '{' otherlv_2= 'type' ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= 'default' ( (lv_default_5_0= ruleParameterList ) ) )? otherlv_6= '}' ) - // InternalRos.g:3735:3: otherlv_0= 'Array' otherlv_1= '{' otherlv_2= 'type' ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= 'default' ( (lv_default_5_0= ruleParameterList ) ) )? otherlv_6= '}' + // InternalRosParser.g:2979:2: (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) + // InternalRosParser.g:2980:3: otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END { - otherlv_0=(Token)match(input,81,FOLLOW_3); + otherlv_0=(Token)match(input,Array,FOLLOW_5); newLeafNode(otherlv_0, grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); - otherlv_1=(Token)match(input,26,FOLLOW_50); + this_BEGIN_1=(Token)match(input,RULE_BEGIN,FOLLOW_37); - newLeafNode(otherlv_1, grammarAccess.getParameterArrayTypeAccess().getLeftCurlyBracketKeyword_1()); + newLeafNode(this_BEGIN_1, grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); - otherlv_2=(Token)match(input,73,FOLLOW_51); + otherlv_2=(Token)match(input,Type,FOLLOW_38); newLeafNode(otherlv_2, grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); - // InternalRos.g:3747:3: ( (lv_type_3_0= ruleParameterType ) ) - // InternalRos.g:3748:4: (lv_type_3_0= ruleParameterType ) + // InternalRosParser.g:2992:3: ( (lv_type_3_0= ruleParameterType ) ) + // InternalRosParser.g:2993:4: (lv_type_3_0= ruleParameterType ) { - // InternalRos.g:3748:4: (lv_type_3_0= ruleParameterType ) - // InternalRos.g:3749:5: lv_type_3_0= ruleParameterType + // InternalRosParser.g:2993:4: (lv_type_3_0= ruleParameterType ) + // InternalRosParser.g:2994:5: lv_type_3_0= ruleParameterType { newCompositeNode(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); - pushFollow(FOLLOW_57); + pushFollow(FOLLOW_45); lv_type_3_0=ruleParameterType(); state._fsp--; @@ -9238,31 +7573,31 @@ public final EObject ruleParameterArrayType() throws RecognitionException { } - // InternalRos.g:3766:3: (otherlv_4= 'default' ( (lv_default_5_0= ruleParameterList ) ) )? - int alt74=2; - int LA74_0 = input.LA(1); + // InternalRosParser.g:3011:3: (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? + int alt51=2; + int LA51_0 = input.LA(1); - if ( (LA74_0==77) ) { - alt74=1; + if ( (LA51_0==Default) ) { + alt51=1; } - switch (alt74) { + switch (alt51) { case 1 : - // InternalRos.g:3767:4: otherlv_4= 'default' ( (lv_default_5_0= ruleParameterList ) ) + // InternalRosParser.g:3012:4: otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) { - otherlv_4=(Token)match(input,77,FOLLOW_3); + otherlv_4=(Token)match(input,Default,FOLLOW_11); newLeafNode(otherlv_4, grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); - // InternalRos.g:3771:4: ( (lv_default_5_0= ruleParameterList ) ) - // InternalRos.g:3772:5: (lv_default_5_0= ruleParameterList ) + // InternalRosParser.g:3016:4: ( (lv_default_5_0= ruleParameterList ) ) + // InternalRosParser.g:3017:5: (lv_default_5_0= ruleParameterList ) { - // InternalRos.g:3772:5: (lv_default_5_0= ruleParameterList ) - // InternalRos.g:3773:6: lv_default_5_0= ruleParameterList + // InternalRosParser.g:3017:5: (lv_default_5_0= ruleParameterList ) + // InternalRosParser.g:3018:6: lv_default_5_0= ruleParameterList { newCompositeNode(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); - pushFollow(FOLLOW_15); + pushFollow(FOLLOW_14); lv_default_5_0=ruleParameterList(); state._fsp--; @@ -9290,9 +7625,9 @@ public final EObject ruleParameterArrayType() throws RecognitionException { } - otherlv_6=(Token)match(input,28,FOLLOW_2); + this_END_6=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_6, grammarAccess.getParameterArrayTypeAccess().getRightCurlyBracketKeyword_5()); + newLeafNode(this_END_6, grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); } @@ -9317,7 +7652,7 @@ public final EObject ruleParameterArrayType() throws RecognitionException { // $ANTLR start "entryRuleParameterList" - // InternalRos.g:3799:1: entryRuleParameterList returns [EObject current=null] : iv_ruleParameterList= ruleParameterList EOF ; + // InternalRosParser.g:3044:1: entryRuleParameterList returns [EObject current=null] : iv_ruleParameterList= ruleParameterList EOF ; public final EObject entryRuleParameterList() throws RecognitionException { EObject current = null; @@ -9325,8 +7660,8 @@ public final EObject entryRuleParameterList() throws RecognitionException { try { - // InternalRos.g:3799:54: (iv_ruleParameterList= ruleParameterList EOF ) - // InternalRos.g:3800:2: iv_ruleParameterList= ruleParameterList EOF + // InternalRosParser.g:3044:54: (iv_ruleParameterList= ruleParameterList EOF ) + // InternalRosParser.g:3045:2: iv_ruleParameterList= ruleParameterList EOF { newCompositeNode(grammarAccess.getParameterListRule()); pushFollow(FOLLOW_1); @@ -9353,7 +7688,7 @@ public final EObject entryRuleParameterList() throws RecognitionException { // $ANTLR start "ruleParameterList" - // InternalRos.g:3806:1: ruleParameterList returns [EObject current=null] : ( () otherlv_1= '{' ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= ',' ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= '}' ) ; + // InternalRosParser.g:3051:1: ruleParameterList returns [EObject current=null] : ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) ; public final EObject ruleParameterList() throws RecognitionException { EObject current = null; @@ -9369,14 +7704,14 @@ public final EObject ruleParameterList() throws RecognitionException { enterRule(); try { - // InternalRos.g:3812:2: ( ( () otherlv_1= '{' ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= ',' ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= '}' ) ) - // InternalRos.g:3813:2: ( () otherlv_1= '{' ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= ',' ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= '}' ) + // InternalRosParser.g:3057:2: ( ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) ) + // InternalRosParser.g:3058:2: ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) { - // InternalRos.g:3813:2: ( () otherlv_1= '{' ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= ',' ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= '}' ) - // InternalRos.g:3814:3: () otherlv_1= '{' ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= ',' ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= '}' + // InternalRosParser.g:3058:2: ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) + // InternalRosParser.g:3059:3: () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket { - // InternalRos.g:3814:3: () - // InternalRos.g:3815:4: + // InternalRosParser.g:3059:3: () + // InternalRosParser.g:3060:4: { current = forceCreateModelElement( @@ -9386,20 +7721,20 @@ public final EObject ruleParameterList() throws RecognitionException { } - otherlv_1=(Token)match(input,26,FOLLOW_58); + otherlv_1=(Token)match(input,LeftSquareBracket,FOLLOW_46); - newLeafNode(otherlv_1, grammarAccess.getParameterListAccess().getLeftCurlyBracketKeyword_1()); + newLeafNode(otherlv_1, grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); - // InternalRos.g:3825:3: ( (lv_value_2_0= ruleParameterValue ) ) - // InternalRos.g:3826:4: (lv_value_2_0= ruleParameterValue ) + // InternalRosParser.g:3070:3: ( (lv_value_2_0= ruleParameterValue ) ) + // InternalRosParser.g:3071:4: (lv_value_2_0= ruleParameterValue ) { - // InternalRos.g:3826:4: (lv_value_2_0= ruleParameterValue ) - // InternalRos.g:3827:5: lv_value_2_0= ruleParameterValue + // InternalRosParser.g:3071:4: (lv_value_2_0= ruleParameterValue ) + // InternalRosParser.g:3072:5: lv_value_2_0= ruleParameterValue { newCompositeNode(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); - pushFollow(FOLLOW_5); + pushFollow(FOLLOW_13); lv_value_2_0=ruleParameterValue(); state._fsp--; @@ -9421,35 +7756,35 @@ public final EObject ruleParameterList() throws RecognitionException { } - // InternalRos.g:3844:3: (otherlv_3= ',' ( (lv_value_4_0= ruleParameterValue ) ) )* - loop75: + // InternalRosParser.g:3089:3: (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* + loop52: do { - int alt75=2; - int LA75_0 = input.LA(1); + int alt52=2; + int LA52_0 = input.LA(1); - if ( (LA75_0==27) ) { - alt75=1; + if ( (LA52_0==Comma) ) { + alt52=1; } - switch (alt75) { + switch (alt52) { case 1 : - // InternalRos.g:3845:4: otherlv_3= ',' ( (lv_value_4_0= ruleParameterValue ) ) + // InternalRosParser.g:3090:4: otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) { - otherlv_3=(Token)match(input,27,FOLLOW_58); + otherlv_3=(Token)match(input,Comma,FOLLOW_46); newLeafNode(otherlv_3, grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); - // InternalRos.g:3849:4: ( (lv_value_4_0= ruleParameterValue ) ) - // InternalRos.g:3850:5: (lv_value_4_0= ruleParameterValue ) + // InternalRosParser.g:3094:4: ( (lv_value_4_0= ruleParameterValue ) ) + // InternalRosParser.g:3095:5: (lv_value_4_0= ruleParameterValue ) { - // InternalRos.g:3850:5: (lv_value_4_0= ruleParameterValue ) - // InternalRos.g:3851:6: lv_value_4_0= ruleParameterValue + // InternalRosParser.g:3095:5: (lv_value_4_0= ruleParameterValue ) + // InternalRosParser.g:3096:6: lv_value_4_0= ruleParameterValue { newCompositeNode(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); - pushFollow(FOLLOW_5); + pushFollow(FOLLOW_13); lv_value_4_0=ruleParameterValue(); state._fsp--; @@ -9476,13 +7811,13 @@ public final EObject ruleParameterList() throws RecognitionException { break; default : - break loop75; + break loop52; } } while (true); - otherlv_5=(Token)match(input,28,FOLLOW_2); + otherlv_5=(Token)match(input,RightSquareBracket,FOLLOW_2); - newLeafNode(otherlv_5, grammarAccess.getParameterListAccess().getRightCurlyBracketKeyword_4()); + newLeafNode(otherlv_5, grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); } @@ -9507,7 +7842,7 @@ public final EObject ruleParameterList() throws RecognitionException { // $ANTLR start "entryRuleParameterAny" - // InternalRos.g:3877:1: entryRuleParameterAny returns [EObject current=null] : iv_ruleParameterAny= ruleParameterAny EOF ; + // InternalRosParser.g:3122:1: entryRuleParameterAny returns [EObject current=null] : iv_ruleParameterAny= ruleParameterAny EOF ; public final EObject entryRuleParameterAny() throws RecognitionException { EObject current = null; @@ -9515,8 +7850,8 @@ public final EObject entryRuleParameterAny() throws RecognitionException { try { - // InternalRos.g:3877:53: (iv_ruleParameterAny= ruleParameterAny EOF ) - // InternalRos.g:3878:2: iv_ruleParameterAny= ruleParameterAny EOF + // InternalRosParser.g:3122:53: (iv_ruleParameterAny= ruleParameterAny EOF ) + // InternalRosParser.g:3123:2: iv_ruleParameterAny= ruleParameterAny EOF { newCompositeNode(grammarAccess.getParameterAnyRule()); pushFollow(FOLLOW_1); @@ -9543,29 +7878,27 @@ public final EObject entryRuleParameterAny() throws RecognitionException { // $ANTLR start "ruleParameterAny" - // InternalRos.g:3884:1: ruleParameterAny returns [EObject current=null] : ( () otherlv_1= 'ParameterAny' otherlv_2= '{' (otherlv_3= 'value' ( (lv_value_4_0= ruleEString ) ) )? otherlv_5= '}' ) ; + // InternalRosParser.g:3129:1: ruleParameterAny returns [EObject current=null] : ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) ; public final EObject ruleParameterAny() throws RecognitionException { EObject current = null; Token otherlv_1=null; Token otherlv_2=null; - Token otherlv_3=null; - Token otherlv_5=null; - AntlrDatatypeRuleToken lv_value_4_0 = null; + AntlrDatatypeRuleToken lv_value_3_0 = null; enterRule(); try { - // InternalRos.g:3890:2: ( ( () otherlv_1= 'ParameterAny' otherlv_2= '{' (otherlv_3= 'value' ( (lv_value_4_0= ruleEString ) ) )? otherlv_5= '}' ) ) - // InternalRos.g:3891:2: ( () otherlv_1= 'ParameterAny' otherlv_2= '{' (otherlv_3= 'value' ( (lv_value_4_0= ruleEString ) ) )? otherlv_5= '}' ) + // InternalRosParser.g:3135:2: ( ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) ) + // InternalRosParser.g:3136:2: ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) { - // InternalRos.g:3891:2: ( () otherlv_1= 'ParameterAny' otherlv_2= '{' (otherlv_3= 'value' ( (lv_value_4_0= ruleEString ) ) )? otherlv_5= '}' ) - // InternalRos.g:3892:3: () otherlv_1= 'ParameterAny' otherlv_2= '{' (otherlv_3= 'value' ( (lv_value_4_0= ruleEString ) ) )? otherlv_5= '}' + // InternalRosParser.g:3136:2: ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) + // InternalRosParser.g:3137:3: () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? { - // InternalRos.g:3892:3: () - // InternalRos.g:3893:4: + // InternalRosParser.g:3137:3: () + // InternalRosParser.g:3138:4: { current = forceCreateModelElement( @@ -9575,40 +7908,36 @@ public final EObject ruleParameterAny() throws RecognitionException { } - otherlv_1=(Token)match(input,82,FOLLOW_3); + otherlv_1=(Token)match(input,ParameterAny,FOLLOW_47); newLeafNode(otherlv_1, grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); - otherlv_2=(Token)match(input,26,FOLLOW_59); - - newLeafNode(otherlv_2, grammarAccess.getParameterAnyAccess().getLeftCurlyBracketKeyword_2()); - - // InternalRos.g:3907:3: (otherlv_3= 'value' ( (lv_value_4_0= ruleEString ) ) )? - int alt76=2; - int LA76_0 = input.LA(1); + // InternalRosParser.g:3148:3: (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? + int alt53=2; + int LA53_0 = input.LA(1); - if ( (LA76_0==83) ) { - alt76=1; + if ( (LA53_0==Value) ) { + alt53=1; } - switch (alt76) { + switch (alt53) { case 1 : - // InternalRos.g:3908:4: otherlv_3= 'value' ( (lv_value_4_0= ruleEString ) ) + // InternalRosParser.g:3149:4: otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) { - otherlv_3=(Token)match(input,83,FOLLOW_7); + otherlv_2=(Token)match(input,Value,FOLLOW_7); - newLeafNode(otherlv_3, grammarAccess.getParameterAnyAccess().getValueKeyword_3_0()); + newLeafNode(otherlv_2, grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); - // InternalRos.g:3912:4: ( (lv_value_4_0= ruleEString ) ) - // InternalRos.g:3913:5: (lv_value_4_0= ruleEString ) + // InternalRosParser.g:3153:4: ( (lv_value_3_0= ruleEString ) ) + // InternalRosParser.g:3154:5: (lv_value_3_0= ruleEString ) { - // InternalRos.g:3913:5: (lv_value_4_0= ruleEString ) - // InternalRos.g:3914:6: lv_value_4_0= ruleEString + // InternalRosParser.g:3154:5: (lv_value_3_0= ruleEString ) + // InternalRosParser.g:3155:6: lv_value_3_0= ruleEString { - newCompositeNode(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_3_1_0()); + newCompositeNode(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); - pushFollow(FOLLOW_15); - lv_value_4_0=ruleEString(); + pushFollow(FOLLOW_2); + lv_value_3_0=ruleEString(); state._fsp--; @@ -9619,7 +7948,7 @@ public final EObject ruleParameterAny() throws RecognitionException { set( current, "value", - lv_value_4_0, + lv_value_3_0, "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); @@ -9635,10 +7964,6 @@ public final EObject ruleParameterAny() throws RecognitionException { } - otherlv_5=(Token)match(input,28,FOLLOW_2); - - newLeafNode(otherlv_5, grammarAccess.getParameterAnyAccess().getRightCurlyBracketKeyword_4()); - } @@ -9662,7 +7987,7 @@ public final EObject ruleParameterAny() throws RecognitionException { // $ANTLR start "entryRuleParameterString" - // InternalRos.g:3940:1: entryRuleParameterString returns [EObject current=null] : iv_ruleParameterString= ruleParameterString EOF ; + // InternalRosParser.g:3177:1: entryRuleParameterString returns [EObject current=null] : iv_ruleParameterString= ruleParameterString EOF ; public final EObject entryRuleParameterString() throws RecognitionException { EObject current = null; @@ -9670,8 +7995,8 @@ public final EObject entryRuleParameterString() throws RecognitionException { try { - // InternalRos.g:3940:56: (iv_ruleParameterString= ruleParameterString EOF ) - // InternalRos.g:3941:2: iv_ruleParameterString= ruleParameterString EOF + // InternalRosParser.g:3177:56: (iv_ruleParameterString= ruleParameterString EOF ) + // InternalRosParser.g:3178:2: iv_ruleParameterString= ruleParameterString EOF { newCompositeNode(grammarAccess.getParameterStringRule()); pushFollow(FOLLOW_1); @@ -9698,7 +8023,7 @@ public final EObject entryRuleParameterString() throws RecognitionException { // $ANTLR start "ruleParameterString" - // InternalRos.g:3947:1: ruleParameterString returns [EObject current=null] : ( (lv_value_0_0= ruleEString ) ) ; + // InternalRosParser.g:3184:1: ruleParameterString returns [EObject current=null] : ( (lv_value_0_0= ruleEString ) ) ; public final EObject ruleParameterString() throws RecognitionException { EObject current = null; @@ -9709,14 +8034,14 @@ public final EObject ruleParameterString() throws RecognitionException { enterRule(); try { - // InternalRos.g:3953:2: ( ( (lv_value_0_0= ruleEString ) ) ) - // InternalRos.g:3954:2: ( (lv_value_0_0= ruleEString ) ) + // InternalRosParser.g:3190:2: ( ( (lv_value_0_0= ruleEString ) ) ) + // InternalRosParser.g:3191:2: ( (lv_value_0_0= ruleEString ) ) { - // InternalRos.g:3954:2: ( (lv_value_0_0= ruleEString ) ) - // InternalRos.g:3955:3: (lv_value_0_0= ruleEString ) + // InternalRosParser.g:3191:2: ( (lv_value_0_0= ruleEString ) ) + // InternalRosParser.g:3192:3: (lv_value_0_0= ruleEString ) { - // InternalRos.g:3955:3: (lv_value_0_0= ruleEString ) - // InternalRos.g:3956:4: lv_value_0_0= ruleEString + // InternalRosParser.g:3192:3: (lv_value_0_0= ruleEString ) + // InternalRosParser.g:3193:4: lv_value_0_0= ruleEString { newCompositeNode(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); @@ -9763,7 +8088,7 @@ public final EObject ruleParameterString() throws RecognitionException { // $ANTLR start "entryRuleParameterBase64" - // InternalRos.g:3976:1: entryRuleParameterBase64 returns [EObject current=null] : iv_ruleParameterBase64= ruleParameterBase64 EOF ; + // InternalRosParser.g:3213:1: entryRuleParameterBase64 returns [EObject current=null] : iv_ruleParameterBase64= ruleParameterBase64 EOF ; public final EObject entryRuleParameterBase64() throws RecognitionException { EObject current = null; @@ -9771,8 +8096,8 @@ public final EObject entryRuleParameterBase64() throws RecognitionException { try { - // InternalRos.g:3976:56: (iv_ruleParameterBase64= ruleParameterBase64 EOF ) - // InternalRos.g:3977:2: iv_ruleParameterBase64= ruleParameterBase64 EOF + // InternalRosParser.g:3213:56: (iv_ruleParameterBase64= ruleParameterBase64 EOF ) + // InternalRosParser.g:3214:2: iv_ruleParameterBase64= ruleParameterBase64 EOF { newCompositeNode(grammarAccess.getParameterBase64Rule()); pushFollow(FOLLOW_1); @@ -9799,7 +8124,7 @@ public final EObject entryRuleParameterBase64() throws RecognitionException { // $ANTLR start "ruleParameterBase64" - // InternalRos.g:3983:1: ruleParameterBase64 returns [EObject current=null] : ( (lv_value_0_0= ruleBase64Binary ) ) ; + // InternalRosParser.g:3220:1: ruleParameterBase64 returns [EObject current=null] : ( (lv_value_0_0= ruleBase64Binary ) ) ; public final EObject ruleParameterBase64() throws RecognitionException { EObject current = null; @@ -9810,14 +8135,14 @@ public final EObject ruleParameterBase64() throws RecognitionException { enterRule(); try { - // InternalRos.g:3989:2: ( ( (lv_value_0_0= ruleBase64Binary ) ) ) - // InternalRos.g:3990:2: ( (lv_value_0_0= ruleBase64Binary ) ) + // InternalRosParser.g:3226:2: ( ( (lv_value_0_0= ruleBase64Binary ) ) ) + // InternalRosParser.g:3227:2: ( (lv_value_0_0= ruleBase64Binary ) ) { - // InternalRos.g:3990:2: ( (lv_value_0_0= ruleBase64Binary ) ) - // InternalRos.g:3991:3: (lv_value_0_0= ruleBase64Binary ) + // InternalRosParser.g:3227:2: ( (lv_value_0_0= ruleBase64Binary ) ) + // InternalRosParser.g:3228:3: (lv_value_0_0= ruleBase64Binary ) { - // InternalRos.g:3991:3: (lv_value_0_0= ruleBase64Binary ) - // InternalRos.g:3992:4: lv_value_0_0= ruleBase64Binary + // InternalRosParser.g:3228:3: (lv_value_0_0= ruleBase64Binary ) + // InternalRosParser.g:3229:4: lv_value_0_0= ruleBase64Binary { newCompositeNode(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); @@ -9864,7 +8189,7 @@ public final EObject ruleParameterBase64() throws RecognitionException { // $ANTLR start "entryRuleParameterInteger" - // InternalRos.g:4012:1: entryRuleParameterInteger returns [EObject current=null] : iv_ruleParameterInteger= ruleParameterInteger EOF ; + // InternalRosParser.g:3249:1: entryRuleParameterInteger returns [EObject current=null] : iv_ruleParameterInteger= ruleParameterInteger EOF ; public final EObject entryRuleParameterInteger() throws RecognitionException { EObject current = null; @@ -9872,8 +8197,8 @@ public final EObject entryRuleParameterInteger() throws RecognitionException { try { - // InternalRos.g:4012:57: (iv_ruleParameterInteger= ruleParameterInteger EOF ) - // InternalRos.g:4013:2: iv_ruleParameterInteger= ruleParameterInteger EOF + // InternalRosParser.g:3249:57: (iv_ruleParameterInteger= ruleParameterInteger EOF ) + // InternalRosParser.g:3250:2: iv_ruleParameterInteger= ruleParameterInteger EOF { newCompositeNode(grammarAccess.getParameterIntegerRule()); pushFollow(FOLLOW_1); @@ -9900,7 +8225,7 @@ public final EObject entryRuleParameterInteger() throws RecognitionException { // $ANTLR start "ruleParameterInteger" - // InternalRos.g:4019:1: ruleParameterInteger returns [EObject current=null] : ( (lv_value_0_0= ruleInteger0 ) ) ; + // InternalRosParser.g:3256:1: ruleParameterInteger returns [EObject current=null] : ( (lv_value_0_0= ruleInteger0 ) ) ; public final EObject ruleParameterInteger() throws RecognitionException { EObject current = null; @@ -9911,14 +8236,14 @@ public final EObject ruleParameterInteger() throws RecognitionException { enterRule(); try { - // InternalRos.g:4025:2: ( ( (lv_value_0_0= ruleInteger0 ) ) ) - // InternalRos.g:4026:2: ( (lv_value_0_0= ruleInteger0 ) ) + // InternalRosParser.g:3262:2: ( ( (lv_value_0_0= ruleInteger0 ) ) ) + // InternalRosParser.g:3263:2: ( (lv_value_0_0= ruleInteger0 ) ) { - // InternalRos.g:4026:2: ( (lv_value_0_0= ruleInteger0 ) ) - // InternalRos.g:4027:3: (lv_value_0_0= ruleInteger0 ) + // InternalRosParser.g:3263:2: ( (lv_value_0_0= ruleInteger0 ) ) + // InternalRosParser.g:3264:3: (lv_value_0_0= ruleInteger0 ) { - // InternalRos.g:4027:3: (lv_value_0_0= ruleInteger0 ) - // InternalRos.g:4028:4: lv_value_0_0= ruleInteger0 + // InternalRosParser.g:3264:3: (lv_value_0_0= ruleInteger0 ) + // InternalRosParser.g:3265:4: lv_value_0_0= ruleInteger0 { newCompositeNode(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); @@ -9965,7 +8290,7 @@ public final EObject ruleParameterInteger() throws RecognitionException { // $ANTLR start "entryRuleParameterDouble" - // InternalRos.g:4048:1: entryRuleParameterDouble returns [EObject current=null] : iv_ruleParameterDouble= ruleParameterDouble EOF ; + // InternalRosParser.g:3285:1: entryRuleParameterDouble returns [EObject current=null] : iv_ruleParameterDouble= ruleParameterDouble EOF ; public final EObject entryRuleParameterDouble() throws RecognitionException { EObject current = null; @@ -9973,8 +8298,8 @@ public final EObject entryRuleParameterDouble() throws RecognitionException { try { - // InternalRos.g:4048:56: (iv_ruleParameterDouble= ruleParameterDouble EOF ) - // InternalRos.g:4049:2: iv_ruleParameterDouble= ruleParameterDouble EOF + // InternalRosParser.g:3285:56: (iv_ruleParameterDouble= ruleParameterDouble EOF ) + // InternalRosParser.g:3286:2: iv_ruleParameterDouble= ruleParameterDouble EOF { newCompositeNode(grammarAccess.getParameterDoubleRule()); pushFollow(FOLLOW_1); @@ -10001,7 +8326,7 @@ public final EObject entryRuleParameterDouble() throws RecognitionException { // $ANTLR start "ruleParameterDouble" - // InternalRos.g:4055:1: ruleParameterDouble returns [EObject current=null] : ( (lv_value_0_0= ruleDouble0 ) ) ; + // InternalRosParser.g:3292:1: ruleParameterDouble returns [EObject current=null] : ( (lv_value_0_0= ruleDouble0 ) ) ; public final EObject ruleParameterDouble() throws RecognitionException { EObject current = null; @@ -10012,14 +8337,14 @@ public final EObject ruleParameterDouble() throws RecognitionException { enterRule(); try { - // InternalRos.g:4061:2: ( ( (lv_value_0_0= ruleDouble0 ) ) ) - // InternalRos.g:4062:2: ( (lv_value_0_0= ruleDouble0 ) ) + // InternalRosParser.g:3298:2: ( ( (lv_value_0_0= ruleDouble0 ) ) ) + // InternalRosParser.g:3299:2: ( (lv_value_0_0= ruleDouble0 ) ) { - // InternalRos.g:4062:2: ( (lv_value_0_0= ruleDouble0 ) ) - // InternalRos.g:4063:3: (lv_value_0_0= ruleDouble0 ) + // InternalRosParser.g:3299:2: ( (lv_value_0_0= ruleDouble0 ) ) + // InternalRosParser.g:3300:3: (lv_value_0_0= ruleDouble0 ) { - // InternalRos.g:4063:3: (lv_value_0_0= ruleDouble0 ) - // InternalRos.g:4064:4: lv_value_0_0= ruleDouble0 + // InternalRosParser.g:3300:3: (lv_value_0_0= ruleDouble0 ) + // InternalRosParser.g:3301:4: lv_value_0_0= ruleDouble0 { newCompositeNode(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); @@ -10066,7 +8391,7 @@ public final EObject ruleParameterDouble() throws RecognitionException { // $ANTLR start "entryRuleParameterBoolean" - // InternalRos.g:4084:1: entryRuleParameterBoolean returns [EObject current=null] : iv_ruleParameterBoolean= ruleParameterBoolean EOF ; + // InternalRosParser.g:3321:1: entryRuleParameterBoolean returns [EObject current=null] : iv_ruleParameterBoolean= ruleParameterBoolean EOF ; public final EObject entryRuleParameterBoolean() throws RecognitionException { EObject current = null; @@ -10074,8 +8399,8 @@ public final EObject entryRuleParameterBoolean() throws RecognitionException { try { - // InternalRos.g:4084:57: (iv_ruleParameterBoolean= ruleParameterBoolean EOF ) - // InternalRos.g:4085:2: iv_ruleParameterBoolean= ruleParameterBoolean EOF + // InternalRosParser.g:3321:57: (iv_ruleParameterBoolean= ruleParameterBoolean EOF ) + // InternalRosParser.g:3322:2: iv_ruleParameterBoolean= ruleParameterBoolean EOF { newCompositeNode(grammarAccess.getParameterBooleanRule()); pushFollow(FOLLOW_1); @@ -10102,7 +8427,7 @@ public final EObject entryRuleParameterBoolean() throws RecognitionException { // $ANTLR start "ruleParameterBoolean" - // InternalRos.g:4091:1: ruleParameterBoolean returns [EObject current=null] : ( (lv_value_0_0= ruleboolean0 ) ) ; + // InternalRosParser.g:3328:1: ruleParameterBoolean returns [EObject current=null] : ( (lv_value_0_0= ruleboolean0 ) ) ; public final EObject ruleParameterBoolean() throws RecognitionException { EObject current = null; @@ -10113,14 +8438,14 @@ public final EObject ruleParameterBoolean() throws RecognitionException { enterRule(); try { - // InternalRos.g:4097:2: ( ( (lv_value_0_0= ruleboolean0 ) ) ) - // InternalRos.g:4098:2: ( (lv_value_0_0= ruleboolean0 ) ) + // InternalRosParser.g:3334:2: ( ( (lv_value_0_0= ruleboolean0 ) ) ) + // InternalRosParser.g:3335:2: ( (lv_value_0_0= ruleboolean0 ) ) { - // InternalRos.g:4098:2: ( (lv_value_0_0= ruleboolean0 ) ) - // InternalRos.g:4099:3: (lv_value_0_0= ruleboolean0 ) + // InternalRosParser.g:3335:2: ( (lv_value_0_0= ruleboolean0 ) ) + // InternalRosParser.g:3336:3: (lv_value_0_0= ruleboolean0 ) { - // InternalRos.g:4099:3: (lv_value_0_0= ruleboolean0 ) - // InternalRos.g:4100:4: lv_value_0_0= ruleboolean0 + // InternalRosParser.g:3336:3: (lv_value_0_0= ruleboolean0 ) + // InternalRosParser.g:3337:4: lv_value_0_0= ruleboolean0 { newCompositeNode(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); @@ -10167,7 +8492,7 @@ public final EObject ruleParameterBoolean() throws RecognitionException { // $ANTLR start "entryRuleParameterStruct" - // InternalRos.g:4120:1: entryRuleParameterStruct returns [EObject current=null] : iv_ruleParameterStruct= ruleParameterStruct EOF ; + // InternalRosParser.g:3357:1: entryRuleParameterStruct returns [EObject current=null] : iv_ruleParameterStruct= ruleParameterStruct EOF ; public final EObject entryRuleParameterStruct() throws RecognitionException { EObject current = null; @@ -10175,8 +8500,8 @@ public final EObject entryRuleParameterStruct() throws RecognitionException { try { - // InternalRos.g:4120:56: (iv_ruleParameterStruct= ruleParameterStruct EOF ) - // InternalRos.g:4121:2: iv_ruleParameterStruct= ruleParameterStruct EOF + // InternalRosParser.g:3357:56: (iv_ruleParameterStruct= ruleParameterStruct EOF ) + // InternalRosParser.g:3358:2: iv_ruleParameterStruct= ruleParameterStruct EOF { newCompositeNode(grammarAccess.getParameterStructRule()); pushFollow(FOLLOW_1); @@ -10203,7 +8528,7 @@ public final EObject entryRuleParameterStruct() throws RecognitionException { // $ANTLR start "ruleParameterStruct" - // InternalRos.g:4127:1: ruleParameterStruct returns [EObject current=null] : ( () (otherlv_1= '{' ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= ',' otherlv_4= '{' ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= '}' )* otherlv_7= '}' )? ) ; + // InternalRosParser.g:3364:1: ruleParameterStruct returns [EObject current=null] : ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) ; public final EObject ruleParameterStruct() throws RecognitionException { EObject current = null; @@ -10221,14 +8546,14 @@ public final EObject ruleParameterStruct() throws RecognitionException { enterRule(); try { - // InternalRos.g:4133:2: ( ( () (otherlv_1= '{' ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= ',' otherlv_4= '{' ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= '}' )* otherlv_7= '}' )? ) ) - // InternalRos.g:4134:2: ( () (otherlv_1= '{' ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= ',' otherlv_4= '{' ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= '}' )* otherlv_7= '}' )? ) + // InternalRosParser.g:3370:2: ( ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) ) + // InternalRosParser.g:3371:2: ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) { - // InternalRos.g:4134:2: ( () (otherlv_1= '{' ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= ',' otherlv_4= '{' ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= '}' )* otherlv_7= '}' )? ) - // InternalRos.g:4135:3: () (otherlv_1= '{' ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= ',' otherlv_4= '{' ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= '}' )* otherlv_7= '}' )? + // InternalRosParser.g:3371:2: ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) + // InternalRosParser.g:3372:3: () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? { - // InternalRos.g:4135:3: () - // InternalRos.g:4136:4: + // InternalRosParser.g:3372:3: () + // InternalRosParser.g:3373:4: { current = forceCreateModelElement( @@ -10238,31 +8563,31 @@ public final EObject ruleParameterStruct() throws RecognitionException { } - // InternalRos.g:4142:3: (otherlv_1= '{' ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= ',' otherlv_4= '{' ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= '}' )* otherlv_7= '}' )? - int alt78=2; - int LA78_0 = input.LA(1); + // InternalRosParser.g:3379:3: (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? + int alt55=2; + int LA55_0 = input.LA(1); - if ( (LA78_0==26) ) { - alt78=1; + if ( (LA55_0==LeftSquareBracket) ) { + alt55=1; } - switch (alt78) { + switch (alt55) { case 1 : - // InternalRos.g:4143:4: otherlv_1= '{' ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= ',' otherlv_4= '{' ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= '}' )* otherlv_7= '}' + // InternalRosParser.g:3380:4: otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket { - otherlv_1=(Token)match(input,26,FOLLOW_60); + otherlv_1=(Token)match(input,LeftSquareBracket,FOLLOW_48); - newLeafNode(otherlv_1, grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_0()); + newLeafNode(otherlv_1, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); - // InternalRos.g:4147:4: ( (lv_value_2_0= ruleParameterStructMember ) ) - // InternalRos.g:4148:5: (lv_value_2_0= ruleParameterStructMember ) + // InternalRosParser.g:3384:4: ( (lv_value_2_0= ruleParameterStructMember ) ) + // InternalRosParser.g:3385:5: (lv_value_2_0= ruleParameterStructMember ) { - // InternalRos.g:4148:5: (lv_value_2_0= ruleParameterStructMember ) - // InternalRos.g:4149:6: lv_value_2_0= ruleParameterStructMember + // InternalRosParser.g:3385:5: (lv_value_2_0= ruleParameterStructMember ) + // InternalRosParser.g:3386:6: lv_value_2_0= ruleParameterStructMember { newCompositeNode(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); - pushFollow(FOLLOW_5); + pushFollow(FOLLOW_13); lv_value_2_0=ruleParameterStructMember(); state._fsp--; @@ -10284,39 +8609,39 @@ public final EObject ruleParameterStruct() throws RecognitionException { } - // InternalRos.g:4166:4: (otherlv_3= ',' otherlv_4= '{' ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= '}' )* - loop77: + // InternalRosParser.g:3403:4: (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* + loop54: do { - int alt77=2; - int LA77_0 = input.LA(1); + int alt54=2; + int LA54_0 = input.LA(1); - if ( (LA77_0==27) ) { - alt77=1; + if ( (LA54_0==Comma) ) { + alt54=1; } - switch (alt77) { + switch (alt54) { case 1 : - // InternalRos.g:4167:5: otherlv_3= ',' otherlv_4= '{' ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= '}' + // InternalRosParser.g:3404:5: otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket { - otherlv_3=(Token)match(input,27,FOLLOW_3); + otherlv_3=(Token)match(input,Comma,FOLLOW_11); newLeafNode(otherlv_3, grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); - otherlv_4=(Token)match(input,26,FOLLOW_60); + otherlv_4=(Token)match(input,LeftSquareBracket,FOLLOW_48); - newLeafNode(otherlv_4, grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_2_1()); + newLeafNode(otherlv_4, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); - // InternalRos.g:4175:5: ( (lv_value_5_0= ruleParameterStructMember ) ) - // InternalRos.g:4176:6: (lv_value_5_0= ruleParameterStructMember ) + // InternalRosParser.g:3412:5: ( (lv_value_5_0= ruleParameterStructMember ) ) + // InternalRosParser.g:3413:6: (lv_value_5_0= ruleParameterStructMember ) { - // InternalRos.g:4176:6: (lv_value_5_0= ruleParameterStructMember ) - // InternalRos.g:4177:7: lv_value_5_0= ruleParameterStructMember + // InternalRosParser.g:3413:6: (lv_value_5_0= ruleParameterStructMember ) + // InternalRosParser.g:3414:7: lv_value_5_0= ruleParameterStructMember { newCompositeNode(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); - pushFollow(FOLLOW_15); + pushFollow(FOLLOW_49); lv_value_5_0=ruleParameterStructMember(); state._fsp--; @@ -10338,22 +8663,22 @@ public final EObject ruleParameterStruct() throws RecognitionException { } - otherlv_6=(Token)match(input,28,FOLLOW_5); + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_13); - newLeafNode(otherlv_6, grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_2_3()); + newLeafNode(otherlv_6, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); } break; default : - break loop77; + break loop54; } } while (true); - otherlv_7=(Token)match(input,28,FOLLOW_2); + otherlv_7=(Token)match(input,RightSquareBracket,FOLLOW_2); - newLeafNode(otherlv_7, grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_3()); + newLeafNode(otherlv_7, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); } @@ -10384,7 +8709,7 @@ public final EObject ruleParameterStruct() throws RecognitionException { // $ANTLR start "entryRuleParameterDate" - // InternalRos.g:4208:1: entryRuleParameterDate returns [EObject current=null] : iv_ruleParameterDate= ruleParameterDate EOF ; + // InternalRosParser.g:3445:1: entryRuleParameterDate returns [EObject current=null] : iv_ruleParameterDate= ruleParameterDate EOF ; public final EObject entryRuleParameterDate() throws RecognitionException { EObject current = null; @@ -10392,8 +8717,8 @@ public final EObject entryRuleParameterDate() throws RecognitionException { try { - // InternalRos.g:4208:54: (iv_ruleParameterDate= ruleParameterDate EOF ) - // InternalRos.g:4209:2: iv_ruleParameterDate= ruleParameterDate EOF + // InternalRosParser.g:3445:54: (iv_ruleParameterDate= ruleParameterDate EOF ) + // InternalRosParser.g:3446:2: iv_ruleParameterDate= ruleParameterDate EOF { newCompositeNode(grammarAccess.getParameterDateRule()); pushFollow(FOLLOW_1); @@ -10420,7 +8745,7 @@ public final EObject entryRuleParameterDate() throws RecognitionException { // $ANTLR start "ruleParameterDate" - // InternalRos.g:4215:1: ruleParameterDate returns [EObject current=null] : ( (lv_value_0_0= ruleDateTime0 ) ) ; + // InternalRosParser.g:3452:1: ruleParameterDate returns [EObject current=null] : ( (lv_value_0_0= ruleDateTime0 ) ) ; public final EObject ruleParameterDate() throws RecognitionException { EObject current = null; @@ -10431,14 +8756,14 @@ public final EObject ruleParameterDate() throws RecognitionException { enterRule(); try { - // InternalRos.g:4221:2: ( ( (lv_value_0_0= ruleDateTime0 ) ) ) - // InternalRos.g:4222:2: ( (lv_value_0_0= ruleDateTime0 ) ) + // InternalRosParser.g:3458:2: ( ( (lv_value_0_0= ruleDateTime0 ) ) ) + // InternalRosParser.g:3459:2: ( (lv_value_0_0= ruleDateTime0 ) ) { - // InternalRos.g:4222:2: ( (lv_value_0_0= ruleDateTime0 ) ) - // InternalRos.g:4223:3: (lv_value_0_0= ruleDateTime0 ) + // InternalRosParser.g:3459:2: ( (lv_value_0_0= ruleDateTime0 ) ) + // InternalRosParser.g:3460:3: (lv_value_0_0= ruleDateTime0 ) { - // InternalRos.g:4223:3: (lv_value_0_0= ruleDateTime0 ) - // InternalRos.g:4224:4: lv_value_0_0= ruleDateTime0 + // InternalRosParser.g:3460:3: (lv_value_0_0= ruleDateTime0 ) + // InternalRosParser.g:3461:4: lv_value_0_0= ruleDateTime0 { newCompositeNode(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); @@ -10485,7 +8810,7 @@ public final EObject ruleParameterDate() throws RecognitionException { // $ANTLR start "entryRuleParameterStructMember" - // InternalRos.g:4244:1: entryRuleParameterStructMember returns [EObject current=null] : iv_ruleParameterStructMember= ruleParameterStructMember EOF ; + // InternalRosParser.g:3481:1: entryRuleParameterStructMember returns [EObject current=null] : iv_ruleParameterStructMember= ruleParameterStructMember EOF ; public final EObject entryRuleParameterStructMember() throws RecognitionException { EObject current = null; @@ -10493,8 +8818,8 @@ public final EObject entryRuleParameterStructMember() throws RecognitionExceptio try { - // InternalRos.g:4244:62: (iv_ruleParameterStructMember= ruleParameterStructMember EOF ) - // InternalRos.g:4245:2: iv_ruleParameterStructMember= ruleParameterStructMember EOF + // InternalRosParser.g:3481:62: (iv_ruleParameterStructMember= ruleParameterStructMember EOF ) + // InternalRosParser.g:3482:2: iv_ruleParameterStructMember= ruleParameterStructMember EOF { newCompositeNode(grammarAccess.getParameterStructMemberRule()); pushFollow(FOLLOW_1); @@ -10521,14 +8846,14 @@ public final EObject entryRuleParameterStructMember() throws RecognitionExceptio // $ANTLR start "ruleParameterStructMember" - // InternalRos.g:4251:1: ruleParameterStructMember returns [EObject current=null] : (otherlv_0= 'ParameterStructMember' ( (lv_name_1_0= ruleEString ) ) otherlv_2= '{' otherlv_3= 'value' ( (lv_value_4_0= ruleParameterValue ) ) otherlv_5= '}' ) ; + // InternalRosParser.g:3488:1: ruleParameterStructMember returns [EObject current=null] : (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) ; public final EObject ruleParameterStructMember() throws RecognitionException { EObject current = null; Token otherlv_0=null; Token otherlv_2=null; - Token otherlv_3=null; - Token otherlv_5=null; + Token this_BEGIN_3=null; + Token this_END_5=null; AntlrDatatypeRuleToken lv_name_1_0 = null; EObject lv_value_4_0 = null; @@ -10538,26 +8863,26 @@ public final EObject ruleParameterStructMember() throws RecognitionException { enterRule(); try { - // InternalRos.g:4257:2: ( (otherlv_0= 'ParameterStructMember' ( (lv_name_1_0= ruleEString ) ) otherlv_2= '{' otherlv_3= 'value' ( (lv_value_4_0= ruleParameterValue ) ) otherlv_5= '}' ) ) - // InternalRos.g:4258:2: (otherlv_0= 'ParameterStructMember' ( (lv_name_1_0= ruleEString ) ) otherlv_2= '{' otherlv_3= 'value' ( (lv_value_4_0= ruleParameterValue ) ) otherlv_5= '}' ) + // InternalRosParser.g:3494:2: ( (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) ) + // InternalRosParser.g:3495:2: (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) { - // InternalRos.g:4258:2: (otherlv_0= 'ParameterStructMember' ( (lv_name_1_0= ruleEString ) ) otherlv_2= '{' otherlv_3= 'value' ( (lv_value_4_0= ruleParameterValue ) ) otherlv_5= '}' ) - // InternalRos.g:4259:3: otherlv_0= 'ParameterStructMember' ( (lv_name_1_0= ruleEString ) ) otherlv_2= '{' otherlv_3= 'value' ( (lv_value_4_0= ruleParameterValue ) ) otherlv_5= '}' + // InternalRosParser.g:3495:2: (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) + // InternalRosParser.g:3496:3: otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END { - otherlv_0=(Token)match(input,84,FOLLOW_7); + otherlv_0=(Token)match(input,ParameterStructMember,FOLLOW_7); newLeafNode(otherlv_0, grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); - // InternalRos.g:4263:3: ( (lv_name_1_0= ruleEString ) ) - // InternalRos.g:4264:4: (lv_name_1_0= ruleEString ) + // InternalRosParser.g:3500:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRosParser.g:3501:4: (lv_name_1_0= ruleEString ) { - // InternalRos.g:4264:4: (lv_name_1_0= ruleEString ) - // InternalRos.g:4265:5: lv_name_1_0= ruleEString + // InternalRosParser.g:3501:4: (lv_name_1_0= ruleEString ) + // InternalRosParser.g:3502:5: lv_name_1_0= ruleEString { newCompositeNode(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); - pushFollow(FOLLOW_3); + pushFollow(FOLLOW_4); lv_name_1_0=ruleEString(); state._fsp--; @@ -10579,24 +8904,24 @@ public final EObject ruleParameterStructMember() throws RecognitionException { } - otherlv_2=(Token)match(input,26,FOLLOW_61); + otherlv_2=(Token)match(input,Colon,FOLLOW_5); - newLeafNode(otherlv_2, grammarAccess.getParameterStructMemberAccess().getLeftCurlyBracketKeyword_2()); + newLeafNode(otherlv_2, grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); - otherlv_3=(Token)match(input,83,FOLLOW_58); + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_46); - newLeafNode(otherlv_3, grammarAccess.getParameterStructMemberAccess().getValueKeyword_3()); + newLeafNode(this_BEGIN_3, grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); - // InternalRos.g:4290:3: ( (lv_value_4_0= ruleParameterValue ) ) - // InternalRos.g:4291:4: (lv_value_4_0= ruleParameterValue ) + // InternalRosParser.g:3527:3: ( (lv_value_4_0= ruleParameterValue ) ) + // InternalRosParser.g:3528:4: (lv_value_4_0= ruleParameterValue ) { - // InternalRos.g:4291:4: (lv_value_4_0= ruleParameterValue ) - // InternalRos.g:4292:5: lv_value_4_0= ruleParameterValue + // InternalRosParser.g:3528:4: (lv_value_4_0= ruleParameterValue ) + // InternalRosParser.g:3529:5: lv_value_4_0= ruleParameterValue { newCompositeNode(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); - pushFollow(FOLLOW_15); + pushFollow(FOLLOW_14); lv_value_4_0=ruleParameterValue(); state._fsp--; @@ -10618,9 +8943,9 @@ public final EObject ruleParameterStructMember() throws RecognitionException { } - otherlv_5=(Token)match(input,28,FOLLOW_2); + this_END_5=(Token)match(input,RULE_END,FOLLOW_2); - newLeafNode(otherlv_5, grammarAccess.getParameterStructMemberAccess().getRightCurlyBracketKeyword_5()); + newLeafNode(this_END_5, grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); } @@ -10645,7 +8970,7 @@ public final EObject ruleParameterStructMember() throws RecognitionException { // $ANTLR start "entryRuleParameterStructTypeMember" - // InternalRos.g:4317:1: entryRuleParameterStructTypeMember returns [EObject current=null] : iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF ; + // InternalRosParser.g:3554:1: entryRuleParameterStructTypeMember returns [EObject current=null] : iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF ; public final EObject entryRuleParameterStructTypeMember() throws RecognitionException { EObject current = null; @@ -10653,8 +8978,8 @@ public final EObject entryRuleParameterStructTypeMember() throws RecognitionExce try { - // InternalRos.g:4317:66: (iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF ) - // InternalRos.g:4318:2: iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF + // InternalRosParser.g:3554:66: (iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF ) + // InternalRosParser.g:3555:2: iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF { newCompositeNode(grammarAccess.getParameterStructTypeMemberRule()); pushFollow(FOLLOW_1); @@ -10681,7 +9006,7 @@ public final EObject entryRuleParameterStructTypeMember() throws RecognitionExce // $ANTLR start "ruleParameterStructTypeMember" - // InternalRos.g:4324:1: ruleParameterStructTypeMember returns [EObject current=null] : ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) ; + // InternalRosParser.g:3561:1: ruleParameterStructTypeMember returns [EObject current=null] : ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) ; public final EObject ruleParameterStructTypeMember() throws RecognitionException { EObject current = null; @@ -10694,22 +9019,22 @@ public final EObject ruleParameterStructTypeMember() throws RecognitionException enterRule(); try { - // InternalRos.g:4330:2: ( ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) ) - // InternalRos.g:4331:2: ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) + // InternalRosParser.g:3567:2: ( ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) ) + // InternalRosParser.g:3568:2: ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) { - // InternalRos.g:4331:2: ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) - // InternalRos.g:4332:3: ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) + // InternalRosParser.g:3568:2: ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) + // InternalRosParser.g:3569:3: ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) { - // InternalRos.g:4332:3: ( (lv_name_0_0= ruleEString ) ) - // InternalRos.g:4333:4: (lv_name_0_0= ruleEString ) + // InternalRosParser.g:3569:3: ( (lv_name_0_0= ruleEString ) ) + // InternalRosParser.g:3570:4: (lv_name_0_0= ruleEString ) { - // InternalRos.g:4333:4: (lv_name_0_0= ruleEString ) - // InternalRos.g:4334:5: lv_name_0_0= ruleEString + // InternalRosParser.g:3570:4: (lv_name_0_0= ruleEString ) + // InternalRosParser.g:3571:5: lv_name_0_0= ruleEString { newCompositeNode(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); - pushFollow(FOLLOW_51); + pushFollow(FOLLOW_38); lv_name_0_0=ruleEString(); state._fsp--; @@ -10731,11 +9056,11 @@ public final EObject ruleParameterStructTypeMember() throws RecognitionException } - // InternalRos.g:4351:3: ( (lv_type_1_0= ruleParameterType ) ) - // InternalRos.g:4352:4: (lv_type_1_0= ruleParameterType ) + // InternalRosParser.g:3588:3: ( (lv_type_1_0= ruleParameterType ) ) + // InternalRosParser.g:3589:4: (lv_type_1_0= ruleParameterType ) { - // InternalRos.g:4352:4: (lv_type_1_0= ruleParameterType ) - // InternalRos.g:4353:5: lv_type_1_0= ruleParameterType + // InternalRosParser.g:3589:4: (lv_type_1_0= ruleParameterType ) + // InternalRosParser.g:3590:5: lv_type_1_0= ruleParameterType { newCompositeNode(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); @@ -10785,7 +9110,7 @@ public final EObject ruleParameterStructTypeMember() throws RecognitionException // $ANTLR start "entryRuleBase64Binary" - // InternalRos.g:4374:1: entryRuleBase64Binary returns [String current=null] : iv_ruleBase64Binary= ruleBase64Binary EOF ; + // InternalRosParser.g:3611:1: entryRuleBase64Binary returns [String current=null] : iv_ruleBase64Binary= ruleBase64Binary EOF ; public final String entryRuleBase64Binary() throws RecognitionException { String current = null; @@ -10793,8 +9118,8 @@ public final String entryRuleBase64Binary() throws RecognitionException { try { - // InternalRos.g:4374:52: (iv_ruleBase64Binary= ruleBase64Binary EOF ) - // InternalRos.g:4375:2: iv_ruleBase64Binary= ruleBase64Binary EOF + // InternalRosParser.g:3611:52: (iv_ruleBase64Binary= ruleBase64Binary EOF ) + // InternalRosParser.g:3612:2: iv_ruleBase64Binary= ruleBase64Binary EOF { newCompositeNode(grammarAccess.getBase64BinaryRule()); pushFollow(FOLLOW_1); @@ -10821,7 +9146,7 @@ public final String entryRuleBase64Binary() throws RecognitionException { // $ANTLR start "ruleBase64Binary" - // InternalRos.g:4381:1: ruleBase64Binary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_BINARY_0= RULE_BINARY ; + // InternalRosParser.g:3618:1: ruleBase64Binary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_BINARY_0= RULE_BINARY ; public final AntlrDatatypeRuleToken ruleBase64Binary() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -10831,8 +9156,8 @@ public final AntlrDatatypeRuleToken ruleBase64Binary() throws RecognitionExcepti enterRule(); try { - // InternalRos.g:4387:2: (this_BINARY_0= RULE_BINARY ) - // InternalRos.g:4388:2: this_BINARY_0= RULE_BINARY + // InternalRosParser.g:3624:2: (this_BINARY_0= RULE_BINARY ) + // InternalRosParser.g:3625:2: this_BINARY_0= RULE_BINARY { this_BINARY_0=(Token)match(input,RULE_BINARY,FOLLOW_2); @@ -10861,7 +9186,7 @@ public final AntlrDatatypeRuleToken ruleBase64Binary() throws RecognitionExcepti // $ANTLR start "entryRuleboolean0" - // InternalRos.g:4398:1: entryRuleboolean0 returns [String current=null] : iv_ruleboolean0= ruleboolean0 EOF ; + // InternalRosParser.g:3635:1: entryRuleboolean0 returns [String current=null] : iv_ruleboolean0= ruleboolean0 EOF ; public final String entryRuleboolean0() throws RecognitionException { String current = null; @@ -10869,8 +9194,8 @@ public final String entryRuleboolean0() throws RecognitionException { try { - // InternalRos.g:4398:48: (iv_ruleboolean0= ruleboolean0 EOF ) - // InternalRos.g:4399:2: iv_ruleboolean0= ruleboolean0 EOF + // InternalRosParser.g:3635:48: (iv_ruleboolean0= ruleboolean0 EOF ) + // InternalRosParser.g:3636:2: iv_ruleboolean0= ruleboolean0 EOF { newCompositeNode(grammarAccess.getBoolean0Rule()); pushFollow(FOLLOW_1); @@ -10897,7 +9222,7 @@ public final String entryRuleboolean0() throws RecognitionException { // $ANTLR start "ruleboolean0" - // InternalRos.g:4405:1: ruleboolean0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_BOOLEAN_0= RULE_BOOLEAN ; + // InternalRosParser.g:3642:1: ruleboolean0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_BOOLEAN_0= RULE_BOOLEAN ; public final AntlrDatatypeRuleToken ruleboolean0() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -10907,8 +9232,8 @@ public final AntlrDatatypeRuleToken ruleboolean0() throws RecognitionException { enterRule(); try { - // InternalRos.g:4411:2: (this_BOOLEAN_0= RULE_BOOLEAN ) - // InternalRos.g:4412:2: this_BOOLEAN_0= RULE_BOOLEAN + // InternalRosParser.g:3648:2: (this_BOOLEAN_0= RULE_BOOLEAN ) + // InternalRosParser.g:3649:2: this_BOOLEAN_0= RULE_BOOLEAN { this_BOOLEAN_0=(Token)match(input,RULE_BOOLEAN,FOLLOW_2); @@ -10937,7 +9262,7 @@ public final AntlrDatatypeRuleToken ruleboolean0() throws RecognitionException { // $ANTLR start "entryRuleDouble0" - // InternalRos.g:4422:1: entryRuleDouble0 returns [String current=null] : iv_ruleDouble0= ruleDouble0 EOF ; + // InternalRosParser.g:3659:1: entryRuleDouble0 returns [String current=null] : iv_ruleDouble0= ruleDouble0 EOF ; public final String entryRuleDouble0() throws RecognitionException { String current = null; @@ -10945,8 +9270,8 @@ public final String entryRuleDouble0() throws RecognitionException { try { - // InternalRos.g:4422:47: (iv_ruleDouble0= ruleDouble0 EOF ) - // InternalRos.g:4423:2: iv_ruleDouble0= ruleDouble0 EOF + // InternalRosParser.g:3659:47: (iv_ruleDouble0= ruleDouble0 EOF ) + // InternalRosParser.g:3660:2: iv_ruleDouble0= ruleDouble0 EOF { newCompositeNode(grammarAccess.getDouble0Rule()); pushFollow(FOLLOW_1); @@ -10973,7 +9298,7 @@ public final String entryRuleDouble0() throws RecognitionException { // $ANTLR start "ruleDouble0" - // InternalRos.g:4429:1: ruleDouble0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DOUBLE_0= RULE_DOUBLE ; + // InternalRosParser.g:3666:1: ruleDouble0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DOUBLE_0= RULE_DOUBLE ; public final AntlrDatatypeRuleToken ruleDouble0() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -10983,8 +9308,8 @@ public final AntlrDatatypeRuleToken ruleDouble0() throws RecognitionException { enterRule(); try { - // InternalRos.g:4435:2: (this_DOUBLE_0= RULE_DOUBLE ) - // InternalRos.g:4436:2: this_DOUBLE_0= RULE_DOUBLE + // InternalRosParser.g:3672:2: (this_DOUBLE_0= RULE_DOUBLE ) + // InternalRosParser.g:3673:2: this_DOUBLE_0= RULE_DOUBLE { this_DOUBLE_0=(Token)match(input,RULE_DOUBLE,FOLLOW_2); @@ -11013,7 +9338,7 @@ public final AntlrDatatypeRuleToken ruleDouble0() throws RecognitionException { // $ANTLR start "entryRuleInteger0" - // InternalRos.g:4446:1: entryRuleInteger0 returns [String current=null] : iv_ruleInteger0= ruleInteger0 EOF ; + // InternalRosParser.g:3683:1: entryRuleInteger0 returns [String current=null] : iv_ruleInteger0= ruleInteger0 EOF ; public final String entryRuleInteger0() throws RecognitionException { String current = null; @@ -11021,8 +9346,8 @@ public final String entryRuleInteger0() throws RecognitionException { try { - // InternalRos.g:4446:48: (iv_ruleInteger0= ruleInteger0 EOF ) - // InternalRos.g:4447:2: iv_ruleInteger0= ruleInteger0 EOF + // InternalRosParser.g:3683:48: (iv_ruleInteger0= ruleInteger0 EOF ) + // InternalRosParser.g:3684:2: iv_ruleInteger0= ruleInteger0 EOF { newCompositeNode(grammarAccess.getInteger0Rule()); pushFollow(FOLLOW_1); @@ -11049,7 +9374,7 @@ public final String entryRuleInteger0() throws RecognitionException { // $ANTLR start "ruleInteger0" - // InternalRos.g:4453:1: ruleInteger0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DECINT_0= RULE_DECINT ; + // InternalRosParser.g:3690:1: ruleInteger0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DECINT_0= RULE_DECINT ; public final AntlrDatatypeRuleToken ruleInteger0() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -11059,8 +9384,8 @@ public final AntlrDatatypeRuleToken ruleInteger0() throws RecognitionException { enterRule(); try { - // InternalRos.g:4459:2: (this_DECINT_0= RULE_DECINT ) - // InternalRos.g:4460:2: this_DECINT_0= RULE_DECINT + // InternalRosParser.g:3696:2: (this_DECINT_0= RULE_DECINT ) + // InternalRosParser.g:3697:2: this_DECINT_0= RULE_DECINT { this_DECINT_0=(Token)match(input,RULE_DECINT,FOLLOW_2); @@ -11089,7 +9414,7 @@ public final AntlrDatatypeRuleToken ruleInteger0() throws RecognitionException { // $ANTLR start "entryRuleDateTime0" - // InternalRos.g:4470:1: entryRuleDateTime0 returns [String current=null] : iv_ruleDateTime0= ruleDateTime0 EOF ; + // InternalRosParser.g:3707:1: entryRuleDateTime0 returns [String current=null] : iv_ruleDateTime0= ruleDateTime0 EOF ; public final String entryRuleDateTime0() throws RecognitionException { String current = null; @@ -11097,8 +9422,8 @@ public final String entryRuleDateTime0() throws RecognitionException { try { - // InternalRos.g:4470:49: (iv_ruleDateTime0= ruleDateTime0 EOF ) - // InternalRos.g:4471:2: iv_ruleDateTime0= ruleDateTime0 EOF + // InternalRosParser.g:3707:49: (iv_ruleDateTime0= ruleDateTime0 EOF ) + // InternalRosParser.g:3708:2: iv_ruleDateTime0= ruleDateTime0 EOF { newCompositeNode(grammarAccess.getDateTime0Rule()); pushFollow(FOLLOW_1); @@ -11125,7 +9450,7 @@ public final String entryRuleDateTime0() throws RecognitionException { // $ANTLR start "ruleDateTime0" - // InternalRos.g:4477:1: ruleDateTime0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DATE_TIME_0= RULE_DATE_TIME ; + // InternalRosParser.g:3714:1: ruleDateTime0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DATE_TIME_0= RULE_DATE_TIME ; public final AntlrDatatypeRuleToken ruleDateTime0() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -11135,8 +9460,8 @@ public final AntlrDatatypeRuleToken ruleDateTime0() throws RecognitionException enterRule(); try { - // InternalRos.g:4483:2: (this_DATE_TIME_0= RULE_DATE_TIME ) - // InternalRos.g:4484:2: this_DATE_TIME_0= RULE_DATE_TIME + // InternalRosParser.g:3720:2: (this_DATE_TIME_0= RULE_DATE_TIME ) + // InternalRosParser.g:3721:2: this_DATE_TIME_0= RULE_DATE_TIME { this_DATE_TIME_0=(Token)match(input,RULE_DATE_TIME,FOLLOW_2); @@ -11165,7 +9490,7 @@ public final AntlrDatatypeRuleToken ruleDateTime0() throws RecognitionException // $ANTLR start "entryRuleMessagePart" - // InternalRos.g:4494:1: entryRuleMessagePart returns [EObject current=null] : iv_ruleMessagePart= ruleMessagePart EOF ; + // InternalRosParser.g:3731:1: entryRuleMessagePart returns [EObject current=null] : iv_ruleMessagePart= ruleMessagePart EOF ; public final EObject entryRuleMessagePart() throws RecognitionException { EObject current = null; @@ -11173,8 +9498,8 @@ public final EObject entryRuleMessagePart() throws RecognitionException { try { - // InternalRos.g:4494:52: (iv_ruleMessagePart= ruleMessagePart EOF ) - // InternalRos.g:4495:2: iv_ruleMessagePart= ruleMessagePart EOF + // InternalRosParser.g:3731:52: (iv_ruleMessagePart= ruleMessagePart EOF ) + // InternalRosParser.g:3732:2: iv_ruleMessagePart= ruleMessagePart EOF { newCompositeNode(grammarAccess.getMessagePartRule()); pushFollow(FOLLOW_1); @@ -11201,7 +9526,7 @@ public final EObject entryRuleMessagePart() throws RecognitionException { // $ANTLR start "ruleMessagePart" - // InternalRos.g:4501:1: ruleMessagePart returns [EObject current=null] : ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) ; + // InternalRosParser.g:3738:1: ruleMessagePart returns [EObject current=null] : ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) ; public final EObject ruleMessagePart() throws RecognitionException { EObject current = null; @@ -11217,22 +9542,22 @@ public final EObject ruleMessagePart() throws RecognitionException { enterRule(); try { - // InternalRos.g:4507:2: ( ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) ) - // InternalRos.g:4508:2: ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) + // InternalRosParser.g:3744:2: ( ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) ) + // InternalRosParser.g:3745:2: ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) { - // InternalRos.g:4508:2: ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) - // InternalRos.g:4509:3: ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) + // InternalRosParser.g:3745:2: ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) + // InternalRosParser.g:3746:3: ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) { - // InternalRos.g:4509:3: ( (lv_Type_0_0= ruleAbstractType ) ) - // InternalRos.g:4510:4: (lv_Type_0_0= ruleAbstractType ) + // InternalRosParser.g:3746:3: ( (lv_Type_0_0= ruleAbstractType ) ) + // InternalRosParser.g:3747:4: (lv_Type_0_0= ruleAbstractType ) { - // InternalRos.g:4510:4: (lv_Type_0_0= ruleAbstractType ) - // InternalRos.g:4511:5: lv_Type_0_0= ruleAbstractType + // InternalRosParser.g:3747:4: (lv_Type_0_0= ruleAbstractType ) + // InternalRosParser.g:3748:5: lv_Type_0_0= ruleAbstractType { newCompositeNode(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); - pushFollow(FOLLOW_62); + pushFollow(FOLLOW_50); lv_Type_0_0=ruleAbstractType(); state._fsp--; @@ -11254,51 +9579,51 @@ public final EObject ruleMessagePart() throws RecognitionException { } - // InternalRos.g:4528:3: ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) - // InternalRos.g:4529:4: ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) + // InternalRosParser.g:3765:3: ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) + // InternalRosParser.g:3766:4: ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) { - // InternalRos.g:4529:4: ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) - // InternalRos.g:4530:5: (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) + // InternalRosParser.g:3766:4: ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) + // InternalRosParser.g:3767:5: (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) { - // InternalRos.g:4530:5: (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) - int alt79=3; + // InternalRosParser.g:3767:5: (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) + int alt56=3; switch ( input.LA(1) ) { - case 43: - case 45: - case 46: - case 47: - case 49: - case 58: - case 64: - case 73: - case 83: - case 98: - case 99: + case Duration: + case Feedback: + case Message: + case Service: + case Action: + case Result: + case Value: + case Goal: + case Name: + case Time: + case Type: { - alt79=1; + alt56=1; } break; case RULE_MESSAGE_ASIGMENT: { - alt79=2; + alt56=2; } break; - case RULE_STRING: case RULE_ID: + case RULE_STRING: { - alt79=3; + alt56=3; } break; default: NoViableAltException nvae = - new NoViableAltException("", 79, 0, input); + new NoViableAltException("", 56, 0, input); throw nvae; } - switch (alt79) { + switch (alt56) { case 1 : - // InternalRos.g:4531:6: lv_Data_1_1= ruleKEYWORD + // InternalRosParser.g:3768:6: lv_Data_1_1= ruleKEYWORD { newCompositeNode(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); @@ -11323,7 +9648,7 @@ public final EObject ruleMessagePart() throws RecognitionException { } break; case 2 : - // InternalRos.g:4547:6: lv_Data_1_2= RULE_MESSAGE_ASIGMENT + // InternalRosParser.g:3784:6: lv_Data_1_2= RULE_MESSAGE_ASIGMENT { lv_Data_1_2=(Token)match(input,RULE_MESSAGE_ASIGMENT,FOLLOW_2); @@ -11343,7 +9668,7 @@ public final EObject ruleMessagePart() throws RecognitionException { } break; case 3 : - // InternalRos.g:4562:6: lv_Data_1_3= ruleEString + // InternalRosParser.g:3799:6: lv_Data_1_3= ruleEString { newCompositeNode(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); @@ -11399,7 +9724,7 @@ public final EObject ruleMessagePart() throws RecognitionException { // $ANTLR start "entryRuleAbstractType" - // InternalRos.g:4584:1: entryRuleAbstractType returns [EObject current=null] : iv_ruleAbstractType= ruleAbstractType EOF ; + // InternalRosParser.g:3821:1: entryRuleAbstractType returns [EObject current=null] : iv_ruleAbstractType= ruleAbstractType EOF ; public final EObject entryRuleAbstractType() throws RecognitionException { EObject current = null; @@ -11407,8 +9732,8 @@ public final EObject entryRuleAbstractType() throws RecognitionException { try { - // InternalRos.g:4584:53: (iv_ruleAbstractType= ruleAbstractType EOF ) - // InternalRos.g:4585:2: iv_ruleAbstractType= ruleAbstractType EOF + // InternalRosParser.g:3821:53: (iv_ruleAbstractType= ruleAbstractType EOF ) + // InternalRosParser.g:3822:2: iv_ruleAbstractType= ruleAbstractType EOF { newCompositeNode(grammarAccess.getAbstractTypeRule()); pushFollow(FOLLOW_1); @@ -11435,7 +9760,7 @@ public final EObject entryRuleAbstractType() throws RecognitionException { // $ANTLR start "ruleAbstractType" - // InternalRos.g:4591:1: ruleAbstractType returns [EObject current=null] : (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) ; + // InternalRosParser.g:3828:1: ruleAbstractType returns [EObject current=null] : (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) ; public final EObject ruleAbstractType() throws RecognitionException { EObject current = null; @@ -11506,15 +9831,15 @@ public final EObject ruleAbstractType() throws RecognitionException { enterRule(); try { - // InternalRos.g:4597:2: ( (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) ) - // InternalRos.g:4598:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) + // InternalRosParser.g:3834:2: ( (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) ) + // InternalRosParser.g:3835:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) { - // InternalRos.g:4598:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) - int alt80=31; - alt80 = dfa80.predict(input); - switch (alt80) { + // InternalRosParser.g:3835:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) + int alt57=31; + alt57 = dfa57.predict(input); + switch (alt57) { case 1 : - // InternalRos.g:4599:3: this_bool_0= rulebool + // InternalRosParser.g:3836:3: this_bool_0= rulebool { newCompositeNode(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); @@ -11532,7 +9857,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 2 : - // InternalRos.g:4608:3: this_int8_1= ruleint8 + // InternalRosParser.g:3845:3: this_int8_1= ruleint8 { newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); @@ -11550,7 +9875,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 3 : - // InternalRos.g:4617:3: this_uint8_2= ruleuint8 + // InternalRosParser.g:3854:3: this_uint8_2= ruleuint8 { newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); @@ -11568,7 +9893,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 4 : - // InternalRos.g:4626:3: this_int16_3= ruleint16 + // InternalRosParser.g:3863:3: this_int16_3= ruleint16 { newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); @@ -11586,7 +9911,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 5 : - // InternalRos.g:4635:3: this_uint16_4= ruleuint16 + // InternalRosParser.g:3872:3: this_uint16_4= ruleuint16 { newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); @@ -11604,7 +9929,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 6 : - // InternalRos.g:4644:3: this_int32_5= ruleint32 + // InternalRosParser.g:3881:3: this_int32_5= ruleint32 { newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); @@ -11622,7 +9947,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 7 : - // InternalRos.g:4653:3: this_uint32_6= ruleuint32 + // InternalRosParser.g:3890:3: this_uint32_6= ruleuint32 { newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); @@ -11640,7 +9965,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 8 : - // InternalRos.g:4662:3: this_int64_7= ruleint64 + // InternalRosParser.g:3899:3: this_int64_7= ruleint64 { newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); @@ -11658,7 +9983,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 9 : - // InternalRos.g:4671:3: this_uint64_8= ruleuint64 + // InternalRosParser.g:3908:3: this_uint64_8= ruleuint64 { newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); @@ -11676,7 +10001,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 10 : - // InternalRos.g:4680:3: this_float32_9= rulefloat32 + // InternalRosParser.g:3917:3: this_float32_9= rulefloat32 { newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); @@ -11694,7 +10019,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 11 : - // InternalRos.g:4689:3: this_float64_10= rulefloat64 + // InternalRosParser.g:3926:3: this_float64_10= rulefloat64 { newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); @@ -11712,7 +10037,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 12 : - // InternalRos.g:4698:3: this_string0_11= rulestring0 + // InternalRosParser.g:3935:3: this_string0_11= rulestring0 { newCompositeNode(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); @@ -11730,7 +10055,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 13 : - // InternalRos.g:4707:3: this_byte_12= rulebyte + // InternalRosParser.g:3944:3: this_byte_12= rulebyte { newCompositeNode(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); @@ -11748,7 +10073,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 14 : - // InternalRos.g:4716:3: this_time_13= ruletime + // InternalRosParser.g:3953:3: this_time_13= ruletime { newCompositeNode(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); @@ -11766,7 +10091,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 15 : - // InternalRos.g:4725:3: this_duration_14= ruleduration + // InternalRosParser.g:3962:3: this_duration_14= ruleduration { newCompositeNode(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); @@ -11784,7 +10109,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 16 : - // InternalRos.g:4734:3: this_Header_15= ruleHeader + // InternalRosParser.g:3971:3: this_Header_15= ruleHeader { newCompositeNode(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); @@ -11802,7 +10127,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 17 : - // InternalRos.g:4743:3: this_boolArray_16= ruleboolArray + // InternalRosParser.g:3980:3: this_boolArray_16= ruleboolArray { newCompositeNode(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); @@ -11820,7 +10145,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 18 : - // InternalRos.g:4752:3: this_int8Array_17= ruleint8Array + // InternalRosParser.g:3989:3: this_int8Array_17= ruleint8Array { newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); @@ -11838,7 +10163,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 19 : - // InternalRos.g:4761:3: this_uint8Array_18= ruleuint8Array + // InternalRosParser.g:3998:3: this_uint8Array_18= ruleuint8Array { newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); @@ -11856,7 +10181,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 20 : - // InternalRos.g:4770:3: this_int16Array_19= ruleint16Array + // InternalRosParser.g:4007:3: this_int16Array_19= ruleint16Array { newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); @@ -11874,7 +10199,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 21 : - // InternalRos.g:4779:3: this_uint16Array_20= ruleuint16Array + // InternalRosParser.g:4016:3: this_uint16Array_20= ruleuint16Array { newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); @@ -11892,7 +10217,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 22 : - // InternalRos.g:4788:3: this_int32Array_21= ruleint32Array + // InternalRosParser.g:4025:3: this_int32Array_21= ruleint32Array { newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); @@ -11910,7 +10235,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 23 : - // InternalRos.g:4797:3: this_uint32Array_22= ruleuint32Array + // InternalRosParser.g:4034:3: this_uint32Array_22= ruleuint32Array { newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); @@ -11928,7 +10253,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 24 : - // InternalRos.g:4806:3: this_int64Array_23= ruleint64Array + // InternalRosParser.g:4043:3: this_int64Array_23= ruleint64Array { newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); @@ -11946,7 +10271,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 25 : - // InternalRos.g:4815:3: this_uint64Array_24= ruleuint64Array + // InternalRosParser.g:4052:3: this_uint64Array_24= ruleuint64Array { newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); @@ -11964,7 +10289,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 26 : - // InternalRos.g:4824:3: this_float32Array_25= rulefloat32Array + // InternalRosParser.g:4061:3: this_float32Array_25= rulefloat32Array { newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); @@ -11982,7 +10307,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 27 : - // InternalRos.g:4833:3: this_float64Array_26= rulefloat64Array + // InternalRosParser.g:4070:3: this_float64Array_26= rulefloat64Array { newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); @@ -12000,7 +10325,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 28 : - // InternalRos.g:4842:3: this_string0Array_27= rulestring0Array + // InternalRosParser.g:4079:3: this_string0Array_27= rulestring0Array { newCompositeNode(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); @@ -12018,7 +10343,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 29 : - // InternalRos.g:4851:3: this_byteArray_28= rulebyteArray + // InternalRosParser.g:4088:3: this_byteArray_28= rulebyteArray { newCompositeNode(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); @@ -12036,7 +10361,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 30 : - // InternalRos.g:4860:3: this_TopicSpecRef_29= ruleTopicSpecRef + // InternalRosParser.g:4097:3: this_TopicSpecRef_29= ruleTopicSpecRef { newCompositeNode(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); @@ -12054,7 +10379,7 @@ public final EObject ruleAbstractType() throws RecognitionException { } break; case 31 : - // InternalRos.g:4869:3: this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef + // InternalRosParser.g:4106:3: this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef { newCompositeNode(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); @@ -12094,7 +10419,7 @@ public final EObject ruleAbstractType() throws RecognitionException { // $ANTLR start "entryRulebool" - // InternalRos.g:4881:1: entryRulebool returns [EObject current=null] : iv_rulebool= rulebool EOF ; + // InternalRosParser.g:4118:1: entryRulebool returns [EObject current=null] : iv_rulebool= rulebool EOF ; public final EObject entryRulebool() throws RecognitionException { EObject current = null; @@ -12102,8 +10427,8 @@ public final EObject entryRulebool() throws RecognitionException { try { - // InternalRos.g:4881:45: (iv_rulebool= rulebool EOF ) - // InternalRos.g:4882:2: iv_rulebool= rulebool EOF + // InternalRosParser.g:4118:45: (iv_rulebool= rulebool EOF ) + // InternalRosParser.g:4119:2: iv_rulebool= rulebool EOF { newCompositeNode(grammarAccess.getBoolRule()); pushFollow(FOLLOW_1); @@ -12130,7 +10455,7 @@ public final EObject entryRulebool() throws RecognitionException { // $ANTLR start "rulebool" - // InternalRos.g:4888:1: rulebool returns [EObject current=null] : ( () otherlv_1= 'bool' ) ; + // InternalRosParser.g:4125:1: rulebool returns [EObject current=null] : ( () otherlv_1= Bool ) ; public final EObject rulebool() throws RecognitionException { EObject current = null; @@ -12140,14 +10465,14 @@ public final EObject rulebool() throws RecognitionException { enterRule(); try { - // InternalRos.g:4894:2: ( ( () otherlv_1= 'bool' ) ) - // InternalRos.g:4895:2: ( () otherlv_1= 'bool' ) + // InternalRosParser.g:4131:2: ( ( () otherlv_1= Bool ) ) + // InternalRosParser.g:4132:2: ( () otherlv_1= Bool ) { - // InternalRos.g:4895:2: ( () otherlv_1= 'bool' ) - // InternalRos.g:4896:3: () otherlv_1= 'bool' + // InternalRosParser.g:4132:2: ( () otherlv_1= Bool ) + // InternalRosParser.g:4133:3: () otherlv_1= Bool { - // InternalRos.g:4896:3: () - // InternalRos.g:4897:4: + // InternalRosParser.g:4133:3: () + // InternalRosParser.g:4134:4: { current = forceCreateModelElement( @@ -12157,7 +10482,7 @@ public final EObject rulebool() throws RecognitionException { } - otherlv_1=(Token)match(input,85,FOLLOW_2); + otherlv_1=(Token)match(input,Bool,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getBoolAccess().getBoolKeyword_1()); @@ -12184,7 +10509,7 @@ public final EObject rulebool() throws RecognitionException { // $ANTLR start "entryRuleint8" - // InternalRos.g:4911:1: entryRuleint8 returns [EObject current=null] : iv_ruleint8= ruleint8 EOF ; + // InternalRosParser.g:4148:1: entryRuleint8 returns [EObject current=null] : iv_ruleint8= ruleint8 EOF ; public final EObject entryRuleint8() throws RecognitionException { EObject current = null; @@ -12192,8 +10517,8 @@ public final EObject entryRuleint8() throws RecognitionException { try { - // InternalRos.g:4911:45: (iv_ruleint8= ruleint8 EOF ) - // InternalRos.g:4912:2: iv_ruleint8= ruleint8 EOF + // InternalRosParser.g:4148:45: (iv_ruleint8= ruleint8 EOF ) + // InternalRosParser.g:4149:2: iv_ruleint8= ruleint8 EOF { newCompositeNode(grammarAccess.getInt8Rule()); pushFollow(FOLLOW_1); @@ -12220,7 +10545,7 @@ public final EObject entryRuleint8() throws RecognitionException { // $ANTLR start "ruleint8" - // InternalRos.g:4918:1: ruleint8 returns [EObject current=null] : ( () otherlv_1= 'int8' ) ; + // InternalRosParser.g:4155:1: ruleint8 returns [EObject current=null] : ( () otherlv_1= Int8 ) ; public final EObject ruleint8() throws RecognitionException { EObject current = null; @@ -12230,14 +10555,14 @@ public final EObject ruleint8() throws RecognitionException { enterRule(); try { - // InternalRos.g:4924:2: ( ( () otherlv_1= 'int8' ) ) - // InternalRos.g:4925:2: ( () otherlv_1= 'int8' ) + // InternalRosParser.g:4161:2: ( ( () otherlv_1= Int8 ) ) + // InternalRosParser.g:4162:2: ( () otherlv_1= Int8 ) { - // InternalRos.g:4925:2: ( () otherlv_1= 'int8' ) - // InternalRos.g:4926:3: () otherlv_1= 'int8' + // InternalRosParser.g:4162:2: ( () otherlv_1= Int8 ) + // InternalRosParser.g:4163:3: () otherlv_1= Int8 { - // InternalRos.g:4926:3: () - // InternalRos.g:4927:4: + // InternalRosParser.g:4163:3: () + // InternalRosParser.g:4164:4: { current = forceCreateModelElement( @@ -12247,7 +10572,7 @@ public final EObject ruleint8() throws RecognitionException { } - otherlv_1=(Token)match(input,86,FOLLOW_2); + otherlv_1=(Token)match(input,Int8,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getInt8Access().getInt8Keyword_1()); @@ -12274,7 +10599,7 @@ public final EObject ruleint8() throws RecognitionException { // $ANTLR start "entryRuleuint8" - // InternalRos.g:4941:1: entryRuleuint8 returns [EObject current=null] : iv_ruleuint8= ruleuint8 EOF ; + // InternalRosParser.g:4178:1: entryRuleuint8 returns [EObject current=null] : iv_ruleuint8= ruleuint8 EOF ; public final EObject entryRuleuint8() throws RecognitionException { EObject current = null; @@ -12282,8 +10607,8 @@ public final EObject entryRuleuint8() throws RecognitionException { try { - // InternalRos.g:4941:46: (iv_ruleuint8= ruleuint8 EOF ) - // InternalRos.g:4942:2: iv_ruleuint8= ruleuint8 EOF + // InternalRosParser.g:4178:46: (iv_ruleuint8= ruleuint8 EOF ) + // InternalRosParser.g:4179:2: iv_ruleuint8= ruleuint8 EOF { newCompositeNode(grammarAccess.getUint8Rule()); pushFollow(FOLLOW_1); @@ -12310,7 +10635,7 @@ public final EObject entryRuleuint8() throws RecognitionException { // $ANTLR start "ruleuint8" - // InternalRos.g:4948:1: ruleuint8 returns [EObject current=null] : ( () otherlv_1= 'uint8' ) ; + // InternalRosParser.g:4185:1: ruleuint8 returns [EObject current=null] : ( () otherlv_1= Uint8 ) ; public final EObject ruleuint8() throws RecognitionException { EObject current = null; @@ -12320,14 +10645,14 @@ public final EObject ruleuint8() throws RecognitionException { enterRule(); try { - // InternalRos.g:4954:2: ( ( () otherlv_1= 'uint8' ) ) - // InternalRos.g:4955:2: ( () otherlv_1= 'uint8' ) + // InternalRosParser.g:4191:2: ( ( () otherlv_1= Uint8 ) ) + // InternalRosParser.g:4192:2: ( () otherlv_1= Uint8 ) { - // InternalRos.g:4955:2: ( () otherlv_1= 'uint8' ) - // InternalRos.g:4956:3: () otherlv_1= 'uint8' + // InternalRosParser.g:4192:2: ( () otherlv_1= Uint8 ) + // InternalRosParser.g:4193:3: () otherlv_1= Uint8 { - // InternalRos.g:4956:3: () - // InternalRos.g:4957:4: + // InternalRosParser.g:4193:3: () + // InternalRosParser.g:4194:4: { current = forceCreateModelElement( @@ -12337,7 +10662,7 @@ public final EObject ruleuint8() throws RecognitionException { } - otherlv_1=(Token)match(input,87,FOLLOW_2); + otherlv_1=(Token)match(input,Uint8,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getUint8Access().getUint8Keyword_1()); @@ -12364,7 +10689,7 @@ public final EObject ruleuint8() throws RecognitionException { // $ANTLR start "entryRuleint16" - // InternalRos.g:4971:1: entryRuleint16 returns [EObject current=null] : iv_ruleint16= ruleint16 EOF ; + // InternalRosParser.g:4208:1: entryRuleint16 returns [EObject current=null] : iv_ruleint16= ruleint16 EOF ; public final EObject entryRuleint16() throws RecognitionException { EObject current = null; @@ -12372,8 +10697,8 @@ public final EObject entryRuleint16() throws RecognitionException { try { - // InternalRos.g:4971:46: (iv_ruleint16= ruleint16 EOF ) - // InternalRos.g:4972:2: iv_ruleint16= ruleint16 EOF + // InternalRosParser.g:4208:46: (iv_ruleint16= ruleint16 EOF ) + // InternalRosParser.g:4209:2: iv_ruleint16= ruleint16 EOF { newCompositeNode(grammarAccess.getInt16Rule()); pushFollow(FOLLOW_1); @@ -12400,7 +10725,7 @@ public final EObject entryRuleint16() throws RecognitionException { // $ANTLR start "ruleint16" - // InternalRos.g:4978:1: ruleint16 returns [EObject current=null] : ( () otherlv_1= 'int16' ) ; + // InternalRosParser.g:4215:1: ruleint16 returns [EObject current=null] : ( () otherlv_1= Int16 ) ; public final EObject ruleint16() throws RecognitionException { EObject current = null; @@ -12410,14 +10735,14 @@ public final EObject ruleint16() throws RecognitionException { enterRule(); try { - // InternalRos.g:4984:2: ( ( () otherlv_1= 'int16' ) ) - // InternalRos.g:4985:2: ( () otherlv_1= 'int16' ) + // InternalRosParser.g:4221:2: ( ( () otherlv_1= Int16 ) ) + // InternalRosParser.g:4222:2: ( () otherlv_1= Int16 ) { - // InternalRos.g:4985:2: ( () otherlv_1= 'int16' ) - // InternalRos.g:4986:3: () otherlv_1= 'int16' + // InternalRosParser.g:4222:2: ( () otherlv_1= Int16 ) + // InternalRosParser.g:4223:3: () otherlv_1= Int16 { - // InternalRos.g:4986:3: () - // InternalRos.g:4987:4: + // InternalRosParser.g:4223:3: () + // InternalRosParser.g:4224:4: { current = forceCreateModelElement( @@ -12427,7 +10752,7 @@ public final EObject ruleint16() throws RecognitionException { } - otherlv_1=(Token)match(input,88,FOLLOW_2); + otherlv_1=(Token)match(input,Int16,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getInt16Access().getInt16Keyword_1()); @@ -12454,7 +10779,7 @@ public final EObject ruleint16() throws RecognitionException { // $ANTLR start "entryRuleuint16" - // InternalRos.g:5001:1: entryRuleuint16 returns [EObject current=null] : iv_ruleuint16= ruleuint16 EOF ; + // InternalRosParser.g:4238:1: entryRuleuint16 returns [EObject current=null] : iv_ruleuint16= ruleuint16 EOF ; public final EObject entryRuleuint16() throws RecognitionException { EObject current = null; @@ -12462,8 +10787,8 @@ public final EObject entryRuleuint16() throws RecognitionException { try { - // InternalRos.g:5001:47: (iv_ruleuint16= ruleuint16 EOF ) - // InternalRos.g:5002:2: iv_ruleuint16= ruleuint16 EOF + // InternalRosParser.g:4238:47: (iv_ruleuint16= ruleuint16 EOF ) + // InternalRosParser.g:4239:2: iv_ruleuint16= ruleuint16 EOF { newCompositeNode(grammarAccess.getUint16Rule()); pushFollow(FOLLOW_1); @@ -12490,7 +10815,7 @@ public final EObject entryRuleuint16() throws RecognitionException { // $ANTLR start "ruleuint16" - // InternalRos.g:5008:1: ruleuint16 returns [EObject current=null] : ( () otherlv_1= 'uint16' ) ; + // InternalRosParser.g:4245:1: ruleuint16 returns [EObject current=null] : ( () otherlv_1= Uint16 ) ; public final EObject ruleuint16() throws RecognitionException { EObject current = null; @@ -12500,14 +10825,14 @@ public final EObject ruleuint16() throws RecognitionException { enterRule(); try { - // InternalRos.g:5014:2: ( ( () otherlv_1= 'uint16' ) ) - // InternalRos.g:5015:2: ( () otherlv_1= 'uint16' ) + // InternalRosParser.g:4251:2: ( ( () otherlv_1= Uint16 ) ) + // InternalRosParser.g:4252:2: ( () otherlv_1= Uint16 ) { - // InternalRos.g:5015:2: ( () otherlv_1= 'uint16' ) - // InternalRos.g:5016:3: () otherlv_1= 'uint16' + // InternalRosParser.g:4252:2: ( () otherlv_1= Uint16 ) + // InternalRosParser.g:4253:3: () otherlv_1= Uint16 { - // InternalRos.g:5016:3: () - // InternalRos.g:5017:4: + // InternalRosParser.g:4253:3: () + // InternalRosParser.g:4254:4: { current = forceCreateModelElement( @@ -12517,7 +10842,7 @@ public final EObject ruleuint16() throws RecognitionException { } - otherlv_1=(Token)match(input,89,FOLLOW_2); + otherlv_1=(Token)match(input,Uint16,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getUint16Access().getUint16Keyword_1()); @@ -12544,7 +10869,7 @@ public final EObject ruleuint16() throws RecognitionException { // $ANTLR start "entryRuleint32" - // InternalRos.g:5031:1: entryRuleint32 returns [EObject current=null] : iv_ruleint32= ruleint32 EOF ; + // InternalRosParser.g:4268:1: entryRuleint32 returns [EObject current=null] : iv_ruleint32= ruleint32 EOF ; public final EObject entryRuleint32() throws RecognitionException { EObject current = null; @@ -12552,8 +10877,8 @@ public final EObject entryRuleint32() throws RecognitionException { try { - // InternalRos.g:5031:46: (iv_ruleint32= ruleint32 EOF ) - // InternalRos.g:5032:2: iv_ruleint32= ruleint32 EOF + // InternalRosParser.g:4268:46: (iv_ruleint32= ruleint32 EOF ) + // InternalRosParser.g:4269:2: iv_ruleint32= ruleint32 EOF { newCompositeNode(grammarAccess.getInt32Rule()); pushFollow(FOLLOW_1); @@ -12580,7 +10905,7 @@ public final EObject entryRuleint32() throws RecognitionException { // $ANTLR start "ruleint32" - // InternalRos.g:5038:1: ruleint32 returns [EObject current=null] : ( () otherlv_1= 'int32' ) ; + // InternalRosParser.g:4275:1: ruleint32 returns [EObject current=null] : ( () otherlv_1= Int32 ) ; public final EObject ruleint32() throws RecognitionException { EObject current = null; @@ -12590,14 +10915,14 @@ public final EObject ruleint32() throws RecognitionException { enterRule(); try { - // InternalRos.g:5044:2: ( ( () otherlv_1= 'int32' ) ) - // InternalRos.g:5045:2: ( () otherlv_1= 'int32' ) + // InternalRosParser.g:4281:2: ( ( () otherlv_1= Int32 ) ) + // InternalRosParser.g:4282:2: ( () otherlv_1= Int32 ) { - // InternalRos.g:5045:2: ( () otherlv_1= 'int32' ) - // InternalRos.g:5046:3: () otherlv_1= 'int32' + // InternalRosParser.g:4282:2: ( () otherlv_1= Int32 ) + // InternalRosParser.g:4283:3: () otherlv_1= Int32 { - // InternalRos.g:5046:3: () - // InternalRos.g:5047:4: + // InternalRosParser.g:4283:3: () + // InternalRosParser.g:4284:4: { current = forceCreateModelElement( @@ -12607,7 +10932,7 @@ public final EObject ruleint32() throws RecognitionException { } - otherlv_1=(Token)match(input,90,FOLLOW_2); + otherlv_1=(Token)match(input,Int32,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getInt32Access().getInt32Keyword_1()); @@ -12634,7 +10959,7 @@ public final EObject ruleint32() throws RecognitionException { // $ANTLR start "entryRuleuint32" - // InternalRos.g:5061:1: entryRuleuint32 returns [EObject current=null] : iv_ruleuint32= ruleuint32 EOF ; + // InternalRosParser.g:4298:1: entryRuleuint32 returns [EObject current=null] : iv_ruleuint32= ruleuint32 EOF ; public final EObject entryRuleuint32() throws RecognitionException { EObject current = null; @@ -12642,8 +10967,8 @@ public final EObject entryRuleuint32() throws RecognitionException { try { - // InternalRos.g:5061:47: (iv_ruleuint32= ruleuint32 EOF ) - // InternalRos.g:5062:2: iv_ruleuint32= ruleuint32 EOF + // InternalRosParser.g:4298:47: (iv_ruleuint32= ruleuint32 EOF ) + // InternalRosParser.g:4299:2: iv_ruleuint32= ruleuint32 EOF { newCompositeNode(grammarAccess.getUint32Rule()); pushFollow(FOLLOW_1); @@ -12670,7 +10995,7 @@ public final EObject entryRuleuint32() throws RecognitionException { // $ANTLR start "ruleuint32" - // InternalRos.g:5068:1: ruleuint32 returns [EObject current=null] : ( () otherlv_1= 'uint32' ) ; + // InternalRosParser.g:4305:1: ruleuint32 returns [EObject current=null] : ( () otherlv_1= Uint32 ) ; public final EObject ruleuint32() throws RecognitionException { EObject current = null; @@ -12680,14 +11005,14 @@ public final EObject ruleuint32() throws RecognitionException { enterRule(); try { - // InternalRos.g:5074:2: ( ( () otherlv_1= 'uint32' ) ) - // InternalRos.g:5075:2: ( () otherlv_1= 'uint32' ) + // InternalRosParser.g:4311:2: ( ( () otherlv_1= Uint32 ) ) + // InternalRosParser.g:4312:2: ( () otherlv_1= Uint32 ) { - // InternalRos.g:5075:2: ( () otherlv_1= 'uint32' ) - // InternalRos.g:5076:3: () otherlv_1= 'uint32' + // InternalRosParser.g:4312:2: ( () otherlv_1= Uint32 ) + // InternalRosParser.g:4313:3: () otherlv_1= Uint32 { - // InternalRos.g:5076:3: () - // InternalRos.g:5077:4: + // InternalRosParser.g:4313:3: () + // InternalRosParser.g:4314:4: { current = forceCreateModelElement( @@ -12697,7 +11022,7 @@ public final EObject ruleuint32() throws RecognitionException { } - otherlv_1=(Token)match(input,91,FOLLOW_2); + otherlv_1=(Token)match(input,Uint32,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getUint32Access().getUint32Keyword_1()); @@ -12724,7 +11049,7 @@ public final EObject ruleuint32() throws RecognitionException { // $ANTLR start "entryRuleint64" - // InternalRos.g:5091:1: entryRuleint64 returns [EObject current=null] : iv_ruleint64= ruleint64 EOF ; + // InternalRosParser.g:4328:1: entryRuleint64 returns [EObject current=null] : iv_ruleint64= ruleint64 EOF ; public final EObject entryRuleint64() throws RecognitionException { EObject current = null; @@ -12732,8 +11057,8 @@ public final EObject entryRuleint64() throws RecognitionException { try { - // InternalRos.g:5091:46: (iv_ruleint64= ruleint64 EOF ) - // InternalRos.g:5092:2: iv_ruleint64= ruleint64 EOF + // InternalRosParser.g:4328:46: (iv_ruleint64= ruleint64 EOF ) + // InternalRosParser.g:4329:2: iv_ruleint64= ruleint64 EOF { newCompositeNode(grammarAccess.getInt64Rule()); pushFollow(FOLLOW_1); @@ -12760,7 +11085,7 @@ public final EObject entryRuleint64() throws RecognitionException { // $ANTLR start "ruleint64" - // InternalRos.g:5098:1: ruleint64 returns [EObject current=null] : ( () otherlv_1= 'int64' ) ; + // InternalRosParser.g:4335:1: ruleint64 returns [EObject current=null] : ( () otherlv_1= Int64 ) ; public final EObject ruleint64() throws RecognitionException { EObject current = null; @@ -12770,14 +11095,14 @@ public final EObject ruleint64() throws RecognitionException { enterRule(); try { - // InternalRos.g:5104:2: ( ( () otherlv_1= 'int64' ) ) - // InternalRos.g:5105:2: ( () otherlv_1= 'int64' ) + // InternalRosParser.g:4341:2: ( ( () otherlv_1= Int64 ) ) + // InternalRosParser.g:4342:2: ( () otherlv_1= Int64 ) { - // InternalRos.g:5105:2: ( () otherlv_1= 'int64' ) - // InternalRos.g:5106:3: () otherlv_1= 'int64' + // InternalRosParser.g:4342:2: ( () otherlv_1= Int64 ) + // InternalRosParser.g:4343:3: () otherlv_1= Int64 { - // InternalRos.g:5106:3: () - // InternalRos.g:5107:4: + // InternalRosParser.g:4343:3: () + // InternalRosParser.g:4344:4: { current = forceCreateModelElement( @@ -12787,7 +11112,7 @@ public final EObject ruleint64() throws RecognitionException { } - otherlv_1=(Token)match(input,92,FOLLOW_2); + otherlv_1=(Token)match(input,Int64,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getInt64Access().getInt64Keyword_1()); @@ -12814,7 +11139,7 @@ public final EObject ruleint64() throws RecognitionException { // $ANTLR start "entryRuleuint64" - // InternalRos.g:5121:1: entryRuleuint64 returns [EObject current=null] : iv_ruleuint64= ruleuint64 EOF ; + // InternalRosParser.g:4358:1: entryRuleuint64 returns [EObject current=null] : iv_ruleuint64= ruleuint64 EOF ; public final EObject entryRuleuint64() throws RecognitionException { EObject current = null; @@ -12822,8 +11147,8 @@ public final EObject entryRuleuint64() throws RecognitionException { try { - // InternalRos.g:5121:47: (iv_ruleuint64= ruleuint64 EOF ) - // InternalRos.g:5122:2: iv_ruleuint64= ruleuint64 EOF + // InternalRosParser.g:4358:47: (iv_ruleuint64= ruleuint64 EOF ) + // InternalRosParser.g:4359:2: iv_ruleuint64= ruleuint64 EOF { newCompositeNode(grammarAccess.getUint64Rule()); pushFollow(FOLLOW_1); @@ -12850,7 +11175,7 @@ public final EObject entryRuleuint64() throws RecognitionException { // $ANTLR start "ruleuint64" - // InternalRos.g:5128:1: ruleuint64 returns [EObject current=null] : ( () otherlv_1= 'uint64' ) ; + // InternalRosParser.g:4365:1: ruleuint64 returns [EObject current=null] : ( () otherlv_1= Uint64 ) ; public final EObject ruleuint64() throws RecognitionException { EObject current = null; @@ -12860,14 +11185,14 @@ public final EObject ruleuint64() throws RecognitionException { enterRule(); try { - // InternalRos.g:5134:2: ( ( () otherlv_1= 'uint64' ) ) - // InternalRos.g:5135:2: ( () otherlv_1= 'uint64' ) + // InternalRosParser.g:4371:2: ( ( () otherlv_1= Uint64 ) ) + // InternalRosParser.g:4372:2: ( () otherlv_1= Uint64 ) { - // InternalRos.g:5135:2: ( () otherlv_1= 'uint64' ) - // InternalRos.g:5136:3: () otherlv_1= 'uint64' + // InternalRosParser.g:4372:2: ( () otherlv_1= Uint64 ) + // InternalRosParser.g:4373:3: () otherlv_1= Uint64 { - // InternalRos.g:5136:3: () - // InternalRos.g:5137:4: + // InternalRosParser.g:4373:3: () + // InternalRosParser.g:4374:4: { current = forceCreateModelElement( @@ -12877,7 +11202,7 @@ public final EObject ruleuint64() throws RecognitionException { } - otherlv_1=(Token)match(input,93,FOLLOW_2); + otherlv_1=(Token)match(input,Uint64,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getUint64Access().getUint64Keyword_1()); @@ -12904,7 +11229,7 @@ public final EObject ruleuint64() throws RecognitionException { // $ANTLR start "entryRulefloat32" - // InternalRos.g:5151:1: entryRulefloat32 returns [EObject current=null] : iv_rulefloat32= rulefloat32 EOF ; + // InternalRosParser.g:4388:1: entryRulefloat32 returns [EObject current=null] : iv_rulefloat32= rulefloat32 EOF ; public final EObject entryRulefloat32() throws RecognitionException { EObject current = null; @@ -12912,8 +11237,8 @@ public final EObject entryRulefloat32() throws RecognitionException { try { - // InternalRos.g:5151:48: (iv_rulefloat32= rulefloat32 EOF ) - // InternalRos.g:5152:2: iv_rulefloat32= rulefloat32 EOF + // InternalRosParser.g:4388:48: (iv_rulefloat32= rulefloat32 EOF ) + // InternalRosParser.g:4389:2: iv_rulefloat32= rulefloat32 EOF { newCompositeNode(grammarAccess.getFloat32Rule()); pushFollow(FOLLOW_1); @@ -12940,7 +11265,7 @@ public final EObject entryRulefloat32() throws RecognitionException { // $ANTLR start "rulefloat32" - // InternalRos.g:5158:1: rulefloat32 returns [EObject current=null] : ( () otherlv_1= 'float32' ) ; + // InternalRosParser.g:4395:1: rulefloat32 returns [EObject current=null] : ( () otherlv_1= Float32 ) ; public final EObject rulefloat32() throws RecognitionException { EObject current = null; @@ -12950,14 +11275,14 @@ public final EObject rulefloat32() throws RecognitionException { enterRule(); try { - // InternalRos.g:5164:2: ( ( () otherlv_1= 'float32' ) ) - // InternalRos.g:5165:2: ( () otherlv_1= 'float32' ) + // InternalRosParser.g:4401:2: ( ( () otherlv_1= Float32 ) ) + // InternalRosParser.g:4402:2: ( () otherlv_1= Float32 ) { - // InternalRos.g:5165:2: ( () otherlv_1= 'float32' ) - // InternalRos.g:5166:3: () otherlv_1= 'float32' + // InternalRosParser.g:4402:2: ( () otherlv_1= Float32 ) + // InternalRosParser.g:4403:3: () otherlv_1= Float32 { - // InternalRos.g:5166:3: () - // InternalRos.g:5167:4: + // InternalRosParser.g:4403:3: () + // InternalRosParser.g:4404:4: { current = forceCreateModelElement( @@ -12967,7 +11292,7 @@ public final EObject rulefloat32() throws RecognitionException { } - otherlv_1=(Token)match(input,94,FOLLOW_2); + otherlv_1=(Token)match(input,Float32,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getFloat32Access().getFloat32Keyword_1()); @@ -12994,7 +11319,7 @@ public final EObject rulefloat32() throws RecognitionException { // $ANTLR start "entryRulefloat64" - // InternalRos.g:5181:1: entryRulefloat64 returns [EObject current=null] : iv_rulefloat64= rulefloat64 EOF ; + // InternalRosParser.g:4418:1: entryRulefloat64 returns [EObject current=null] : iv_rulefloat64= rulefloat64 EOF ; public final EObject entryRulefloat64() throws RecognitionException { EObject current = null; @@ -13002,8 +11327,8 @@ public final EObject entryRulefloat64() throws RecognitionException { try { - // InternalRos.g:5181:48: (iv_rulefloat64= rulefloat64 EOF ) - // InternalRos.g:5182:2: iv_rulefloat64= rulefloat64 EOF + // InternalRosParser.g:4418:48: (iv_rulefloat64= rulefloat64 EOF ) + // InternalRosParser.g:4419:2: iv_rulefloat64= rulefloat64 EOF { newCompositeNode(grammarAccess.getFloat64Rule()); pushFollow(FOLLOW_1); @@ -13030,7 +11355,7 @@ public final EObject entryRulefloat64() throws RecognitionException { // $ANTLR start "rulefloat64" - // InternalRos.g:5188:1: rulefloat64 returns [EObject current=null] : ( () otherlv_1= 'float64' ) ; + // InternalRosParser.g:4425:1: rulefloat64 returns [EObject current=null] : ( () otherlv_1= Float64 ) ; public final EObject rulefloat64() throws RecognitionException { EObject current = null; @@ -13040,14 +11365,14 @@ public final EObject rulefloat64() throws RecognitionException { enterRule(); try { - // InternalRos.g:5194:2: ( ( () otherlv_1= 'float64' ) ) - // InternalRos.g:5195:2: ( () otherlv_1= 'float64' ) + // InternalRosParser.g:4431:2: ( ( () otherlv_1= Float64 ) ) + // InternalRosParser.g:4432:2: ( () otherlv_1= Float64 ) { - // InternalRos.g:5195:2: ( () otherlv_1= 'float64' ) - // InternalRos.g:5196:3: () otherlv_1= 'float64' + // InternalRosParser.g:4432:2: ( () otherlv_1= Float64 ) + // InternalRosParser.g:4433:3: () otherlv_1= Float64 { - // InternalRos.g:5196:3: () - // InternalRos.g:5197:4: + // InternalRosParser.g:4433:3: () + // InternalRosParser.g:4434:4: { current = forceCreateModelElement( @@ -13057,7 +11382,7 @@ public final EObject rulefloat64() throws RecognitionException { } - otherlv_1=(Token)match(input,95,FOLLOW_2); + otherlv_1=(Token)match(input,Float64,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getFloat64Access().getFloat64Keyword_1()); @@ -13084,7 +11409,7 @@ public final EObject rulefloat64() throws RecognitionException { // $ANTLR start "entryRulestring0" - // InternalRos.g:5211:1: entryRulestring0 returns [EObject current=null] : iv_rulestring0= rulestring0 EOF ; + // InternalRosParser.g:4448:1: entryRulestring0 returns [EObject current=null] : iv_rulestring0= rulestring0 EOF ; public final EObject entryRulestring0() throws RecognitionException { EObject current = null; @@ -13092,8 +11417,8 @@ public final EObject entryRulestring0() throws RecognitionException { try { - // InternalRos.g:5211:48: (iv_rulestring0= rulestring0 EOF ) - // InternalRos.g:5212:2: iv_rulestring0= rulestring0 EOF + // InternalRosParser.g:4448:48: (iv_rulestring0= rulestring0 EOF ) + // InternalRosParser.g:4449:2: iv_rulestring0= rulestring0 EOF { newCompositeNode(grammarAccess.getString0Rule()); pushFollow(FOLLOW_1); @@ -13120,7 +11445,7 @@ public final EObject entryRulestring0() throws RecognitionException { // $ANTLR start "rulestring0" - // InternalRos.g:5218:1: rulestring0 returns [EObject current=null] : ( () otherlv_1= 'string' ) ; + // InternalRosParser.g:4455:1: rulestring0 returns [EObject current=null] : ( () otherlv_1= String_1 ) ; public final EObject rulestring0() throws RecognitionException { EObject current = null; @@ -13130,14 +11455,14 @@ public final EObject rulestring0() throws RecognitionException { enterRule(); try { - // InternalRos.g:5224:2: ( ( () otherlv_1= 'string' ) ) - // InternalRos.g:5225:2: ( () otherlv_1= 'string' ) + // InternalRosParser.g:4461:2: ( ( () otherlv_1= String_1 ) ) + // InternalRosParser.g:4462:2: ( () otherlv_1= String_1 ) { - // InternalRos.g:5225:2: ( () otherlv_1= 'string' ) - // InternalRos.g:5226:3: () otherlv_1= 'string' + // InternalRosParser.g:4462:2: ( () otherlv_1= String_1 ) + // InternalRosParser.g:4463:3: () otherlv_1= String_1 { - // InternalRos.g:5226:3: () - // InternalRos.g:5227:4: + // InternalRosParser.g:4463:3: () + // InternalRosParser.g:4464:4: { current = forceCreateModelElement( @@ -13147,7 +11472,7 @@ public final EObject rulestring0() throws RecognitionException { } - otherlv_1=(Token)match(input,96,FOLLOW_2); + otherlv_1=(Token)match(input,String_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getString0Access().getStringKeyword_1()); @@ -13174,7 +11499,7 @@ public final EObject rulestring0() throws RecognitionException { // $ANTLR start "entryRulebyte" - // InternalRos.g:5241:1: entryRulebyte returns [EObject current=null] : iv_rulebyte= rulebyte EOF ; + // InternalRosParser.g:4478:1: entryRulebyte returns [EObject current=null] : iv_rulebyte= rulebyte EOF ; public final EObject entryRulebyte() throws RecognitionException { EObject current = null; @@ -13182,8 +11507,8 @@ public final EObject entryRulebyte() throws RecognitionException { try { - // InternalRos.g:5241:45: (iv_rulebyte= rulebyte EOF ) - // InternalRos.g:5242:2: iv_rulebyte= rulebyte EOF + // InternalRosParser.g:4478:45: (iv_rulebyte= rulebyte EOF ) + // InternalRosParser.g:4479:2: iv_rulebyte= rulebyte EOF { newCompositeNode(grammarAccess.getByteRule()); pushFollow(FOLLOW_1); @@ -13210,7 +11535,7 @@ public final EObject entryRulebyte() throws RecognitionException { // $ANTLR start "rulebyte" - // InternalRos.g:5248:1: rulebyte returns [EObject current=null] : ( () otherlv_1= 'byte' ) ; + // InternalRosParser.g:4485:1: rulebyte returns [EObject current=null] : ( () otherlv_1= Byte ) ; public final EObject rulebyte() throws RecognitionException { EObject current = null; @@ -13220,14 +11545,14 @@ public final EObject rulebyte() throws RecognitionException { enterRule(); try { - // InternalRos.g:5254:2: ( ( () otherlv_1= 'byte' ) ) - // InternalRos.g:5255:2: ( () otherlv_1= 'byte' ) + // InternalRosParser.g:4491:2: ( ( () otherlv_1= Byte ) ) + // InternalRosParser.g:4492:2: ( () otherlv_1= Byte ) { - // InternalRos.g:5255:2: ( () otherlv_1= 'byte' ) - // InternalRos.g:5256:3: () otherlv_1= 'byte' + // InternalRosParser.g:4492:2: ( () otherlv_1= Byte ) + // InternalRosParser.g:4493:3: () otherlv_1= Byte { - // InternalRos.g:5256:3: () - // InternalRos.g:5257:4: + // InternalRosParser.g:4493:3: () + // InternalRosParser.g:4494:4: { current = forceCreateModelElement( @@ -13237,7 +11562,7 @@ public final EObject rulebyte() throws RecognitionException { } - otherlv_1=(Token)match(input,97,FOLLOW_2); + otherlv_1=(Token)match(input,Byte,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getByteAccess().getByteKeyword_1()); @@ -13264,7 +11589,7 @@ public final EObject rulebyte() throws RecognitionException { // $ANTLR start "entryRuletime" - // InternalRos.g:5271:1: entryRuletime returns [EObject current=null] : iv_ruletime= ruletime EOF ; + // InternalRosParser.g:4508:1: entryRuletime returns [EObject current=null] : iv_ruletime= ruletime EOF ; public final EObject entryRuletime() throws RecognitionException { EObject current = null; @@ -13272,8 +11597,8 @@ public final EObject entryRuletime() throws RecognitionException { try { - // InternalRos.g:5271:45: (iv_ruletime= ruletime EOF ) - // InternalRos.g:5272:2: iv_ruletime= ruletime EOF + // InternalRosParser.g:4508:45: (iv_ruletime= ruletime EOF ) + // InternalRosParser.g:4509:2: iv_ruletime= ruletime EOF { newCompositeNode(grammarAccess.getTimeRule()); pushFollow(FOLLOW_1); @@ -13300,7 +11625,7 @@ public final EObject entryRuletime() throws RecognitionException { // $ANTLR start "ruletime" - // InternalRos.g:5278:1: ruletime returns [EObject current=null] : ( () otherlv_1= 'time' ) ; + // InternalRosParser.g:4515:1: ruletime returns [EObject current=null] : ( () otherlv_1= Time ) ; public final EObject ruletime() throws RecognitionException { EObject current = null; @@ -13310,14 +11635,14 @@ public final EObject ruletime() throws RecognitionException { enterRule(); try { - // InternalRos.g:5284:2: ( ( () otherlv_1= 'time' ) ) - // InternalRos.g:5285:2: ( () otherlv_1= 'time' ) + // InternalRosParser.g:4521:2: ( ( () otherlv_1= Time ) ) + // InternalRosParser.g:4522:2: ( () otherlv_1= Time ) { - // InternalRos.g:5285:2: ( () otherlv_1= 'time' ) - // InternalRos.g:5286:3: () otherlv_1= 'time' + // InternalRosParser.g:4522:2: ( () otherlv_1= Time ) + // InternalRosParser.g:4523:3: () otherlv_1= Time { - // InternalRos.g:5286:3: () - // InternalRos.g:5287:4: + // InternalRosParser.g:4523:3: () + // InternalRosParser.g:4524:4: { current = forceCreateModelElement( @@ -13327,7 +11652,7 @@ public final EObject ruletime() throws RecognitionException { } - otherlv_1=(Token)match(input,98,FOLLOW_2); + otherlv_1=(Token)match(input,Time,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getTimeAccess().getTimeKeyword_1()); @@ -13354,7 +11679,7 @@ public final EObject ruletime() throws RecognitionException { // $ANTLR start "entryRuleduration" - // InternalRos.g:5301:1: entryRuleduration returns [EObject current=null] : iv_ruleduration= ruleduration EOF ; + // InternalRosParser.g:4538:1: entryRuleduration returns [EObject current=null] : iv_ruleduration= ruleduration EOF ; public final EObject entryRuleduration() throws RecognitionException { EObject current = null; @@ -13362,8 +11687,8 @@ public final EObject entryRuleduration() throws RecognitionException { try { - // InternalRos.g:5301:49: (iv_ruleduration= ruleduration EOF ) - // InternalRos.g:5302:2: iv_ruleduration= ruleduration EOF + // InternalRosParser.g:4538:49: (iv_ruleduration= ruleduration EOF ) + // InternalRosParser.g:4539:2: iv_ruleduration= ruleduration EOF { newCompositeNode(grammarAccess.getDurationRule()); pushFollow(FOLLOW_1); @@ -13390,7 +11715,7 @@ public final EObject entryRuleduration() throws RecognitionException { // $ANTLR start "ruleduration" - // InternalRos.g:5308:1: ruleduration returns [EObject current=null] : ( () otherlv_1= 'duration' ) ; + // InternalRosParser.g:4545:1: ruleduration returns [EObject current=null] : ( () otherlv_1= Duration ) ; public final EObject ruleduration() throws RecognitionException { EObject current = null; @@ -13400,14 +11725,14 @@ public final EObject ruleduration() throws RecognitionException { enterRule(); try { - // InternalRos.g:5314:2: ( ( () otherlv_1= 'duration' ) ) - // InternalRos.g:5315:2: ( () otherlv_1= 'duration' ) + // InternalRosParser.g:4551:2: ( ( () otherlv_1= Duration ) ) + // InternalRosParser.g:4552:2: ( () otherlv_1= Duration ) { - // InternalRos.g:5315:2: ( () otherlv_1= 'duration' ) - // InternalRos.g:5316:3: () otherlv_1= 'duration' + // InternalRosParser.g:4552:2: ( () otherlv_1= Duration ) + // InternalRosParser.g:4553:3: () otherlv_1= Duration { - // InternalRos.g:5316:3: () - // InternalRos.g:5317:4: + // InternalRosParser.g:4553:3: () + // InternalRosParser.g:4554:4: { current = forceCreateModelElement( @@ -13417,7 +11742,7 @@ public final EObject ruleduration() throws RecognitionException { } - otherlv_1=(Token)match(input,99,FOLLOW_2); + otherlv_1=(Token)match(input,Duration,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getDurationAccess().getDurationKeyword_1()); @@ -13444,7 +11769,7 @@ public final EObject ruleduration() throws RecognitionException { // $ANTLR start "entryRuleboolArray" - // InternalRos.g:5331:1: entryRuleboolArray returns [EObject current=null] : iv_ruleboolArray= ruleboolArray EOF ; + // InternalRosParser.g:4568:1: entryRuleboolArray returns [EObject current=null] : iv_ruleboolArray= ruleboolArray EOF ; public final EObject entryRuleboolArray() throws RecognitionException { EObject current = null; @@ -13452,8 +11777,8 @@ public final EObject entryRuleboolArray() throws RecognitionException { try { - // InternalRos.g:5331:50: (iv_ruleboolArray= ruleboolArray EOF ) - // InternalRos.g:5332:2: iv_ruleboolArray= ruleboolArray EOF + // InternalRosParser.g:4568:50: (iv_ruleboolArray= ruleboolArray EOF ) + // InternalRosParser.g:4569:2: iv_ruleboolArray= ruleboolArray EOF { newCompositeNode(grammarAccess.getBoolArrayRule()); pushFollow(FOLLOW_1); @@ -13480,7 +11805,7 @@ public final EObject entryRuleboolArray() throws RecognitionException { // $ANTLR start "ruleboolArray" - // InternalRos.g:5338:1: ruleboolArray returns [EObject current=null] : ( () otherlv_1= 'bool[]' ) ; + // InternalRosParser.g:4575:1: ruleboolArray returns [EObject current=null] : ( () otherlv_1= Bool_1 ) ; public final EObject ruleboolArray() throws RecognitionException { EObject current = null; @@ -13490,14 +11815,14 @@ public final EObject ruleboolArray() throws RecognitionException { enterRule(); try { - // InternalRos.g:5344:2: ( ( () otherlv_1= 'bool[]' ) ) - // InternalRos.g:5345:2: ( () otherlv_1= 'bool[]' ) + // InternalRosParser.g:4581:2: ( ( () otherlv_1= Bool_1 ) ) + // InternalRosParser.g:4582:2: ( () otherlv_1= Bool_1 ) { - // InternalRos.g:5345:2: ( () otherlv_1= 'bool[]' ) - // InternalRos.g:5346:3: () otherlv_1= 'bool[]' + // InternalRosParser.g:4582:2: ( () otherlv_1= Bool_1 ) + // InternalRosParser.g:4583:3: () otherlv_1= Bool_1 { - // InternalRos.g:5346:3: () - // InternalRos.g:5347:4: + // InternalRosParser.g:4583:3: () + // InternalRosParser.g:4584:4: { current = forceCreateModelElement( @@ -13507,7 +11832,7 @@ public final EObject ruleboolArray() throws RecognitionException { } - otherlv_1=(Token)match(input,100,FOLLOW_2); + otherlv_1=(Token)match(input,Bool_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); @@ -13534,7 +11859,7 @@ public final EObject ruleboolArray() throws RecognitionException { // $ANTLR start "entryRuleint8Array" - // InternalRos.g:5361:1: entryRuleint8Array returns [EObject current=null] : iv_ruleint8Array= ruleint8Array EOF ; + // InternalRosParser.g:4598:1: entryRuleint8Array returns [EObject current=null] : iv_ruleint8Array= ruleint8Array EOF ; public final EObject entryRuleint8Array() throws RecognitionException { EObject current = null; @@ -13542,8 +11867,8 @@ public final EObject entryRuleint8Array() throws RecognitionException { try { - // InternalRos.g:5361:50: (iv_ruleint8Array= ruleint8Array EOF ) - // InternalRos.g:5362:2: iv_ruleint8Array= ruleint8Array EOF + // InternalRosParser.g:4598:50: (iv_ruleint8Array= ruleint8Array EOF ) + // InternalRosParser.g:4599:2: iv_ruleint8Array= ruleint8Array EOF { newCompositeNode(grammarAccess.getInt8ArrayRule()); pushFollow(FOLLOW_1); @@ -13570,7 +11895,7 @@ public final EObject entryRuleint8Array() throws RecognitionException { // $ANTLR start "ruleint8Array" - // InternalRos.g:5368:1: ruleint8Array returns [EObject current=null] : ( () otherlv_1= 'int8[]' ) ; + // InternalRosParser.g:4605:1: ruleint8Array returns [EObject current=null] : ( () otherlv_1= Int8_1 ) ; public final EObject ruleint8Array() throws RecognitionException { EObject current = null; @@ -13580,14 +11905,14 @@ public final EObject ruleint8Array() throws RecognitionException { enterRule(); try { - // InternalRos.g:5374:2: ( ( () otherlv_1= 'int8[]' ) ) - // InternalRos.g:5375:2: ( () otherlv_1= 'int8[]' ) + // InternalRosParser.g:4611:2: ( ( () otherlv_1= Int8_1 ) ) + // InternalRosParser.g:4612:2: ( () otherlv_1= Int8_1 ) { - // InternalRos.g:5375:2: ( () otherlv_1= 'int8[]' ) - // InternalRos.g:5376:3: () otherlv_1= 'int8[]' + // InternalRosParser.g:4612:2: ( () otherlv_1= Int8_1 ) + // InternalRosParser.g:4613:3: () otherlv_1= Int8_1 { - // InternalRos.g:5376:3: () - // InternalRos.g:5377:4: + // InternalRosParser.g:4613:3: () + // InternalRosParser.g:4614:4: { current = forceCreateModelElement( @@ -13597,7 +11922,7 @@ public final EObject ruleint8Array() throws RecognitionException { } - otherlv_1=(Token)match(input,101,FOLLOW_2); + otherlv_1=(Token)match(input,Int8_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); @@ -13624,7 +11949,7 @@ public final EObject ruleint8Array() throws RecognitionException { // $ANTLR start "entryRuleuint8Array" - // InternalRos.g:5391:1: entryRuleuint8Array returns [EObject current=null] : iv_ruleuint8Array= ruleuint8Array EOF ; + // InternalRosParser.g:4628:1: entryRuleuint8Array returns [EObject current=null] : iv_ruleuint8Array= ruleuint8Array EOF ; public final EObject entryRuleuint8Array() throws RecognitionException { EObject current = null; @@ -13632,8 +11957,8 @@ public final EObject entryRuleuint8Array() throws RecognitionException { try { - // InternalRos.g:5391:51: (iv_ruleuint8Array= ruleuint8Array EOF ) - // InternalRos.g:5392:2: iv_ruleuint8Array= ruleuint8Array EOF + // InternalRosParser.g:4628:51: (iv_ruleuint8Array= ruleuint8Array EOF ) + // InternalRosParser.g:4629:2: iv_ruleuint8Array= ruleuint8Array EOF { newCompositeNode(grammarAccess.getUint8ArrayRule()); pushFollow(FOLLOW_1); @@ -13660,7 +11985,7 @@ public final EObject entryRuleuint8Array() throws RecognitionException { // $ANTLR start "ruleuint8Array" - // InternalRos.g:5398:1: ruleuint8Array returns [EObject current=null] : ( () otherlv_1= 'uint8[]' ) ; + // InternalRosParser.g:4635:1: ruleuint8Array returns [EObject current=null] : ( () otherlv_1= Uint8_1 ) ; public final EObject ruleuint8Array() throws RecognitionException { EObject current = null; @@ -13670,14 +11995,14 @@ public final EObject ruleuint8Array() throws RecognitionException { enterRule(); try { - // InternalRos.g:5404:2: ( ( () otherlv_1= 'uint8[]' ) ) - // InternalRos.g:5405:2: ( () otherlv_1= 'uint8[]' ) + // InternalRosParser.g:4641:2: ( ( () otherlv_1= Uint8_1 ) ) + // InternalRosParser.g:4642:2: ( () otherlv_1= Uint8_1 ) { - // InternalRos.g:5405:2: ( () otherlv_1= 'uint8[]' ) - // InternalRos.g:5406:3: () otherlv_1= 'uint8[]' + // InternalRosParser.g:4642:2: ( () otherlv_1= Uint8_1 ) + // InternalRosParser.g:4643:3: () otherlv_1= Uint8_1 { - // InternalRos.g:5406:3: () - // InternalRos.g:5407:4: + // InternalRosParser.g:4643:3: () + // InternalRosParser.g:4644:4: { current = forceCreateModelElement( @@ -13687,7 +12012,7 @@ public final EObject ruleuint8Array() throws RecognitionException { } - otherlv_1=(Token)match(input,102,FOLLOW_2); + otherlv_1=(Token)match(input,Uint8_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); @@ -13714,7 +12039,7 @@ public final EObject ruleuint8Array() throws RecognitionException { // $ANTLR start "entryRuleint16Array" - // InternalRos.g:5421:1: entryRuleint16Array returns [EObject current=null] : iv_ruleint16Array= ruleint16Array EOF ; + // InternalRosParser.g:4658:1: entryRuleint16Array returns [EObject current=null] : iv_ruleint16Array= ruleint16Array EOF ; public final EObject entryRuleint16Array() throws RecognitionException { EObject current = null; @@ -13722,8 +12047,8 @@ public final EObject entryRuleint16Array() throws RecognitionException { try { - // InternalRos.g:5421:51: (iv_ruleint16Array= ruleint16Array EOF ) - // InternalRos.g:5422:2: iv_ruleint16Array= ruleint16Array EOF + // InternalRosParser.g:4658:51: (iv_ruleint16Array= ruleint16Array EOF ) + // InternalRosParser.g:4659:2: iv_ruleint16Array= ruleint16Array EOF { newCompositeNode(grammarAccess.getInt16ArrayRule()); pushFollow(FOLLOW_1); @@ -13750,7 +12075,7 @@ public final EObject entryRuleint16Array() throws RecognitionException { // $ANTLR start "ruleint16Array" - // InternalRos.g:5428:1: ruleint16Array returns [EObject current=null] : ( () otherlv_1= 'int16[]' ) ; + // InternalRosParser.g:4665:1: ruleint16Array returns [EObject current=null] : ( () otherlv_1= Int16_1 ) ; public final EObject ruleint16Array() throws RecognitionException { EObject current = null; @@ -13760,14 +12085,14 @@ public final EObject ruleint16Array() throws RecognitionException { enterRule(); try { - // InternalRos.g:5434:2: ( ( () otherlv_1= 'int16[]' ) ) - // InternalRos.g:5435:2: ( () otherlv_1= 'int16[]' ) + // InternalRosParser.g:4671:2: ( ( () otherlv_1= Int16_1 ) ) + // InternalRosParser.g:4672:2: ( () otherlv_1= Int16_1 ) { - // InternalRos.g:5435:2: ( () otherlv_1= 'int16[]' ) - // InternalRos.g:5436:3: () otherlv_1= 'int16[]' + // InternalRosParser.g:4672:2: ( () otherlv_1= Int16_1 ) + // InternalRosParser.g:4673:3: () otherlv_1= Int16_1 { - // InternalRos.g:5436:3: () - // InternalRos.g:5437:4: + // InternalRosParser.g:4673:3: () + // InternalRosParser.g:4674:4: { current = forceCreateModelElement( @@ -13777,7 +12102,7 @@ public final EObject ruleint16Array() throws RecognitionException { } - otherlv_1=(Token)match(input,103,FOLLOW_2); + otherlv_1=(Token)match(input,Int16_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); @@ -13804,7 +12129,7 @@ public final EObject ruleint16Array() throws RecognitionException { // $ANTLR start "entryRuleuint16Array" - // InternalRos.g:5451:1: entryRuleuint16Array returns [EObject current=null] : iv_ruleuint16Array= ruleuint16Array EOF ; + // InternalRosParser.g:4688:1: entryRuleuint16Array returns [EObject current=null] : iv_ruleuint16Array= ruleuint16Array EOF ; public final EObject entryRuleuint16Array() throws RecognitionException { EObject current = null; @@ -13812,8 +12137,8 @@ public final EObject entryRuleuint16Array() throws RecognitionException { try { - // InternalRos.g:5451:52: (iv_ruleuint16Array= ruleuint16Array EOF ) - // InternalRos.g:5452:2: iv_ruleuint16Array= ruleuint16Array EOF + // InternalRosParser.g:4688:52: (iv_ruleuint16Array= ruleuint16Array EOF ) + // InternalRosParser.g:4689:2: iv_ruleuint16Array= ruleuint16Array EOF { newCompositeNode(grammarAccess.getUint16ArrayRule()); pushFollow(FOLLOW_1); @@ -13840,7 +12165,7 @@ public final EObject entryRuleuint16Array() throws RecognitionException { // $ANTLR start "ruleuint16Array" - // InternalRos.g:5458:1: ruleuint16Array returns [EObject current=null] : ( () otherlv_1= 'uint16[]' ) ; + // InternalRosParser.g:4695:1: ruleuint16Array returns [EObject current=null] : ( () otherlv_1= Uint16_1 ) ; public final EObject ruleuint16Array() throws RecognitionException { EObject current = null; @@ -13850,14 +12175,14 @@ public final EObject ruleuint16Array() throws RecognitionException { enterRule(); try { - // InternalRos.g:5464:2: ( ( () otherlv_1= 'uint16[]' ) ) - // InternalRos.g:5465:2: ( () otherlv_1= 'uint16[]' ) + // InternalRosParser.g:4701:2: ( ( () otherlv_1= Uint16_1 ) ) + // InternalRosParser.g:4702:2: ( () otherlv_1= Uint16_1 ) { - // InternalRos.g:5465:2: ( () otherlv_1= 'uint16[]' ) - // InternalRos.g:5466:3: () otherlv_1= 'uint16[]' + // InternalRosParser.g:4702:2: ( () otherlv_1= Uint16_1 ) + // InternalRosParser.g:4703:3: () otherlv_1= Uint16_1 { - // InternalRos.g:5466:3: () - // InternalRos.g:5467:4: + // InternalRosParser.g:4703:3: () + // InternalRosParser.g:4704:4: { current = forceCreateModelElement( @@ -13867,7 +12192,7 @@ public final EObject ruleuint16Array() throws RecognitionException { } - otherlv_1=(Token)match(input,104,FOLLOW_2); + otherlv_1=(Token)match(input,Uint16_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); @@ -13894,7 +12219,7 @@ public final EObject ruleuint16Array() throws RecognitionException { // $ANTLR start "entryRuleint32Array" - // InternalRos.g:5481:1: entryRuleint32Array returns [EObject current=null] : iv_ruleint32Array= ruleint32Array EOF ; + // InternalRosParser.g:4718:1: entryRuleint32Array returns [EObject current=null] : iv_ruleint32Array= ruleint32Array EOF ; public final EObject entryRuleint32Array() throws RecognitionException { EObject current = null; @@ -13902,8 +12227,8 @@ public final EObject entryRuleint32Array() throws RecognitionException { try { - // InternalRos.g:5481:51: (iv_ruleint32Array= ruleint32Array EOF ) - // InternalRos.g:5482:2: iv_ruleint32Array= ruleint32Array EOF + // InternalRosParser.g:4718:51: (iv_ruleint32Array= ruleint32Array EOF ) + // InternalRosParser.g:4719:2: iv_ruleint32Array= ruleint32Array EOF { newCompositeNode(grammarAccess.getInt32ArrayRule()); pushFollow(FOLLOW_1); @@ -13930,7 +12255,7 @@ public final EObject entryRuleint32Array() throws RecognitionException { // $ANTLR start "ruleint32Array" - // InternalRos.g:5488:1: ruleint32Array returns [EObject current=null] : ( () otherlv_1= 'int32[]' ) ; + // InternalRosParser.g:4725:1: ruleint32Array returns [EObject current=null] : ( () otherlv_1= Int32_1 ) ; public final EObject ruleint32Array() throws RecognitionException { EObject current = null; @@ -13940,14 +12265,14 @@ public final EObject ruleint32Array() throws RecognitionException { enterRule(); try { - // InternalRos.g:5494:2: ( ( () otherlv_1= 'int32[]' ) ) - // InternalRos.g:5495:2: ( () otherlv_1= 'int32[]' ) + // InternalRosParser.g:4731:2: ( ( () otherlv_1= Int32_1 ) ) + // InternalRosParser.g:4732:2: ( () otherlv_1= Int32_1 ) { - // InternalRos.g:5495:2: ( () otherlv_1= 'int32[]' ) - // InternalRos.g:5496:3: () otherlv_1= 'int32[]' + // InternalRosParser.g:4732:2: ( () otherlv_1= Int32_1 ) + // InternalRosParser.g:4733:3: () otherlv_1= Int32_1 { - // InternalRos.g:5496:3: () - // InternalRos.g:5497:4: + // InternalRosParser.g:4733:3: () + // InternalRosParser.g:4734:4: { current = forceCreateModelElement( @@ -13957,7 +12282,7 @@ public final EObject ruleint32Array() throws RecognitionException { } - otherlv_1=(Token)match(input,105,FOLLOW_2); + otherlv_1=(Token)match(input,Int32_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); @@ -13984,7 +12309,7 @@ public final EObject ruleint32Array() throws RecognitionException { // $ANTLR start "entryRuleuint32Array" - // InternalRos.g:5511:1: entryRuleuint32Array returns [EObject current=null] : iv_ruleuint32Array= ruleuint32Array EOF ; + // InternalRosParser.g:4748:1: entryRuleuint32Array returns [EObject current=null] : iv_ruleuint32Array= ruleuint32Array EOF ; public final EObject entryRuleuint32Array() throws RecognitionException { EObject current = null; @@ -13992,8 +12317,8 @@ public final EObject entryRuleuint32Array() throws RecognitionException { try { - // InternalRos.g:5511:52: (iv_ruleuint32Array= ruleuint32Array EOF ) - // InternalRos.g:5512:2: iv_ruleuint32Array= ruleuint32Array EOF + // InternalRosParser.g:4748:52: (iv_ruleuint32Array= ruleuint32Array EOF ) + // InternalRosParser.g:4749:2: iv_ruleuint32Array= ruleuint32Array EOF { newCompositeNode(grammarAccess.getUint32ArrayRule()); pushFollow(FOLLOW_1); @@ -14020,7 +12345,7 @@ public final EObject entryRuleuint32Array() throws RecognitionException { // $ANTLR start "ruleuint32Array" - // InternalRos.g:5518:1: ruleuint32Array returns [EObject current=null] : ( () otherlv_1= 'uint32[]' ) ; + // InternalRosParser.g:4755:1: ruleuint32Array returns [EObject current=null] : ( () otherlv_1= Uint32_1 ) ; public final EObject ruleuint32Array() throws RecognitionException { EObject current = null; @@ -14030,14 +12355,14 @@ public final EObject ruleuint32Array() throws RecognitionException { enterRule(); try { - // InternalRos.g:5524:2: ( ( () otherlv_1= 'uint32[]' ) ) - // InternalRos.g:5525:2: ( () otherlv_1= 'uint32[]' ) + // InternalRosParser.g:4761:2: ( ( () otherlv_1= Uint32_1 ) ) + // InternalRosParser.g:4762:2: ( () otherlv_1= Uint32_1 ) { - // InternalRos.g:5525:2: ( () otherlv_1= 'uint32[]' ) - // InternalRos.g:5526:3: () otherlv_1= 'uint32[]' + // InternalRosParser.g:4762:2: ( () otherlv_1= Uint32_1 ) + // InternalRosParser.g:4763:3: () otherlv_1= Uint32_1 { - // InternalRos.g:5526:3: () - // InternalRos.g:5527:4: + // InternalRosParser.g:4763:3: () + // InternalRosParser.g:4764:4: { current = forceCreateModelElement( @@ -14047,7 +12372,7 @@ public final EObject ruleuint32Array() throws RecognitionException { } - otherlv_1=(Token)match(input,106,FOLLOW_2); + otherlv_1=(Token)match(input,Uint32_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); @@ -14074,7 +12399,7 @@ public final EObject ruleuint32Array() throws RecognitionException { // $ANTLR start "entryRuleint64Array" - // InternalRos.g:5541:1: entryRuleint64Array returns [EObject current=null] : iv_ruleint64Array= ruleint64Array EOF ; + // InternalRosParser.g:4778:1: entryRuleint64Array returns [EObject current=null] : iv_ruleint64Array= ruleint64Array EOF ; public final EObject entryRuleint64Array() throws RecognitionException { EObject current = null; @@ -14082,8 +12407,8 @@ public final EObject entryRuleint64Array() throws RecognitionException { try { - // InternalRos.g:5541:51: (iv_ruleint64Array= ruleint64Array EOF ) - // InternalRos.g:5542:2: iv_ruleint64Array= ruleint64Array EOF + // InternalRosParser.g:4778:51: (iv_ruleint64Array= ruleint64Array EOF ) + // InternalRosParser.g:4779:2: iv_ruleint64Array= ruleint64Array EOF { newCompositeNode(grammarAccess.getInt64ArrayRule()); pushFollow(FOLLOW_1); @@ -14110,7 +12435,7 @@ public final EObject entryRuleint64Array() throws RecognitionException { // $ANTLR start "ruleint64Array" - // InternalRos.g:5548:1: ruleint64Array returns [EObject current=null] : ( () otherlv_1= 'int64[]' ) ; + // InternalRosParser.g:4785:1: ruleint64Array returns [EObject current=null] : ( () otherlv_1= Int64_1 ) ; public final EObject ruleint64Array() throws RecognitionException { EObject current = null; @@ -14120,14 +12445,14 @@ public final EObject ruleint64Array() throws RecognitionException { enterRule(); try { - // InternalRos.g:5554:2: ( ( () otherlv_1= 'int64[]' ) ) - // InternalRos.g:5555:2: ( () otherlv_1= 'int64[]' ) + // InternalRosParser.g:4791:2: ( ( () otherlv_1= Int64_1 ) ) + // InternalRosParser.g:4792:2: ( () otherlv_1= Int64_1 ) { - // InternalRos.g:5555:2: ( () otherlv_1= 'int64[]' ) - // InternalRos.g:5556:3: () otherlv_1= 'int64[]' + // InternalRosParser.g:4792:2: ( () otherlv_1= Int64_1 ) + // InternalRosParser.g:4793:3: () otherlv_1= Int64_1 { - // InternalRos.g:5556:3: () - // InternalRos.g:5557:4: + // InternalRosParser.g:4793:3: () + // InternalRosParser.g:4794:4: { current = forceCreateModelElement( @@ -14137,7 +12462,7 @@ public final EObject ruleint64Array() throws RecognitionException { } - otherlv_1=(Token)match(input,107,FOLLOW_2); + otherlv_1=(Token)match(input,Int64_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); @@ -14164,7 +12489,7 @@ public final EObject ruleint64Array() throws RecognitionException { // $ANTLR start "entryRuleuint64Array" - // InternalRos.g:5571:1: entryRuleuint64Array returns [EObject current=null] : iv_ruleuint64Array= ruleuint64Array EOF ; + // InternalRosParser.g:4808:1: entryRuleuint64Array returns [EObject current=null] : iv_ruleuint64Array= ruleuint64Array EOF ; public final EObject entryRuleuint64Array() throws RecognitionException { EObject current = null; @@ -14172,8 +12497,8 @@ public final EObject entryRuleuint64Array() throws RecognitionException { try { - // InternalRos.g:5571:52: (iv_ruleuint64Array= ruleuint64Array EOF ) - // InternalRos.g:5572:2: iv_ruleuint64Array= ruleuint64Array EOF + // InternalRosParser.g:4808:52: (iv_ruleuint64Array= ruleuint64Array EOF ) + // InternalRosParser.g:4809:2: iv_ruleuint64Array= ruleuint64Array EOF { newCompositeNode(grammarAccess.getUint64ArrayRule()); pushFollow(FOLLOW_1); @@ -14200,7 +12525,7 @@ public final EObject entryRuleuint64Array() throws RecognitionException { // $ANTLR start "ruleuint64Array" - // InternalRos.g:5578:1: ruleuint64Array returns [EObject current=null] : ( () otherlv_1= 'uint64[]' ) ; + // InternalRosParser.g:4815:1: ruleuint64Array returns [EObject current=null] : ( () otherlv_1= Uint64_1 ) ; public final EObject ruleuint64Array() throws RecognitionException { EObject current = null; @@ -14210,14 +12535,14 @@ public final EObject ruleuint64Array() throws RecognitionException { enterRule(); try { - // InternalRos.g:5584:2: ( ( () otherlv_1= 'uint64[]' ) ) - // InternalRos.g:5585:2: ( () otherlv_1= 'uint64[]' ) + // InternalRosParser.g:4821:2: ( ( () otherlv_1= Uint64_1 ) ) + // InternalRosParser.g:4822:2: ( () otherlv_1= Uint64_1 ) { - // InternalRos.g:5585:2: ( () otherlv_1= 'uint64[]' ) - // InternalRos.g:5586:3: () otherlv_1= 'uint64[]' + // InternalRosParser.g:4822:2: ( () otherlv_1= Uint64_1 ) + // InternalRosParser.g:4823:3: () otherlv_1= Uint64_1 { - // InternalRos.g:5586:3: () - // InternalRos.g:5587:4: + // InternalRosParser.g:4823:3: () + // InternalRosParser.g:4824:4: { current = forceCreateModelElement( @@ -14227,7 +12552,7 @@ public final EObject ruleuint64Array() throws RecognitionException { } - otherlv_1=(Token)match(input,108,FOLLOW_2); + otherlv_1=(Token)match(input,Uint64_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); @@ -14254,7 +12579,7 @@ public final EObject ruleuint64Array() throws RecognitionException { // $ANTLR start "entryRulefloat32Array" - // InternalRos.g:5601:1: entryRulefloat32Array returns [EObject current=null] : iv_rulefloat32Array= rulefloat32Array EOF ; + // InternalRosParser.g:4838:1: entryRulefloat32Array returns [EObject current=null] : iv_rulefloat32Array= rulefloat32Array EOF ; public final EObject entryRulefloat32Array() throws RecognitionException { EObject current = null; @@ -14262,8 +12587,8 @@ public final EObject entryRulefloat32Array() throws RecognitionException { try { - // InternalRos.g:5601:53: (iv_rulefloat32Array= rulefloat32Array EOF ) - // InternalRos.g:5602:2: iv_rulefloat32Array= rulefloat32Array EOF + // InternalRosParser.g:4838:53: (iv_rulefloat32Array= rulefloat32Array EOF ) + // InternalRosParser.g:4839:2: iv_rulefloat32Array= rulefloat32Array EOF { newCompositeNode(grammarAccess.getFloat32ArrayRule()); pushFollow(FOLLOW_1); @@ -14290,7 +12615,7 @@ public final EObject entryRulefloat32Array() throws RecognitionException { // $ANTLR start "rulefloat32Array" - // InternalRos.g:5608:1: rulefloat32Array returns [EObject current=null] : ( () otherlv_1= 'float32[]' ) ; + // InternalRosParser.g:4845:1: rulefloat32Array returns [EObject current=null] : ( () otherlv_1= Float32_1 ) ; public final EObject rulefloat32Array() throws RecognitionException { EObject current = null; @@ -14300,14 +12625,14 @@ public final EObject rulefloat32Array() throws RecognitionException { enterRule(); try { - // InternalRos.g:5614:2: ( ( () otherlv_1= 'float32[]' ) ) - // InternalRos.g:5615:2: ( () otherlv_1= 'float32[]' ) + // InternalRosParser.g:4851:2: ( ( () otherlv_1= Float32_1 ) ) + // InternalRosParser.g:4852:2: ( () otherlv_1= Float32_1 ) { - // InternalRos.g:5615:2: ( () otherlv_1= 'float32[]' ) - // InternalRos.g:5616:3: () otherlv_1= 'float32[]' + // InternalRosParser.g:4852:2: ( () otherlv_1= Float32_1 ) + // InternalRosParser.g:4853:3: () otherlv_1= Float32_1 { - // InternalRos.g:5616:3: () - // InternalRos.g:5617:4: + // InternalRosParser.g:4853:3: () + // InternalRosParser.g:4854:4: { current = forceCreateModelElement( @@ -14317,7 +12642,7 @@ public final EObject rulefloat32Array() throws RecognitionException { } - otherlv_1=(Token)match(input,109,FOLLOW_2); + otherlv_1=(Token)match(input,Float32_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); @@ -14344,7 +12669,7 @@ public final EObject rulefloat32Array() throws RecognitionException { // $ANTLR start "entryRulefloat64Array" - // InternalRos.g:5631:1: entryRulefloat64Array returns [EObject current=null] : iv_rulefloat64Array= rulefloat64Array EOF ; + // InternalRosParser.g:4868:1: entryRulefloat64Array returns [EObject current=null] : iv_rulefloat64Array= rulefloat64Array EOF ; public final EObject entryRulefloat64Array() throws RecognitionException { EObject current = null; @@ -14352,8 +12677,8 @@ public final EObject entryRulefloat64Array() throws RecognitionException { try { - // InternalRos.g:5631:53: (iv_rulefloat64Array= rulefloat64Array EOF ) - // InternalRos.g:5632:2: iv_rulefloat64Array= rulefloat64Array EOF + // InternalRosParser.g:4868:53: (iv_rulefloat64Array= rulefloat64Array EOF ) + // InternalRosParser.g:4869:2: iv_rulefloat64Array= rulefloat64Array EOF { newCompositeNode(grammarAccess.getFloat64ArrayRule()); pushFollow(FOLLOW_1); @@ -14380,7 +12705,7 @@ public final EObject entryRulefloat64Array() throws RecognitionException { // $ANTLR start "rulefloat64Array" - // InternalRos.g:5638:1: rulefloat64Array returns [EObject current=null] : ( () otherlv_1= 'float64[]' ) ; + // InternalRosParser.g:4875:1: rulefloat64Array returns [EObject current=null] : ( () otherlv_1= Float64_1 ) ; public final EObject rulefloat64Array() throws RecognitionException { EObject current = null; @@ -14390,14 +12715,14 @@ public final EObject rulefloat64Array() throws RecognitionException { enterRule(); try { - // InternalRos.g:5644:2: ( ( () otherlv_1= 'float64[]' ) ) - // InternalRos.g:5645:2: ( () otherlv_1= 'float64[]' ) + // InternalRosParser.g:4881:2: ( ( () otherlv_1= Float64_1 ) ) + // InternalRosParser.g:4882:2: ( () otherlv_1= Float64_1 ) { - // InternalRos.g:5645:2: ( () otherlv_1= 'float64[]' ) - // InternalRos.g:5646:3: () otherlv_1= 'float64[]' + // InternalRosParser.g:4882:2: ( () otherlv_1= Float64_1 ) + // InternalRosParser.g:4883:3: () otherlv_1= Float64_1 { - // InternalRos.g:5646:3: () - // InternalRos.g:5647:4: + // InternalRosParser.g:4883:3: () + // InternalRosParser.g:4884:4: { current = forceCreateModelElement( @@ -14407,7 +12732,7 @@ public final EObject rulefloat64Array() throws RecognitionException { } - otherlv_1=(Token)match(input,110,FOLLOW_2); + otherlv_1=(Token)match(input,Float64_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); @@ -14434,7 +12759,7 @@ public final EObject rulefloat64Array() throws RecognitionException { // $ANTLR start "entryRulestring0Array" - // InternalRos.g:5661:1: entryRulestring0Array returns [EObject current=null] : iv_rulestring0Array= rulestring0Array EOF ; + // InternalRosParser.g:4898:1: entryRulestring0Array returns [EObject current=null] : iv_rulestring0Array= rulestring0Array EOF ; public final EObject entryRulestring0Array() throws RecognitionException { EObject current = null; @@ -14442,8 +12767,8 @@ public final EObject entryRulestring0Array() throws RecognitionException { try { - // InternalRos.g:5661:53: (iv_rulestring0Array= rulestring0Array EOF ) - // InternalRos.g:5662:2: iv_rulestring0Array= rulestring0Array EOF + // InternalRosParser.g:4898:53: (iv_rulestring0Array= rulestring0Array EOF ) + // InternalRosParser.g:4899:2: iv_rulestring0Array= rulestring0Array EOF { newCompositeNode(grammarAccess.getString0ArrayRule()); pushFollow(FOLLOW_1); @@ -14470,7 +12795,7 @@ public final EObject entryRulestring0Array() throws RecognitionException { // $ANTLR start "rulestring0Array" - // InternalRos.g:5668:1: rulestring0Array returns [EObject current=null] : ( () otherlv_1= 'string[]' ) ; + // InternalRosParser.g:4905:1: rulestring0Array returns [EObject current=null] : ( () otherlv_1= String_2 ) ; public final EObject rulestring0Array() throws RecognitionException { EObject current = null; @@ -14480,14 +12805,14 @@ public final EObject rulestring0Array() throws RecognitionException { enterRule(); try { - // InternalRos.g:5674:2: ( ( () otherlv_1= 'string[]' ) ) - // InternalRos.g:5675:2: ( () otherlv_1= 'string[]' ) + // InternalRosParser.g:4911:2: ( ( () otherlv_1= String_2 ) ) + // InternalRosParser.g:4912:2: ( () otherlv_1= String_2 ) { - // InternalRos.g:5675:2: ( () otherlv_1= 'string[]' ) - // InternalRos.g:5676:3: () otherlv_1= 'string[]' + // InternalRosParser.g:4912:2: ( () otherlv_1= String_2 ) + // InternalRosParser.g:4913:3: () otherlv_1= String_2 { - // InternalRos.g:5676:3: () - // InternalRos.g:5677:4: + // InternalRosParser.g:4913:3: () + // InternalRosParser.g:4914:4: { current = forceCreateModelElement( @@ -14497,7 +12822,7 @@ public final EObject rulestring0Array() throws RecognitionException { } - otherlv_1=(Token)match(input,111,FOLLOW_2); + otherlv_1=(Token)match(input,String_2,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getString0ArrayAccess().getStringKeyword_1()); @@ -14524,7 +12849,7 @@ public final EObject rulestring0Array() throws RecognitionException { // $ANTLR start "entryRulebyteArray" - // InternalRos.g:5691:1: entryRulebyteArray returns [EObject current=null] : iv_rulebyteArray= rulebyteArray EOF ; + // InternalRosParser.g:4928:1: entryRulebyteArray returns [EObject current=null] : iv_rulebyteArray= rulebyteArray EOF ; public final EObject entryRulebyteArray() throws RecognitionException { EObject current = null; @@ -14532,8 +12857,8 @@ public final EObject entryRulebyteArray() throws RecognitionException { try { - // InternalRos.g:5691:50: (iv_rulebyteArray= rulebyteArray EOF ) - // InternalRos.g:5692:2: iv_rulebyteArray= rulebyteArray EOF + // InternalRosParser.g:4928:50: (iv_rulebyteArray= rulebyteArray EOF ) + // InternalRosParser.g:4929:2: iv_rulebyteArray= rulebyteArray EOF { newCompositeNode(grammarAccess.getByteArrayRule()); pushFollow(FOLLOW_1); @@ -14560,7 +12885,7 @@ public final EObject entryRulebyteArray() throws RecognitionException { // $ANTLR start "rulebyteArray" - // InternalRos.g:5698:1: rulebyteArray returns [EObject current=null] : ( () otherlv_1= 'byte[]' ) ; + // InternalRosParser.g:4935:1: rulebyteArray returns [EObject current=null] : ( () otherlv_1= Byte_1 ) ; public final EObject rulebyteArray() throws RecognitionException { EObject current = null; @@ -14570,14 +12895,14 @@ public final EObject rulebyteArray() throws RecognitionException { enterRule(); try { - // InternalRos.g:5704:2: ( ( () otherlv_1= 'byte[]' ) ) - // InternalRos.g:5705:2: ( () otherlv_1= 'byte[]' ) + // InternalRosParser.g:4941:2: ( ( () otherlv_1= Byte_1 ) ) + // InternalRosParser.g:4942:2: ( () otherlv_1= Byte_1 ) { - // InternalRos.g:5705:2: ( () otherlv_1= 'byte[]' ) - // InternalRos.g:5706:3: () otherlv_1= 'byte[]' + // InternalRosParser.g:4942:2: ( () otherlv_1= Byte_1 ) + // InternalRosParser.g:4943:3: () otherlv_1= Byte_1 { - // InternalRos.g:5706:3: () - // InternalRos.g:5707:4: + // InternalRosParser.g:4943:3: () + // InternalRosParser.g:4944:4: { current = forceCreateModelElement( @@ -14587,7 +12912,7 @@ public final EObject rulebyteArray() throws RecognitionException { } - otherlv_1=(Token)match(input,112,FOLLOW_2); + otherlv_1=(Token)match(input,Byte_1,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getByteArrayAccess().getByteKeyword_1()); @@ -14614,7 +12939,7 @@ public final EObject rulebyteArray() throws RecognitionException { // $ANTLR start "entryRuleHeader" - // InternalRos.g:5721:1: entryRuleHeader returns [EObject current=null] : iv_ruleHeader= ruleHeader EOF ; + // InternalRosParser.g:4958:1: entryRuleHeader returns [EObject current=null] : iv_ruleHeader= ruleHeader EOF ; public final EObject entryRuleHeader() throws RecognitionException { EObject current = null; @@ -14622,8 +12947,8 @@ public final EObject entryRuleHeader() throws RecognitionException { try { - // InternalRos.g:5721:47: (iv_ruleHeader= ruleHeader EOF ) - // InternalRos.g:5722:2: iv_ruleHeader= ruleHeader EOF + // InternalRosParser.g:4958:47: (iv_ruleHeader= ruleHeader EOF ) + // InternalRosParser.g:4959:2: iv_ruleHeader= ruleHeader EOF { newCompositeNode(grammarAccess.getHeaderRule()); pushFollow(FOLLOW_1); @@ -14650,7 +12975,7 @@ public final EObject entryRuleHeader() throws RecognitionException { // $ANTLR start "ruleHeader" - // InternalRos.g:5728:1: ruleHeader returns [EObject current=null] : ( () otherlv_1= 'Header' ) ; + // InternalRosParser.g:4965:1: ruleHeader returns [EObject current=null] : ( () otherlv_1= Header ) ; public final EObject ruleHeader() throws RecognitionException { EObject current = null; @@ -14660,14 +12985,14 @@ public final EObject ruleHeader() throws RecognitionException { enterRule(); try { - // InternalRos.g:5734:2: ( ( () otherlv_1= 'Header' ) ) - // InternalRos.g:5735:2: ( () otherlv_1= 'Header' ) + // InternalRosParser.g:4971:2: ( ( () otherlv_1= Header ) ) + // InternalRosParser.g:4972:2: ( () otherlv_1= Header ) { - // InternalRos.g:5735:2: ( () otherlv_1= 'Header' ) - // InternalRos.g:5736:3: () otherlv_1= 'Header' + // InternalRosParser.g:4972:2: ( () otherlv_1= Header ) + // InternalRosParser.g:4973:3: () otherlv_1= Header { - // InternalRos.g:5736:3: () - // InternalRos.g:5737:4: + // InternalRosParser.g:4973:3: () + // InternalRosParser.g:4974:4: { current = forceCreateModelElement( @@ -14677,7 +13002,7 @@ public final EObject ruleHeader() throws RecognitionException { } - otherlv_1=(Token)match(input,41,FOLLOW_2); + otherlv_1=(Token)match(input,Header,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getHeaderAccess().getHeaderKeyword_1()); @@ -14704,7 +13029,7 @@ public final EObject ruleHeader() throws RecognitionException { // $ANTLR start "entryRuleTopicSpecRef" - // InternalRos.g:5751:1: entryRuleTopicSpecRef returns [EObject current=null] : iv_ruleTopicSpecRef= ruleTopicSpecRef EOF ; + // InternalRosParser.g:4988:1: entryRuleTopicSpecRef returns [EObject current=null] : iv_ruleTopicSpecRef= ruleTopicSpecRef EOF ; public final EObject entryRuleTopicSpecRef() throws RecognitionException { EObject current = null; @@ -14712,8 +13037,8 @@ public final EObject entryRuleTopicSpecRef() throws RecognitionException { try { - // InternalRos.g:5751:53: (iv_ruleTopicSpecRef= ruleTopicSpecRef EOF ) - // InternalRos.g:5752:2: iv_ruleTopicSpecRef= ruleTopicSpecRef EOF + // InternalRosParser.g:4988:53: (iv_ruleTopicSpecRef= ruleTopicSpecRef EOF ) + // InternalRosParser.g:4989:2: iv_ruleTopicSpecRef= ruleTopicSpecRef EOF { newCompositeNode(grammarAccess.getTopicSpecRefRule()); pushFollow(FOLLOW_1); @@ -14740,7 +13065,7 @@ public final EObject entryRuleTopicSpecRef() throws RecognitionException { // $ANTLR start "ruleTopicSpecRef" - // InternalRos.g:5758:1: ruleTopicSpecRef returns [EObject current=null] : ( ( ruleEString ) ) ; + // InternalRosParser.g:4995:1: ruleTopicSpecRef returns [EObject current=null] : ( ( ruleEString ) ) ; public final EObject ruleTopicSpecRef() throws RecognitionException { EObject current = null; @@ -14748,14 +13073,14 @@ public final EObject ruleTopicSpecRef() throws RecognitionException { enterRule(); try { - // InternalRos.g:5764:2: ( ( ( ruleEString ) ) ) - // InternalRos.g:5765:2: ( ( ruleEString ) ) + // InternalRosParser.g:5001:2: ( ( ( ruleEString ) ) ) + // InternalRosParser.g:5002:2: ( ( ruleEString ) ) { - // InternalRos.g:5765:2: ( ( ruleEString ) ) - // InternalRos.g:5766:3: ( ruleEString ) + // InternalRosParser.g:5002:2: ( ( ruleEString ) ) + // InternalRosParser.g:5003:3: ( ruleEString ) { - // InternalRos.g:5766:3: ( ruleEString ) - // InternalRos.g:5767:4: ruleEString + // InternalRosParser.g:5003:3: ( ruleEString ) + // InternalRosParser.g:5004:4: ruleEString { if (current==null) { @@ -14799,7 +13124,7 @@ public final EObject ruleTopicSpecRef() throws RecognitionException { // $ANTLR start "entryRuleArrayTopicSpecRef" - // InternalRos.g:5784:1: entryRuleArrayTopicSpecRef returns [EObject current=null] : iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF ; + // InternalRosParser.g:5021:1: entryRuleArrayTopicSpecRef returns [EObject current=null] : iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF ; public final EObject entryRuleArrayTopicSpecRef() throws RecognitionException { EObject current = null; @@ -14807,8 +13132,8 @@ public final EObject entryRuleArrayTopicSpecRef() throws RecognitionException { try { - // InternalRos.g:5784:58: (iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF ) - // InternalRos.g:5785:2: iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF + // InternalRosParser.g:5021:58: (iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF ) + // InternalRosParser.g:5022:2: iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF { newCompositeNode(grammarAccess.getArrayTopicSpecRefRule()); pushFollow(FOLLOW_1); @@ -14835,7 +13160,7 @@ public final EObject entryRuleArrayTopicSpecRef() throws RecognitionException { // $ANTLR start "ruleArrayTopicSpecRef" - // InternalRos.g:5791:1: ruleArrayTopicSpecRef returns [EObject current=null] : ( ( ( ruleEString ) ) otherlv_1= '[]' ) ; + // InternalRosParser.g:5028:1: ruleArrayTopicSpecRef returns [EObject current=null] : ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) ; public final EObject ruleArrayTopicSpecRef() throws RecognitionException { EObject current = null; @@ -14845,17 +13170,17 @@ public final EObject ruleArrayTopicSpecRef() throws RecognitionException { enterRule(); try { - // InternalRos.g:5797:2: ( ( ( ( ruleEString ) ) otherlv_1= '[]' ) ) - // InternalRos.g:5798:2: ( ( ( ruleEString ) ) otherlv_1= '[]' ) + // InternalRosParser.g:5034:2: ( ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) ) + // InternalRosParser.g:5035:2: ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) { - // InternalRos.g:5798:2: ( ( ( ruleEString ) ) otherlv_1= '[]' ) - // InternalRos.g:5799:3: ( ( ruleEString ) ) otherlv_1= '[]' + // InternalRosParser.g:5035:2: ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) + // InternalRosParser.g:5036:3: ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket { - // InternalRos.g:5799:3: ( ( ruleEString ) ) - // InternalRos.g:5800:4: ( ruleEString ) + // InternalRosParser.g:5036:3: ( ( ruleEString ) ) + // InternalRosParser.g:5037:4: ( ruleEString ) { - // InternalRos.g:5800:4: ( ruleEString ) - // InternalRos.g:5801:5: ruleEString + // InternalRosParser.g:5037:4: ( ruleEString ) + // InternalRosParser.g:5038:5: ruleEString { if (current==null) { @@ -14865,7 +13190,7 @@ public final EObject ruleArrayTopicSpecRef() throws RecognitionException { newCompositeNode(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); - pushFollow(FOLLOW_63); + pushFollow(FOLLOW_51); ruleEString(); state._fsp--; @@ -14879,7 +13204,7 @@ public final EObject ruleArrayTopicSpecRef() throws RecognitionException { } - otherlv_1=(Token)match(input,113,FOLLOW_2); + otherlv_1=(Token)match(input,LeftSquareBracketRightSquareBracket,FOLLOW_2); newLeafNode(otherlv_1, grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); @@ -14906,7 +13231,7 @@ public final EObject ruleArrayTopicSpecRef() throws RecognitionException { // $ANTLR start "entryRuleKEYWORD" - // InternalRos.g:5823:1: entryRuleKEYWORD returns [String current=null] : iv_ruleKEYWORD= ruleKEYWORD EOF ; + // InternalRosParser.g:5060:1: entryRuleKEYWORD returns [String current=null] : iv_ruleKEYWORD= ruleKEYWORD EOF ; public final String entryRuleKEYWORD() throws RecognitionException { String current = null; @@ -14914,8 +13239,8 @@ public final String entryRuleKEYWORD() throws RecognitionException { try { - // InternalRos.g:5823:47: (iv_ruleKEYWORD= ruleKEYWORD EOF ) - // InternalRos.g:5824:2: iv_ruleKEYWORD= ruleKEYWORD EOF + // InternalRosParser.g:5060:47: (iv_ruleKEYWORD= ruleKEYWORD EOF ) + // InternalRosParser.g:5061:2: iv_ruleKEYWORD= ruleKEYWORD EOF { newCompositeNode(grammarAccess.getKEYWORDRule()); pushFollow(FOLLOW_1); @@ -14942,7 +13267,7 @@ public final String entryRuleKEYWORD() throws RecognitionException { // $ANTLR start "ruleKEYWORD" - // InternalRos.g:5830:1: ruleKEYWORD returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= 'goal' | kw= 'message' | kw= 'result' | kw= 'feedback' | kw= 'name' | kw= 'value' | kw= 'service' | kw= 'type' | kw= 'action' | kw= 'duration' | kw= 'time' ) ; + // InternalRosParser.g:5067:1: ruleKEYWORD returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) ; public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -14952,79 +13277,79 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { enterRule(); try { - // InternalRos.g:5836:2: ( (kw= 'goal' | kw= 'message' | kw= 'result' | kw= 'feedback' | kw= 'name' | kw= 'value' | kw= 'service' | kw= 'type' | kw= 'action' | kw= 'duration' | kw= 'time' ) ) - // InternalRos.g:5837:2: (kw= 'goal' | kw= 'message' | kw= 'result' | kw= 'feedback' | kw= 'name' | kw= 'value' | kw= 'service' | kw= 'type' | kw= 'action' | kw= 'duration' | kw= 'time' ) + // InternalRosParser.g:5073:2: ( (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) ) + // InternalRosParser.g:5074:2: (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) { - // InternalRos.g:5837:2: (kw= 'goal' | kw= 'message' | kw= 'result' | kw= 'feedback' | kw= 'name' | kw= 'value' | kw= 'service' | kw= 'type' | kw= 'action' | kw= 'duration' | kw= 'time' ) - int alt81=11; + // InternalRosParser.g:5074:2: (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) + int alt58=11; switch ( input.LA(1) ) { - case 45: + case Goal: { - alt81=1; + alt58=1; } break; - case 43: + case Message: { - alt81=2; + alt58=2; } break; - case 46: + case Result: { - alt81=3; + alt58=3; } break; - case 47: + case Feedback: { - alt81=4; + alt58=4; } break; - case 49: + case Name: { - alt81=5; + alt58=5; } break; - case 83: + case Value: { - alt81=6; + alt58=6; } break; - case 58: + case Service: { - alt81=7; + alt58=7; } break; - case 73: + case Type: { - alt81=8; + alt58=8; } break; - case 64: + case Action: { - alt81=9; + alt58=9; } break; - case 99: + case Duration: { - alt81=10; + alt58=10; } break; - case 98: + case Time: { - alt81=11; + alt58=11; } break; default: NoViableAltException nvae = - new NoViableAltException("", 81, 0, input); + new NoViableAltException("", 58, 0, input); throw nvae; } - switch (alt81) { + switch (alt58) { case 1 : - // InternalRos.g:5838:3: kw= 'goal' + // InternalRosParser.g:5075:3: kw= Goal { - kw=(Token)match(input,45,FOLLOW_2); + kw=(Token)match(input,Goal,FOLLOW_2); current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); @@ -15033,9 +13358,9 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { } break; case 2 : - // InternalRos.g:5844:3: kw= 'message' + // InternalRosParser.g:5081:3: kw= Message { - kw=(Token)match(input,43,FOLLOW_2); + kw=(Token)match(input,Message,FOLLOW_2); current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); @@ -15044,9 +13369,9 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { } break; case 3 : - // InternalRos.g:5850:3: kw= 'result' + // InternalRosParser.g:5087:3: kw= Result { - kw=(Token)match(input,46,FOLLOW_2); + kw=(Token)match(input,Result,FOLLOW_2); current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getResultKeyword_2()); @@ -15055,9 +13380,9 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { } break; case 4 : - // InternalRos.g:5856:3: kw= 'feedback' + // InternalRosParser.g:5093:3: kw= Feedback { - kw=(Token)match(input,47,FOLLOW_2); + kw=(Token)match(input,Feedback,FOLLOW_2); current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); @@ -15066,9 +13391,9 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { } break; case 5 : - // InternalRos.g:5862:3: kw= 'name' + // InternalRosParser.g:5099:3: kw= Name { - kw=(Token)match(input,49,FOLLOW_2); + kw=(Token)match(input,Name,FOLLOW_2); current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getNameKeyword_4()); @@ -15077,9 +13402,9 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { } break; case 6 : - // InternalRos.g:5868:3: kw= 'value' + // InternalRosParser.g:5105:3: kw= Value { - kw=(Token)match(input,83,FOLLOW_2); + kw=(Token)match(input,Value,FOLLOW_2); current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getValueKeyword_5()); @@ -15088,9 +13413,9 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { } break; case 7 : - // InternalRos.g:5874:3: kw= 'service' + // InternalRosParser.g:5111:3: kw= Service { - kw=(Token)match(input,58,FOLLOW_2); + kw=(Token)match(input,Service,FOLLOW_2); current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); @@ -15099,9 +13424,9 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { } break; case 8 : - // InternalRos.g:5880:3: kw= 'type' + // InternalRosParser.g:5117:3: kw= Type { - kw=(Token)match(input,73,FOLLOW_2); + kw=(Token)match(input,Type,FOLLOW_2); current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); @@ -15110,9 +13435,9 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { } break; case 9 : - // InternalRos.g:5886:3: kw= 'action' + // InternalRosParser.g:5123:3: kw= Action { - kw=(Token)match(input,64,FOLLOW_2); + kw=(Token)match(input,Action,FOLLOW_2); current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getActionKeyword_8()); @@ -15121,9 +13446,9 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { } break; case 10 : - // InternalRos.g:5892:3: kw= 'duration' + // InternalRosParser.g:5129:3: kw= Duration { - kw=(Token)match(input,99,FOLLOW_2); + kw=(Token)match(input,Duration,FOLLOW_2); current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); @@ -15132,9 +13457,9 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { } break; case 11 : - // InternalRos.g:5898:3: kw= 'time' + // InternalRosParser.g:5135:3: kw= Time { - kw=(Token)match(input,98,FOLLOW_2); + kw=(Token)match(input,Time,FOLLOW_2); current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); @@ -15166,15 +13491,15 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { // Delegated rules - protected DFA80 dfa80 = new DFA80(this); + protected DFA57 dfa57 = new DFA57(this); static final String dfa_1s = "\42\uffff"; static final String dfa_2s = "\36\uffff\2\41\2\uffff"; - static final String dfa_3s = "\1\4\35\uffff\2\4\2\uffff"; - static final String dfa_4s = "\1\160\35\uffff\2\161\2\uffff"; + static final String dfa_3s = "\1\27\35\uffff\2\32\2\uffff"; + static final String dfa_4s = "\1\140\35\uffff\2\156\2\uffff"; static final String dfa_5s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\2\uffff\1\37\1\36"; static final String dfa_6s = "\42\uffff}>"; static final String[] dfa_7s = { - "\1\36\1\37\43\uffff\1\20\53\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35", + "\1\32\1\33\1\uffff\1\17\3\uffff\1\34\1\25\1\27\1\31\4\uffff\1\12\1\13\1\24\1\26\1\30\3\uffff\1\23\3\uffff\1\20\3\uffff\1\21\1\35\1\22\2\uffff\1\14\1\5\1\7\1\11\1\uffff\1\4\1\6\1\10\2\uffff\1\3\3\uffff\1\1\1\15\1\uffff\1\2\4\uffff\1\16\14\uffff\1\37\1\uffff\1\36", "", "", "", @@ -15204,8 +13529,8 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { "", "", "", - "\2\41\6\uffff\1\41\36\uffff\1\41\1\uffff\3\41\1\uffff\1\41\10\uffff\1\41\5\uffff\1\41\10\uffff\1\41\11\uffff\1\41\16\uffff\2\41\15\uffff\1\40", - "\2\41\6\uffff\1\41\36\uffff\1\41\1\uffff\3\41\1\uffff\1\41\10\uffff\1\41\5\uffff\1\41\10\uffff\1\41\11\uffff\1\41\16\uffff\2\41\15\uffff\1\40", + "\2\41\17\uffff\1\41\1\uffff\1\41\7\uffff\1\41\3\uffff\1\41\14\uffff\1\41\4\uffff\1\41\2\uffff\1\41\2\uffff\2\41\2\uffff\1\40\10\uffff\1\41\1\uffff\1\41\15\uffff\1\41", + "\2\41\17\uffff\1\41\1\uffff\1\41\7\uffff\1\41\3\uffff\1\41\14\uffff\1\41\4\uffff\1\41\2\uffff\1\41\2\uffff\2\41\2\uffff\1\40\10\uffff\1\41\1\uffff\1\41\15\uffff\1\41", "", "" }; @@ -15218,11 +13543,11 @@ public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s); static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s); - class DFA80 extends DFA { + class DFA57 extends DFA { - public DFA80(BaseRecognizer recognizer) { + public DFA57(BaseRecognizer recognizer) { this.recognizer = recognizer; - this.decisionNumber = 80; + this.decisionNumber = 57; this.eot = dfa_1; this.eof = dfa_2; this.min = dfa_3; @@ -15232,73 +13557,61 @@ public DFA80(BaseRecognizer recognizer) { this.transition = dfa_7; } public String getDescription() { - return "4598:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef )"; + return "3835:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef )"; } } 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[]{0x0000000004000000L}); - public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000001430000000L}); - public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000018000000L}); - public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000001420000000L}); - public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000030L}); - public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x00000002D0000000L}); - public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000290000000L}); - public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000112000000000L}); - public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000210000000L}); - public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000200000000L}); - public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000100000060L}); - public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0001000010000000L}); - public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000010000000L}); - public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000AD0000000L}); - public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000A90000000L}); - public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000000030L,0x0000000000000008L}); - public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x000000C010000000L}); - public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000008010000000L}); - public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000060000000030L}); - public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000080010000000L}); - public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000E00010000000L}); - public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000C00010000000L}); - public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000800010000000L}); - public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000020010000030L,0x0001FFFFFFE00000L}); - public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0002000000000000L}); - public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x01FC000010000000L}); - public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0200000000000000L}); - public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x01F8000010000000L}); - public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x1000000000000000L}); - public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x01F0000010000000L}); - public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x2000000000000000L}); - public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x01E0000010000000L}); - public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x4000000000000000L}); - public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x01C0000010000000L}); - public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x8000000000000000L}); - public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0180000010000000L}); - public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); - public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0100000010000000L}); - public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); - public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0400000000000000L}); - public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0800000010000000L}); - public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x00000000000000D0L}); - public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000080000000000L}); - public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); - public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000020L}); - public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); - public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0800000000000000L,0x0000000000000200L}); - public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); - public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000040000000000L,0x000000000003DC00L}); - public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000002L,0x0000000000002000L}); - public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000400L}); - public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000200L}); - public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000100L}); - public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000000080L}); - public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000010000000L,0x0000000000002000L}); - public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x00000000040007B0L}); - public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000010000000L,0x0000000000080000L}); - public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); - public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); - public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0402E80000001030L,0x0000000C00080201L}); - public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000000L,0x0002000000000000L}); + public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000002L,0x00000000C0008000L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0400000000012000L,0x0000000010000000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000000L,0x0000000140000000L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0400000000002000L,0x0000000010000000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000001000000000L,0x0000000010012000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000002000L,0x0000000010000000L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000020L,0x0000000140000000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000000L,0x0000000002400000L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000008L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000000000L,0x00000000C8008000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x00000000000E1E00L,0x0000000010000000L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000000000L,0x0000000150000000L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x000C000000000000L,0x0000000140000000L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000010000000L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000000000L,0x0000000018000000L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x79C447C3C5800000L,0x0000000150021627L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000020000000L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000002000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000002000000L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x8000000000000000L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000100000000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000100000000000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000400000L,0x0000000008000000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000000400000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x79C447C3C5800002L,0x0000000140021627L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x00000000000001C0L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000002L,0x0000000001000000L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000200000L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x001B800C00000000L,0x0000000000000100L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000002000000002L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000000L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000000L,0x0000004000000000L}); + public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000002000000000L,0x0000000010000000L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000000000L,0x0000007941000000L}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x022028000C000000L,0x0000400140064840L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); } \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosParser.tokens b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosParser.tokens new file mode 100644 index 000000000..7a07c1570 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRosParser.tokens @@ -0,0 +1,110 @@ +','=86 +':'=87 +'AmentPackage'=14 +'Any'=83 +'Array:'=47 +'Base64'=48 +'Boolean'=34 +'Date'=71 +'Double'=49 +'ExternalDependency'=5 +'GlobalNamespace'=8 +'GraphName'=21 +'Header'=50 +'Integer'=35 +'List'=72 +'ParameterAny'=15 +'ParameterStructMember'=4 +'PrivateNamespace'=7 +'RelativeNamespace'=6 +'String'=51 +'Struct'=52 +'['=88 +'[]'=85 +']'=89 +'action'=53 +'action:'=36 +'actionclient:'=11 +'actionserver:'=12 +'artifacts:'=20 +'bool'=73 +'bool[]'=54 +'byte'=74 +'byte[]'=55 +'default'=37 +'dependencies:'=13 +'duration'=26 +'feedback'=27 +'feedback:'=22 +'float32'=38 +'float32[]'=23 +'float64'=39 +'float64[]'=24 +'fromGitRepo:'=16 +'goal'=75 +'goal:'=63 +'int16'=64 +'int16[]'=40 +'int32'=65 +'int32[]'=41 +'int64'=66 +'int64[]'=42 +'int8'=76 +'int8[]'=56 +'message'=43 +'message:'=28 +'msg:'=77 +'name'=78 +'node'=79 +'node:'=67 +'ns:'=84 +'parameters:'=18 +'publishers:'=19 +'request:'=29 +'response:'=25 +'result'=57 +'result:'=44 +'service'=45 +'serviceclient:'=9 +'serviceserver:'=10 +'specs:'=58 +'srv:'=80 +'string'=59 +'string[]'=30 +'subscribers:'=17 +'time'=81 +'type'=82 +'type:'=68 +'uint16'=60 +'uint16[]'=31 +'uint32'=61 +'uint32[]'=32 +'uint64'=62 +'uint64[]'=33 +'uint8'=69 +'uint8[]'=46 +'value'=70 +'}'=90 +RULE_ANY_OTHER=113 +RULE_BEGIN=91 +RULE_BINARY=99 +RULE_BOOLEAN=100 +RULE_DATE_TIME=108 +RULE_DAY=103 +RULE_DECINT=101 +RULE_DIGIT=98 +RULE_DOUBLE=102 +RULE_END=92 +RULE_HOUR=106 +RULE_ID=94 +RULE_INT=109 +RULE_MESSAGE_ASIGMENT=110 +RULE_MIN_SEC=107 +RULE_ML_COMMENT=111 +RULE_MONTH=104 +RULE_ROS_CONVENTION_A=95 +RULE_ROS_CONVENTION_PARAM=97 +RULE_SL_COMMENT=93 +RULE_STRING=96 +RULE_WS=112 +RULE_YEAR=105 diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/lexer/InternalRosLexer.g b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/lexer/InternalRosLexer.g new file mode 100644 index 000000000..811b5b5c0 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/lexer/InternalRosLexer.g @@ -0,0 +1,232 @@ +/* + * generated by Xtext 2.25.0 + */ +lexer grammar InternalRosLexer; + +@header { +package de.fraunhofer.ipa.ros.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; +} + +ParameterStructMember : 'ParameterStructMember'; + +ExternalDependency : 'ExternalDependency'; + +RelativeNamespace : 'RelativeNamespace'; + +PrivateNamespace : 'PrivateNamespace'; + +GlobalNamespace : 'GlobalNamespace'; + +Serviceclient : 'serviceclient:'; + +Serviceserver : 'serviceserver:'; + +Actionclient : 'actionclient:'; + +Actionserver : 'actionserver:'; + +Dependencies : 'dependencies:'; + +AmentPackage : 'AmentPackage'; + +ParameterAny : 'ParameterAny'; + +FromGitRepo : 'fromGitRepo:'; + +Subscribers : 'subscribers:'; + +Parameters : 'parameters:'; + +Publishers : 'publishers:'; + +Artifacts : 'artifacts:'; + +GraphName : 'GraphName'; + +Feedback_1 : 'feedback:'; + +Float32_1 : 'float32[]'; + +Float64_1 : 'float64[]'; + +Response : 'response:'; + +Duration : 'duration'; + +Feedback : 'feedback'; + +Message_1 : 'message:'; + +Request : 'request:'; + +String_2 : 'string[]'; + +Uint16_1 : 'uint16[]'; + +Uint32_1 : 'uint32[]'; + +Uint64_1 : 'uint64[]'; + +Boolean : 'Boolean'; + +Integer : 'Integer'; + +Action_1 : 'action:'; + +Default : 'default'; + +Float32 : 'float32'; + +Float64 : 'float64'; + +Int16_1 : 'int16[]'; + +Int32_1 : 'int32[]'; + +Int64_1 : 'int64[]'; + +Message : 'message'; + +Result_1 : 'result:'; + +Service : 'service'; + +Uint8_1 : 'uint8[]'; + +Array : 'Array:'; + +Base64 : 'Base64'; + +Double : 'Double'; + +Header : 'Header'; + +String : 'String'; + +Struct : 'Struct'; + +Action : 'action'; + +Bool_1 : 'bool[]'; + +Byte_1 : 'byte[]'; + +Int8_1 : 'int8[]'; + +Result : 'result'; + +Specs : 'specs:'; + +String_1 : 'string'; + +Uint16 : 'uint16'; + +Uint32 : 'uint32'; + +Uint64 : 'uint64'; + +Goal_1 : 'goal:'; + +Int16 : 'int16'; + +Int32 : 'int32'; + +Int64 : 'int64'; + +Node_1 : 'node:'; + +Type_1 : 'type:'; + +Uint8 : 'uint8'; + +Value : 'value'; + +Date : 'Date'; + +List : 'List'; + +Bool : 'bool'; + +Byte : 'byte'; + +Goal : 'goal'; + +Int8 : 'int8'; + +Msg : 'msg:'; + +Name : 'name'; + +Node : 'node'; + +Srv : 'srv:'; + +Time : 'time'; + +Type : 'type'; + +Any : 'Any'; + +Ns : 'ns:'; + +LeftSquareBracketRightSquareBracket : '[]'; + +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)*; + +fragment RULE_DIGIT : '0'..'9'; + +RULE_BINARY : ('0b'|'0B') ('0'|'1')+; + +RULE_BOOLEAN : ('true'|'false'); + +RULE_DOUBLE : RULE_DIGIT ('.' RULE_DECINT*|('.' RULE_DIGIT*)? ('E'|'e') ('-'|'+')? RULE_DIGIT); + +RULE_DECINT : ('0'|'1'..'9' RULE_DIGIT*|'-' '0'..'9' RULE_DIGIT*); + +fragment RULE_DAY : ('1'..'9'|'1'..'3' '0'..'9'); + +fragment RULE_MONTH : ('1'..'9'|'1' '0'..'2'); + +fragment RULE_YEAR : '0'..'2' '0'..'9' '0'..'9' '0'..'9'; + +fragment RULE_HOUR : ('0'..'1' '0'..'9'|'2' '0'..'3'); + +fragment RULE_MIN_SEC : '0'..'5' '0'..'9'; + +RULE_DATE_TIME : RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC; + +RULE_MESSAGE_ASIGMENT : (RULE_ID|RULE_STRING) '=' (RULE_ID|RULE_STRING|RULE_INT|'-' RULE_INT); + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + +fragment 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.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/lexer/InternalRosLexer.java b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/lexer/InternalRosLexer.java new file mode 100644 index 000000000..c934eabd1 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/lexer/InternalRosLexer.java @@ -0,0 +1,4967 @@ +package de.fraunhofer.ipa.ros.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 InternalRosLexer extends Lexer { + public static final int Float32_1=23; + public static final int Node=79; + public static final int RULE_DATE_TIME=108; + public static final int Uint64_1=33; + public static final int String=51; + public static final int Int16=64; + public static final int Float32=38; + public static final int Goal=75; + public static final int Bool=73; + public static final int Uint16=60; + public static final int Boolean=34; + public static final int ExternalDependency=5; + public static final int Uint8=69; + public static final int Parameters=18; + public static final int RULE_ID=94; + public static final int AmentPackage=14; + public static final int Actionclient=11; + public static final int RULE_DIGIT=98; + public static final int GlobalNamespace=8; + public static final int Artifacts=20; + public static final int Node_1=67; + public static final int Int16_1=40; + public static final int Header=50; + public static final int RULE_INT=109; + public static final int Byte=74; + public static final int RULE_ML_COMMENT=111; + public static final int LeftSquareBracket=88; + public static final int Specs=58; + public static final int Base64=48; + public static final int Message_1=28; + public static final int Comma=86; + public static final int RULE_MESSAGE_ASIGMENT=110; + public static final int Goal_1=63; + public static final int LeftSquareBracketRightSquareBracket=85; + public static final int Int32=65; + public static final int Publishers=19; + public static final int Serviceserver=10; + public static final int RightCurlyBracket=90; + public static final int RULE_DECINT=101; + public static final int Uint32=61; + public static final int FromGitRepo=16; + public static final int Msg=77; + public static final int RULE_HOUR=106; + public static final int Int8=76; + public static final int Default=37; + public static final int Actionserver=12; + public static final int Int8_1=56; + public static final int Uint16_1=31; + public static final int Type=82; + public static final int Float64=39; + public static final int Int32_1=41; + public static final int Result_1=44; + public static final int RULE_BINARY=99; + public static final int String_1=59; + public static final int Subscribers=17; + public static final int String_2=30; + public static final int RULE_BEGIN=91; + public static final int RULE_DAY=103; + public static final int RULE_BOOLEAN=100; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=105; + public static final int Feedback_1=22; + public static final int Result=57; + public static final int Name=78; + public static final int RULE_MIN_SEC=107; + public static final int ParameterAny=15; + public static final int List=72; + public static final int Dependencies=13; + public static final int RightSquareBracket=89; + public static final int PrivateNamespace=7; + public static final int GraphName=21; + public static final int Byte_1=55; + public static final int Float64_1=24; + public static final int Duration=26; + public static final int Uint32_1=32; + public static final int Action_1=36; + public static final int Double=49; + public static final int Type_1=68; + public static final int Value=70; + public static final int Uint64=62; + public static final int Action=53; + public static final int RULE_END=92; + public static final int Message=43; + public static final int Time=81; + public static final int RULE_STRING=96; + public static final int Bool_1=54; + public static final int Any=83; + public static final int Struct=52; + public static final int RULE_SL_COMMENT=93; + public static final int Uint8_1=46; + public static final int RULE_DOUBLE=102; + public static final int Feedback=27; + public static final int ParameterStructMember=4; + public static final int Srv=80; + public static final int RULE_ROS_CONVENTION_A=95; + public static final int RULE_ROS_CONVENTION_PARAM=97; + public static final int Colon=87; + public static final int EOF=-1; + public static final int Ns=84; + public static final int RULE_WS=112; + public static final int Request=29; + public static final int Int64_1=42; + public static final int Service=45; + public static final int RULE_ANY_OTHER=113; + public static final int Date=71; + public static final int Response=25; + public static final int Integer=35; + public static final int Array=47; + public static final int Serviceclient=9; + public static final int Int64=66; + public static final int RULE_MONTH=104; + + // delegates + // delegators + + public InternalRosLexer() {;} + public InternalRosLexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public InternalRosLexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "InternalRosLexer.g"; } + + // $ANTLR start "ParameterStructMember" + public final void mParameterStructMember() throws RecognitionException { + try { + int _type = ParameterStructMember; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:14:23: ( 'ParameterStructMember' ) + // InternalRosLexer.g:14:25: 'ParameterStructMember' + { + match("ParameterStructMember"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterStructMember" + + // $ANTLR start "ExternalDependency" + public final void mExternalDependency() throws RecognitionException { + try { + int _type = ExternalDependency; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:16:20: ( 'ExternalDependency' ) + // InternalRosLexer.g:16:22: 'ExternalDependency' + { + match("ExternalDependency"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ExternalDependency" + + // $ANTLR start "RelativeNamespace" + public final void mRelativeNamespace() throws RecognitionException { + try { + int _type = RelativeNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:18:19: ( 'RelativeNamespace' ) + // InternalRosLexer.g:18:21: 'RelativeNamespace' + { + match("RelativeNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RelativeNamespace" + + // $ANTLR start "PrivateNamespace" + public final void mPrivateNamespace() throws RecognitionException { + try { + int _type = PrivateNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:20:18: ( 'PrivateNamespace' ) + // InternalRosLexer.g:20:20: 'PrivateNamespace' + { + match("PrivateNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PrivateNamespace" + + // $ANTLR start "GlobalNamespace" + public final void mGlobalNamespace() throws RecognitionException { + try { + int _type = GlobalNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:22:17: ( 'GlobalNamespace' ) + // InternalRosLexer.g:22:19: 'GlobalNamespace' + { + match("GlobalNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GlobalNamespace" + + // $ANTLR start "Serviceclient" + public final void mServiceclient() throws RecognitionException { + try { + int _type = Serviceclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:24:15: ( 'serviceclient:' ) + // InternalRosLexer.g:24:17: 'serviceclient:' + { + match("serviceclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceclient" + + // $ANTLR start "Serviceserver" + public final void mServiceserver() throws RecognitionException { + try { + int _type = Serviceserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:26:15: ( 'serviceserver:' ) + // InternalRosLexer.g:26:17: 'serviceserver:' + { + match("serviceserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceserver" + + // $ANTLR start "Actionclient" + public final void mActionclient() throws RecognitionException { + try { + int _type = Actionclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:28:14: ( 'actionclient:' ) + // InternalRosLexer.g:28:16: 'actionclient:' + { + match("actionclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionclient" + + // $ANTLR start "Actionserver" + public final void mActionserver() throws RecognitionException { + try { + int _type = Actionserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:30:14: ( 'actionserver:' ) + // InternalRosLexer.g:30:16: 'actionserver:' + { + match("actionserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionserver" + + // $ANTLR start "Dependencies" + public final void mDependencies() throws RecognitionException { + try { + int _type = Dependencies; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:32:14: ( 'dependencies:' ) + // InternalRosLexer.g:32:16: 'dependencies:' + { + match("dependencies:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Dependencies" + + // $ANTLR start "AmentPackage" + public final void mAmentPackage() throws RecognitionException { + try { + int _type = AmentPackage; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:34:14: ( 'AmentPackage' ) + // InternalRosLexer.g:34:16: 'AmentPackage' + { + match("AmentPackage"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AmentPackage" + + // $ANTLR start "ParameterAny" + public final void mParameterAny() throws RecognitionException { + try { + int _type = ParameterAny; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:36:14: ( 'ParameterAny' ) + // InternalRosLexer.g:36:16: 'ParameterAny' + { + match("ParameterAny"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterAny" + + // $ANTLR start "FromGitRepo" + public final void mFromGitRepo() throws RecognitionException { + try { + int _type = FromGitRepo; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:38:13: ( 'fromGitRepo:' ) + // InternalRosLexer.g:38: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; + // InternalRosLexer.g:40:13: ( 'subscribers:' ) + // InternalRosLexer.g:40: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; + // InternalRosLexer.g:42:12: ( 'parameters:' ) + // InternalRosLexer.g:42: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; + // InternalRosLexer.g:44:12: ( 'publishers:' ) + // InternalRosLexer.g:44: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; + // InternalRosLexer.g:46:11: ( 'artifacts:' ) + // InternalRosLexer.g:46:13: 'artifacts:' + { + match("artifacts:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Artifacts" + + // $ANTLR start "GraphName" + public final void mGraphName() throws RecognitionException { + try { + int _type = GraphName; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:48:11: ( 'GraphName' ) + // InternalRosLexer.g:48:13: 'GraphName' + { + match("GraphName"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GraphName" + + // $ANTLR start "Feedback_1" + public final void mFeedback_1() throws RecognitionException { + try { + int _type = Feedback_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:50:12: ( 'feedback:' ) + // InternalRosLexer.g:50:14: 'feedback:' + { + match("feedback:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback_1" + + // $ANTLR start "Float32_1" + public final void mFloat32_1() throws RecognitionException { + try { + int _type = Float32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:52:11: ( 'float32[]' ) + // InternalRosLexer.g:52:13: 'float32[]' + { + match("float32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32_1" + + // $ANTLR start "Float64_1" + public final void mFloat64_1() throws RecognitionException { + try { + int _type = Float64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:54:11: ( 'float64[]' ) + // InternalRosLexer.g:54:13: 'float64[]' + { + match("float64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64_1" + + // $ANTLR start "Response" + public final void mResponse() throws RecognitionException { + try { + int _type = Response; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:56:10: ( 'response:' ) + // InternalRosLexer.g:56:12: 'response:' + { + match("response:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Response" + + // $ANTLR start "Duration" + public final void mDuration() throws RecognitionException { + try { + int _type = Duration; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:58:10: ( 'duration' ) + // InternalRosLexer.g:58:12: 'duration' + { + match("duration"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Duration" + + // $ANTLR start "Feedback" + public final void mFeedback() throws RecognitionException { + try { + int _type = Feedback; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:60:10: ( 'feedback' ) + // InternalRosLexer.g:60:12: 'feedback' + { + match("feedback"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback" + + // $ANTLR start "Message_1" + public final void mMessage_1() throws RecognitionException { + try { + int _type = Message_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:62:11: ( 'message:' ) + // InternalRosLexer.g:62:13: 'message:' + { + match("message:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message_1" + + // $ANTLR start "Request" + public final void mRequest() throws RecognitionException { + try { + int _type = Request; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:64:9: ( 'request:' ) + // InternalRosLexer.g:64:11: 'request:' + { + match("request:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Request" + + // $ANTLR start "String_2" + public final void mString_2() throws RecognitionException { + try { + int _type = String_2; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:66:10: ( 'string[]' ) + // InternalRosLexer.g:66:12: 'string[]' + { + match("string[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_2" + + // $ANTLR start "Uint16_1" + public final void mUint16_1() throws RecognitionException { + try { + int _type = Uint16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:68:10: ( 'uint16[]' ) + // InternalRosLexer.g:68:12: 'uint16[]' + { + match("uint16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16_1" + + // $ANTLR start "Uint32_1" + public final void mUint32_1() throws RecognitionException { + try { + int _type = Uint32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:70:10: ( 'uint32[]' ) + // InternalRosLexer.g:70:12: 'uint32[]' + { + match("uint32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32_1" + + // $ANTLR start "Uint64_1" + public final void mUint64_1() throws RecognitionException { + try { + int _type = Uint64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:72:10: ( 'uint64[]' ) + // InternalRosLexer.g:72:12: 'uint64[]' + { + match("uint64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64_1" + + // $ANTLR start "Boolean" + public final void mBoolean() throws RecognitionException { + try { + int _type = Boolean; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:74:9: ( 'Boolean' ) + // InternalRosLexer.g:74:11: 'Boolean' + { + match("Boolean"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Boolean" + + // $ANTLR start "Integer" + public final void mInteger() throws RecognitionException { + try { + int _type = Integer; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:76:9: ( 'Integer' ) + // InternalRosLexer.g:76:11: 'Integer' + { + match("Integer"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Integer" + + // $ANTLR start "Action_1" + public final void mAction_1() throws RecognitionException { + try { + int _type = Action_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:78:10: ( 'action:' ) + // InternalRosLexer.g:78:12: 'action:' + { + match("action:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action_1" + + // $ANTLR start "Default" + public final void mDefault() throws RecognitionException { + try { + int _type = Default; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:80:9: ( 'default' ) + // InternalRosLexer.g:80:11: 'default' + { + match("default"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Default" + + // $ANTLR start "Float32" + public final void mFloat32() throws RecognitionException { + try { + int _type = Float32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:82:9: ( 'float32' ) + // InternalRosLexer.g:82:11: 'float32' + { + match("float32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32" + + // $ANTLR start "Float64" + public final void mFloat64() throws RecognitionException { + try { + int _type = Float64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:84:9: ( 'float64' ) + // InternalRosLexer.g:84:11: 'float64' + { + match("float64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64" + + // $ANTLR start "Int16_1" + public final void mInt16_1() throws RecognitionException { + try { + int _type = Int16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:86:9: ( 'int16[]' ) + // InternalRosLexer.g:86:11: 'int16[]' + { + match("int16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16_1" + + // $ANTLR start "Int32_1" + public final void mInt32_1() throws RecognitionException { + try { + int _type = Int32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:88:9: ( 'int32[]' ) + // InternalRosLexer.g:88:11: 'int32[]' + { + match("int32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32_1" + + // $ANTLR start "Int64_1" + public final void mInt64_1() throws RecognitionException { + try { + int _type = Int64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:90:9: ( 'int64[]' ) + // InternalRosLexer.g:90:11: 'int64[]' + { + match("int64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64_1" + + // $ANTLR start "Message" + public final void mMessage() throws RecognitionException { + try { + int _type = Message; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:92:9: ( 'message' ) + // InternalRosLexer.g:92:11: 'message' + { + match("message"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message" + + // $ANTLR start "Result_1" + public final void mResult_1() throws RecognitionException { + try { + int _type = Result_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:94:10: ( 'result:' ) + // InternalRosLexer.g:94:12: 'result:' + { + match("result:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result_1" + + // $ANTLR start "Service" + public final void mService() throws RecognitionException { + try { + int _type = Service; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:96:9: ( 'service' ) + // InternalRosLexer.g:96:11: 'service' + { + match("service"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Service" + + // $ANTLR start "Uint8_1" + public final void mUint8_1() throws RecognitionException { + try { + int _type = Uint8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:98:9: ( 'uint8[]' ) + // InternalRosLexer.g:98:11: 'uint8[]' + { + match("uint8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8_1" + + // $ANTLR start "Array" + public final void mArray() throws RecognitionException { + try { + int _type = Array; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:100:7: ( 'Array:' ) + // InternalRosLexer.g:100:9: 'Array:' + { + match("Array:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Array" + + // $ANTLR start "Base64" + public final void mBase64() throws RecognitionException { + try { + int _type = Base64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:102:8: ( 'Base64' ) + // InternalRosLexer.g:102:10: 'Base64' + { + match("Base64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Base64" + + // $ANTLR start "Double" + public final void mDouble() throws RecognitionException { + try { + int _type = Double; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:104:8: ( 'Double' ) + // InternalRosLexer.g:104:10: 'Double' + { + match("Double"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Double" + + // $ANTLR start "Header" + public final void mHeader() throws RecognitionException { + try { + int _type = Header; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:106:8: ( 'Header' ) + // InternalRosLexer.g:106:10: 'Header' + { + match("Header"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Header" + + // $ANTLR start "String" + public final void mString() throws RecognitionException { + try { + int _type = String; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:108:8: ( 'String' ) + // InternalRosLexer.g:108:10: 'String' + { + match("String"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String" + + // $ANTLR start "Struct" + public final void mStruct() throws RecognitionException { + try { + int _type = Struct; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:110:8: ( 'Struct' ) + // InternalRosLexer.g:110:10: 'Struct' + { + match("Struct"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Struct" + + // $ANTLR start "Action" + public final void mAction() throws RecognitionException { + try { + int _type = Action; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:112:8: ( 'action' ) + // InternalRosLexer.g:112:10: 'action' + { + match("action"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action" + + // $ANTLR start "Bool_1" + public final void mBool_1() throws RecognitionException { + try { + int _type = Bool_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:114:8: ( 'bool[]' ) + // InternalRosLexer.g:114:10: 'bool[]' + { + match("bool[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool_1" + + // $ANTLR start "Byte_1" + public final void mByte_1() throws RecognitionException { + try { + int _type = Byte_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:116:8: ( 'byte[]' ) + // InternalRosLexer.g:116:10: 'byte[]' + { + match("byte[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte_1" + + // $ANTLR start "Int8_1" + public final void mInt8_1() throws RecognitionException { + try { + int _type = Int8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:118:8: ( 'int8[]' ) + // InternalRosLexer.g:118:10: 'int8[]' + { + match("int8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8_1" + + // $ANTLR start "Result" + public final void mResult() throws RecognitionException { + try { + int _type = Result; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:120:8: ( 'result' ) + // InternalRosLexer.g:120:10: 'result' + { + match("result"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result" + + // $ANTLR start "Specs" + public final void mSpecs() throws RecognitionException { + try { + int _type = Specs; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:122:7: ( 'specs:' ) + // InternalRosLexer.g:122:9: 'specs:' + { + match("specs:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Specs" + + // $ANTLR start "String_1" + public final void mString_1() throws RecognitionException { + try { + int _type = String_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:124:10: ( 'string' ) + // InternalRosLexer.g:124:12: 'string' + { + match("string"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_1" + + // $ANTLR start "Uint16" + public final void mUint16() throws RecognitionException { + try { + int _type = Uint16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:126:8: ( 'uint16' ) + // InternalRosLexer.g:126:10: 'uint16' + { + match("uint16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16" + + // $ANTLR start "Uint32" + public final void mUint32() throws RecognitionException { + try { + int _type = Uint32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:128:8: ( 'uint32' ) + // InternalRosLexer.g:128:10: 'uint32' + { + match("uint32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32" + + // $ANTLR start "Uint64" + public final void mUint64() throws RecognitionException { + try { + int _type = Uint64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:130:8: ( 'uint64' ) + // InternalRosLexer.g:130:10: 'uint64' + { + match("uint64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64" + + // $ANTLR start "Goal_1" + public final void mGoal_1() throws RecognitionException { + try { + int _type = Goal_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:132:8: ( 'goal:' ) + // InternalRosLexer.g:132:10: 'goal:' + { + match("goal:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal_1" + + // $ANTLR start "Int16" + public final void mInt16() throws RecognitionException { + try { + int _type = Int16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:134:7: ( 'int16' ) + // InternalRosLexer.g:134:9: 'int16' + { + match("int16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16" + + // $ANTLR start "Int32" + public final void mInt32() throws RecognitionException { + try { + int _type = Int32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:136:7: ( 'int32' ) + // InternalRosLexer.g:136:9: 'int32' + { + match("int32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32" + + // $ANTLR start "Int64" + public final void mInt64() throws RecognitionException { + try { + int _type = Int64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:138:7: ( 'int64' ) + // InternalRosLexer.g:138:9: 'int64' + { + match("int64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64" + + // $ANTLR start "Node_1" + public final void mNode_1() throws RecognitionException { + try { + int _type = Node_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:140:8: ( 'node:' ) + // InternalRosLexer.g:140:10: 'node:' + { + match("node:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node_1" + + // $ANTLR start "Type_1" + public final void mType_1() throws RecognitionException { + try { + int _type = Type_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:142:8: ( 'type:' ) + // InternalRosLexer.g:142:10: 'type:' + { + match("type:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type_1" + + // $ANTLR start "Uint8" + public final void mUint8() throws RecognitionException { + try { + int _type = Uint8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:144:7: ( 'uint8' ) + // InternalRosLexer.g:144:9: 'uint8' + { + match("uint8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8" + + // $ANTLR start "Value" + public final void mValue() throws RecognitionException { + try { + int _type = Value; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:146:7: ( 'value' ) + // InternalRosLexer.g:146:9: 'value' + { + match("value"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Value" + + // $ANTLR start "Date" + public final void mDate() throws RecognitionException { + try { + int _type = Date; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:148:6: ( 'Date' ) + // InternalRosLexer.g:148:8: 'Date' + { + match("Date"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Date" + + // $ANTLR start "List" + public final void mList() throws RecognitionException { + try { + int _type = List; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:150:6: ( 'List' ) + // InternalRosLexer.g:150:8: 'List' + { + match("List"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "List" + + // $ANTLR start "Bool" + public final void mBool() throws RecognitionException { + try { + int _type = Bool; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:152:6: ( 'bool' ) + // InternalRosLexer.g:152:8: 'bool' + { + match("bool"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool" + + // $ANTLR start "Byte" + public final void mByte() throws RecognitionException { + try { + int _type = Byte; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:154:6: ( 'byte' ) + // InternalRosLexer.g:154:8: 'byte' + { + match("byte"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte" + + // $ANTLR start "Goal" + public final void mGoal() throws RecognitionException { + try { + int _type = Goal; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:156:6: ( 'goal' ) + // InternalRosLexer.g:156:8: 'goal' + { + match("goal"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal" + + // $ANTLR start "Int8" + public final void mInt8() throws RecognitionException { + try { + int _type = Int8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:158:6: ( 'int8' ) + // InternalRosLexer.g:158:8: 'int8' + { + match("int8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8" + + // $ANTLR start "Msg" + public final void mMsg() throws RecognitionException { + try { + int _type = Msg; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:160:5: ( 'msg:' ) + // InternalRosLexer.g:160:7: 'msg:' + { + match("msg:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Msg" + + // $ANTLR start "Name" + public final void mName() throws RecognitionException { + try { + int _type = Name; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:162:6: ( 'name' ) + // InternalRosLexer.g:162:8: 'name' + { + match("name"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Name" + + // $ANTLR start "Node" + public final void mNode() throws RecognitionException { + try { + int _type = Node; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:164:6: ( 'node' ) + // InternalRosLexer.g:164:8: 'node' + { + match("node"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node" + + // $ANTLR start "Srv" + public final void mSrv() throws RecognitionException { + try { + int _type = Srv; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:166:5: ( 'srv:' ) + // InternalRosLexer.g:166:7: 'srv:' + { + match("srv:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Srv" + + // $ANTLR start "Time" + public final void mTime() throws RecognitionException { + try { + int _type = Time; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:168:6: ( 'time' ) + // InternalRosLexer.g:168:8: 'time' + { + match("time"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Time" + + // $ANTLR start "Type" + public final void mType() throws RecognitionException { + try { + int _type = Type; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:170:6: ( 'type' ) + // InternalRosLexer.g:170:8: 'type' + { + match("type"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type" + + // $ANTLR start "Any" + public final void mAny() throws RecognitionException { + try { + int _type = Any; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:172:5: ( 'Any' ) + // InternalRosLexer.g:172:7: 'Any' + { + match("Any"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Any" + + // $ANTLR start "Ns" + public final void mNs() throws RecognitionException { + try { + int _type = Ns; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:174:4: ( 'ns:' ) + // InternalRosLexer.g:174:6: 'ns:' + { + match("ns:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Ns" + + // $ANTLR start "LeftSquareBracketRightSquareBracket" + public final void mLeftSquareBracketRightSquareBracket() throws RecognitionException { + try { + int _type = LeftSquareBracketRightSquareBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:176:37: ( '[]' ) + // InternalRosLexer.g:176:39: '[]' + { + match("[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LeftSquareBracketRightSquareBracket" + + // $ANTLR start "Comma" + public final void mComma() throws RecognitionException { + try { + int _type = Comma; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:178:7: ( ',' ) + // InternalRosLexer.g:178: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; + // InternalRosLexer.g:180:7: ( ':' ) + // InternalRosLexer.g:180: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; + // InternalRosLexer.g:182:19: ( '[' ) + // InternalRosLexer.g:182: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; + // InternalRosLexer.g:184:20: ( ']' ) + // InternalRosLexer.g:184: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; + // InternalRosLexer.g:186:19: ( '}' ) + // InternalRosLexer.g:186:21: '}' + { + match('}'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RightCurlyBracket" + + // $ANTLR start "RULE_BEGIN" + public final void mRULE_BEGIN() throws RecognitionException { + try { + // InternalRosLexer.g:188:21: () + // InternalRosLexer.g:188:23: + { + } + + } + finally { + } + } + // $ANTLR end "RULE_BEGIN" + + // $ANTLR start "RULE_END" + public final void mRULE_END() throws RecognitionException { + try { + // InternalRosLexer.g:190:19: () + // InternalRosLexer.g:190: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; + // InternalRosLexer.g:192:17: ( '#' (~ ( ( '\\n' | '\\r' ) ) )* ) + // InternalRosLexer.g:192:19: '#' (~ ( ( '\\n' | '\\r' ) ) )* + { + match('#'); + // InternalRosLexer.g:192: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 : + // InternalRosLexer.g:192: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; + // InternalRosLexer.g:194:23: ( ( '/' RULE_ID | RULE_ID '/' )* ) + // InternalRosLexer.g:194:25: ( '/' RULE_ID | RULE_ID '/' )* + { + // InternalRosLexer.g:194: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 : + // InternalRosLexer.g:194:26: '/' RULE_ID + { + match('/'); + mRULE_ID(); + + } + break; + case 2 : + // InternalRosLexer.g:194: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; + // InternalRosLexer.g:196:27: ( ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* ) + // InternalRosLexer.g:196:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* + { + // InternalRosLexer.g:196: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 : + // InternalRosLexer.g:196:30: '/' RULE_STRING + { + match('/'); + mRULE_STRING(); + + } + break; + case 2 : + // InternalRosLexer.g:196:46: RULE_STRING '/' + { + mRULE_STRING(); + match('/'); + + } + break; + case 3 : + // InternalRosLexer.g:196: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_DIGIT" + public final void mRULE_DIGIT() throws RecognitionException { + try { + // InternalRosLexer.g:198:21: ( '0' .. '9' ) + // InternalRosLexer.g:198:23: '0' .. '9' + { + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_DIGIT" + + // $ANTLR start "RULE_BINARY" + public final void mRULE_BINARY() throws RecognitionException { + try { + int _type = RULE_BINARY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:200:13: ( ( '0b' | '0B' ) ( '0' | '1' )+ ) + // InternalRosLexer.g:200:15: ( '0b' | '0B' ) ( '0' | '1' )+ + { + // InternalRosLexer.g:200:15: ( '0b' | '0B' ) + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0=='0') ) { + int LA4_1 = input.LA(2); + + if ( (LA4_1=='b') ) { + alt4=1; + } + else if ( (LA4_1=='B') ) { + alt4=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + switch (alt4) { + case 1 : + // InternalRosLexer.g:200:16: '0b' + { + match("0b"); + + + } + break; + case 2 : + // InternalRosLexer.g:200:21: '0B' + { + match("0B"); + + + } + break; + + } + + // InternalRosLexer.g:200:27: ( '0' | '1' )+ + int cnt5=0; + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( ((LA5_0>='0' && LA5_0<='1')) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalRosLexer.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='1') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt5 >= 1 ) break loop5; + EarlyExitException eee = + new EarlyExitException(5, input); + throw eee; + } + cnt5++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BINARY" + + // $ANTLR start "RULE_BOOLEAN" + public final void mRULE_BOOLEAN() throws RecognitionException { + try { + int _type = RULE_BOOLEAN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:202:14: ( ( 'true' | 'false' ) ) + // InternalRosLexer.g:202:16: ( 'true' | 'false' ) + { + // InternalRosLexer.g:202:16: ( 'true' | 'false' ) + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='t') ) { + alt6=1; + } + else if ( (LA6_0=='f') ) { + alt6=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + switch (alt6) { + case 1 : + // InternalRosLexer.g:202:17: 'true' + { + match("true"); + + + } + break; + case 2 : + // InternalRosLexer.g:202:24: 'false' + { + match("false"); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BOOLEAN" + + // $ANTLR start "RULE_DOUBLE" + public final void mRULE_DOUBLE() throws RecognitionException { + try { + int _type = RULE_DOUBLE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:204:13: ( RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) ) + // InternalRosLexer.g:204:15: RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + { + mRULE_DIGIT(); + // InternalRosLexer.g:204:26: ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + int alt11=2; + alt11 = dfa11.predict(input); + switch (alt11) { + case 1 : + // InternalRosLexer.g:204:27: '.' ( RULE_DECINT )* + { + match('.'); + // InternalRosLexer.g:204:31: ( RULE_DECINT )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0=='-'||(LA7_0>='0' && LA7_0<='9')) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalRosLexer.g:204:31: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + + default : + break loop7; + } + } while (true); + + + } + break; + case 2 : + // InternalRosLexer.g:204:44: ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT + { + // InternalRosLexer.g:204:44: ( '.' ( RULE_DIGIT )* )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='.') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalRosLexer.g:204:45: '.' ( RULE_DIGIT )* + { + match('.'); + // InternalRosLexer.g:204:49: ( RULE_DIGIT )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( ((LA8_0>='0' && LA8_0<='9')) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // InternalRosLexer.g:204:49: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop8; + } + } while (true); + + + } + break; + + } + + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalRosLexer.g:204:73: ( '-' | '+' )? + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='+'||LA10_0=='-') ) { + alt10=1; + } + switch (alt10) { + case 1 : + // InternalRosLexer.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_DIGIT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DOUBLE" + + // $ANTLR start "RULE_DECINT" + public final void mRULE_DECINT() throws RecognitionException { + try { + int _type = RULE_DECINT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:206:13: ( ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) ) + // InternalRosLexer.g:206:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + { + // InternalRosLexer.g:206:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + int alt14=3; + switch ( input.LA(1) ) { + case '0': + { + alt14=1; + } + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt14=2; + } + break; + case '-': + { + alt14=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + + throw nvae; + } + + switch (alt14) { + case 1 : + // InternalRosLexer.g:206:16: '0' + { + match('0'); + + } + break; + case 2 : + // InternalRosLexer.g:206:20: '1' .. '9' ( RULE_DIGIT )* + { + matchRange('1','9'); + // InternalRosLexer.g:206:29: ( RULE_DIGIT )* + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( ((LA12_0>='0' && LA12_0<='9')) ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalRosLexer.g:206:29: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop12; + } + } while (true); + + + } + break; + case 3 : + // InternalRosLexer.g:206:41: '-' '0' .. '9' ( RULE_DIGIT )* + { + match('-'); + matchRange('0','9'); + // InternalRosLexer.g:206:54: ( RULE_DIGIT )* + loop13: + do { + int alt13=2; + int LA13_0 = input.LA(1); + + if ( ((LA13_0>='0' && LA13_0<='9')) ) { + alt13=1; + } + + + switch (alt13) { + case 1 : + // InternalRosLexer.g:206:54: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop13; + } + } while (true); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DECINT" + + // $ANTLR start "RULE_DAY" + public final void mRULE_DAY() throws RecognitionException { + try { + // InternalRosLexer.g:208:19: ( ( '1' .. '9' | '1' .. '3' '0' .. '9' ) ) + // InternalRosLexer.g:208:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + { + // InternalRosLexer.g:208:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + int alt15=2; + int LA15_0 = input.LA(1); + + if ( ((LA15_0>='1' && LA15_0<='3')) ) { + int LA15_1 = input.LA(2); + + if ( ((LA15_1>='0' && LA15_1<='9')) ) { + alt15=2; + } + else { + alt15=1;} + } + else if ( ((LA15_0>='4' && LA15_0<='9')) ) { + alt15=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + + throw nvae; + } + switch (alt15) { + case 1 : + // InternalRosLexer.g:208:22: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRosLexer.g:208:31: '1' .. '3' '0' .. '9' + { + matchRange('1','3'); + matchRange('0','9'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_DAY" + + // $ANTLR start "RULE_MONTH" + public final void mRULE_MONTH() throws RecognitionException { + try { + // InternalRosLexer.g:210:21: ( ( '1' .. '9' | '1' '0' .. '2' ) ) + // InternalRosLexer.g:210:23: ( '1' .. '9' | '1' '0' .. '2' ) + { + // InternalRosLexer.g:210:23: ( '1' .. '9' | '1' '0' .. '2' ) + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='1') ) { + int LA16_1 = input.LA(2); + + if ( ((LA16_1>='0' && LA16_1<='2')) ) { + alt16=2; + } + else { + alt16=1;} + } + else if ( ((LA16_0>='2' && LA16_0<='9')) ) { + alt16=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + + throw nvae; + } + switch (alt16) { + case 1 : + // InternalRosLexer.g:210:24: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRosLexer.g:210:33: '1' '0' .. '2' + { + match('1'); + matchRange('0','2'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_MONTH" + + // $ANTLR start "RULE_YEAR" + public final void mRULE_YEAR() throws RecognitionException { + try { + // InternalRosLexer.g:212:20: ( '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' ) + // InternalRosLexer.g:212:22: '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' + { + matchRange('0','2'); + matchRange('0','9'); + matchRange('0','9'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_YEAR" + + // $ANTLR start "RULE_HOUR" + public final void mRULE_HOUR() throws RecognitionException { + try { + // InternalRosLexer.g:214:20: ( ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) ) + // InternalRosLexer.g:214:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + { + // InternalRosLexer.g:214:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + int alt17=2; + int LA17_0 = input.LA(1); + + if ( ((LA17_0>='0' && LA17_0<='1')) ) { + alt17=1; + } + else if ( (LA17_0=='2') ) { + alt17=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); + + throw nvae; + } + switch (alt17) { + case 1 : + // InternalRosLexer.g:214:23: '0' .. '1' '0' .. '9' + { + matchRange('0','1'); + matchRange('0','9'); + + } + break; + case 2 : + // InternalRosLexer.g:214:41: '2' '0' .. '3' + { + match('2'); + matchRange('0','3'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_HOUR" + + // $ANTLR start "RULE_MIN_SEC" + public final void mRULE_MIN_SEC() throws RecognitionException { + try { + // InternalRosLexer.g:216:23: ( '0' .. '5' '0' .. '9' ) + // InternalRosLexer.g:216:25: '0' .. '5' '0' .. '9' + { + matchRange('0','5'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_MIN_SEC" + + // $ANTLR start "RULE_DATE_TIME" + public final void mRULE_DATE_TIME() throws RecognitionException { + try { + int _type = RULE_DATE_TIME; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:218:16: ( RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC ) + // InternalRosLexer.g:218:18: RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC + { + mRULE_YEAR(); + match('-'); + mRULE_MONTH(); + match('-'); + mRULE_DAY(); + match('T'); + mRULE_HOUR(); + match(':'); + mRULE_MIN_SEC(); + match(':'); + mRULE_MIN_SEC(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DATE_TIME" + + // $ANTLR start "RULE_MESSAGE_ASIGMENT" + public final void mRULE_MESSAGE_ASIGMENT() throws RecognitionException { + try { + int _type = RULE_MESSAGE_ASIGMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:220:23: ( ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) ) + // InternalRosLexer.g:220:25: ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + { + // InternalRosLexer.g:220:25: ( RULE_ID | RULE_STRING ) + int alt18=2; + int LA18_0 = input.LA(1); + + if ( ((LA18_0>='A' && LA18_0<='Z')||(LA18_0>='^' && LA18_0<='_')||(LA18_0>='a' && LA18_0<='z')) ) { + alt18=1; + } + else if ( (LA18_0=='\"'||LA18_0=='\'') ) { + alt18=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + + throw nvae; + } + switch (alt18) { + case 1 : + // InternalRosLexer.g:220:26: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRosLexer.g:220:34: RULE_STRING + { + mRULE_STRING(); + + } + break; + + } + + match('='); + // InternalRosLexer.g:220:51: ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + int alt19=4; + switch ( input.LA(1) ) { + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + case 'G': + case 'H': + case 'I': + case 'J': + case 'K': + case 'L': + case 'M': + case 'N': + case 'O': + case 'P': + case 'Q': + case 'R': + case 'S': + case 'T': + case 'U': + case 'V': + case 'W': + case 'X': + case 'Y': + case 'Z': + case '^': + case '_': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'g': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': + { + alt19=1; + } + break; + case '\"': + case '\'': + { + alt19=2; + } + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt19=3; + } + break; + case '-': + { + alt19=4; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 19, 0, input); + + throw nvae; + } + + switch (alt19) { + case 1 : + // InternalRosLexer.g:220:52: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRosLexer.g:220:60: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 3 : + // InternalRosLexer.g:220:72: RULE_INT + { + mRULE_INT(); + + } + break; + case 4 : + // InternalRosLexer.g:220:81: '-' RULE_INT + { + match('-'); + mRULE_INT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_MESSAGE_ASIGMENT" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRosLexer.g:222:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // InternalRosLexer.g:222:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + // InternalRosLexer.g:222:11: ( '^' )? + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0=='^') ) { + alt20=1; + } + switch (alt20) { + case 1 : + // InternalRosLexer.g:222: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;} + + // InternalRosLexer.g:222:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop21: + do { + int alt21=2; + int LA21_0 = input.LA(1); + + if ( ((LA21_0>='0' && LA21_0<='9')||(LA21_0>='A' && LA21_0<='Z')||LA21_0=='_'||(LA21_0>='a' && LA21_0<='z')) ) { + alt21=1; + } + + + switch (alt21) { + case 1 : + // InternalRosLexer.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 loop21; + } + } 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 { + // InternalRosLexer.g:224:19: ( ( '0' .. '9' )+ ) + // InternalRosLexer.g:224:21: ( '0' .. '9' )+ + { + // InternalRosLexer.g:224:21: ( '0' .. '9' )+ + int cnt22=0; + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( ((LA22_0>='0' && LA22_0<='9')) ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalRosLexer.g:224:22: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt22 >= 1 ) break loop22; + EarlyExitException eee = + new EarlyExitException(22, input); + throw eee; + } + cnt22++; + } while (true); + + + } + + } + 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; + // InternalRosLexer.g:226:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) + // InternalRosLexer.g:226:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + { + // InternalRosLexer.g:226:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0=='\"') ) { + alt25=1; + } + else if ( (LA25_0=='\'') ) { + alt25=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); + + throw nvae; + } + switch (alt25) { + case 1 : + // InternalRosLexer.g:226:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + { + match('\"'); + // InternalRosLexer.g:226:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop23: + do { + int alt23=3; + int LA23_0 = input.LA(1); + + if ( (LA23_0=='\\') ) { + alt23=1; + } + else if ( ((LA23_0>='\u0000' && LA23_0<='!')||(LA23_0>='#' && LA23_0<='[')||(LA23_0>=']' && LA23_0<='\uFFFF')) ) { + alt23=2; + } + + + switch (alt23) { + case 1 : + // InternalRosLexer.g:226:21: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRosLexer.g:226: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 loop23; + } + } while (true); + + match('\"'); + + } + break; + case 2 : + // InternalRosLexer.g:226:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + { + match('\''); + // InternalRosLexer.g:226:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop24: + do { + int alt24=3; + int LA24_0 = input.LA(1); + + if ( (LA24_0=='\\') ) { + alt24=1; + } + else if ( ((LA24_0>='\u0000' && LA24_0<='&')||(LA24_0>='(' && LA24_0<='[')||(LA24_0>=']' && LA24_0<='\uFFFF')) ) { + alt24=2; + } + + + switch (alt24) { + case 1 : + // InternalRosLexer.g:226:54: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRosLexer.g:226: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 loop24; + } + } 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; + // InternalRosLexer.g:228:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalRosLexer.g:228:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalRosLexer.g:228:24: ( options {greedy=false; } : . )* + loop26: + do { + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0=='*') ) { + int LA26_1 = input.LA(2); + + if ( (LA26_1=='/') ) { + alt26=2; + } + else if ( ((LA26_1>='\u0000' && LA26_1<='.')||(LA26_1>='0' && LA26_1<='\uFFFF')) ) { + alt26=1; + } + + + } + else if ( ((LA26_0>='\u0000' && LA26_0<=')')||(LA26_0>='+' && LA26_0<='\uFFFF')) ) { + alt26=1; + } + + + switch (alt26) { + case 1 : + // InternalRosLexer.g:228:52: . + { + matchAny(); + + } + break; + + default : + break loop26; + } + } 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; + // InternalRosLexer.g:230:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalRosLexer.g:230:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalRosLexer.g:230:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt27=0; + loop27: + do { + int alt27=2; + int LA27_0 = input.LA(1); + + if ( ((LA27_0>='\t' && LA27_0<='\n')||LA27_0=='\r'||LA27_0==' ') ) { + alt27=1; + } + + + switch (alt27) { + case 1 : + // InternalRosLexer.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 ( cnt27 >= 1 ) break loop27; + EarlyExitException eee = + new EarlyExitException(27, input); + throw eee; + } + cnt27++; + } 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; + // InternalRosLexer.g:232:16: ( . ) + // InternalRosLexer.g:232:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalRosLexer.g:1:8: ( ParameterStructMember | ExternalDependency | RelativeNamespace | PrivateNamespace | GlobalNamespace | Serviceclient | Serviceserver | Actionclient | Actionserver | Dependencies | AmentPackage | ParameterAny | FromGitRepo | Subscribers | Parameters | Publishers | Artifacts | GraphName | Feedback_1 | Float32_1 | Float64_1 | Response | Duration | Feedback | Message_1 | Request | String_2 | Uint16_1 | Uint32_1 | Uint64_1 | Boolean | Integer | Action_1 | Default | Float32 | Float64 | Int16_1 | Int32_1 | Int64_1 | Message | Result_1 | Service | Uint8_1 | Array | Base64 | Double | Header | String | Struct | Action | Bool_1 | Byte_1 | Int8_1 | Result | Specs | String_1 | Uint16 | Uint32 | Uint64 | Goal_1 | Int16 | Int32 | Int64 | Node_1 | Type_1 | Uint8 | Value | Date | List | Bool | Byte | Goal | Int8 | Msg | Name | Node | Srv | Time | Type | Any | Ns | LeftSquareBracketRightSquareBracket | Comma | Colon | LeftSquareBracket | RightSquareBracket | RightCurlyBracket | RULE_SL_COMMENT | RULE_ROS_CONVENTION_A | RULE_ROS_CONVENTION_PARAM | RULE_BINARY | RULE_BOOLEAN | RULE_DOUBLE | RULE_DECINT | RULE_DATE_TIME | RULE_MESSAGE_ASIGMENT | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt28=101; + alt28 = dfa28.predict(input); + switch (alt28) { + case 1 : + // InternalRosLexer.g:1:10: ParameterStructMember + { + mParameterStructMember(); + + } + break; + case 2 : + // InternalRosLexer.g:1:32: ExternalDependency + { + mExternalDependency(); + + } + break; + case 3 : + // InternalRosLexer.g:1:51: RelativeNamespace + { + mRelativeNamespace(); + + } + break; + case 4 : + // InternalRosLexer.g:1:69: PrivateNamespace + { + mPrivateNamespace(); + + } + break; + case 5 : + // InternalRosLexer.g:1:86: GlobalNamespace + { + mGlobalNamespace(); + + } + break; + case 6 : + // InternalRosLexer.g:1:102: Serviceclient + { + mServiceclient(); + + } + break; + case 7 : + // InternalRosLexer.g:1:116: Serviceserver + { + mServiceserver(); + + } + break; + case 8 : + // InternalRosLexer.g:1:130: Actionclient + { + mActionclient(); + + } + break; + case 9 : + // InternalRosLexer.g:1:143: Actionserver + { + mActionserver(); + + } + break; + case 10 : + // InternalRosLexer.g:1:156: Dependencies + { + mDependencies(); + + } + break; + case 11 : + // InternalRosLexer.g:1:169: AmentPackage + { + mAmentPackage(); + + } + break; + case 12 : + // InternalRosLexer.g:1:182: ParameterAny + { + mParameterAny(); + + } + break; + case 13 : + // InternalRosLexer.g:1:195: FromGitRepo + { + mFromGitRepo(); + + } + break; + case 14 : + // InternalRosLexer.g:1:207: Subscribers + { + mSubscribers(); + + } + break; + case 15 : + // InternalRosLexer.g:1:219: Parameters + { + mParameters(); + + } + break; + case 16 : + // InternalRosLexer.g:1:230: Publishers + { + mPublishers(); + + } + break; + case 17 : + // InternalRosLexer.g:1:241: Artifacts + { + mArtifacts(); + + } + break; + case 18 : + // InternalRosLexer.g:1:251: GraphName + { + mGraphName(); + + } + break; + case 19 : + // InternalRosLexer.g:1:261: Feedback_1 + { + mFeedback_1(); + + } + break; + case 20 : + // InternalRosLexer.g:1:272: Float32_1 + { + mFloat32_1(); + + } + break; + case 21 : + // InternalRosLexer.g:1:282: Float64_1 + { + mFloat64_1(); + + } + break; + case 22 : + // InternalRosLexer.g:1:292: Response + { + mResponse(); + + } + break; + case 23 : + // InternalRosLexer.g:1:301: Duration + { + mDuration(); + + } + break; + case 24 : + // InternalRosLexer.g:1:310: Feedback + { + mFeedback(); + + } + break; + case 25 : + // InternalRosLexer.g:1:319: Message_1 + { + mMessage_1(); + + } + break; + case 26 : + // InternalRosLexer.g:1:329: Request + { + mRequest(); + + } + break; + case 27 : + // InternalRosLexer.g:1:337: String_2 + { + mString_2(); + + } + break; + case 28 : + // InternalRosLexer.g:1:346: Uint16_1 + { + mUint16_1(); + + } + break; + case 29 : + // InternalRosLexer.g:1:355: Uint32_1 + { + mUint32_1(); + + } + break; + case 30 : + // InternalRosLexer.g:1:364: Uint64_1 + { + mUint64_1(); + + } + break; + case 31 : + // InternalRosLexer.g:1:373: Boolean + { + mBoolean(); + + } + break; + case 32 : + // InternalRosLexer.g:1:381: Integer + { + mInteger(); + + } + break; + case 33 : + // InternalRosLexer.g:1:389: Action_1 + { + mAction_1(); + + } + break; + case 34 : + // InternalRosLexer.g:1:398: Default + { + mDefault(); + + } + break; + case 35 : + // InternalRosLexer.g:1:406: Float32 + { + mFloat32(); + + } + break; + case 36 : + // InternalRosLexer.g:1:414: Float64 + { + mFloat64(); + + } + break; + case 37 : + // InternalRosLexer.g:1:422: Int16_1 + { + mInt16_1(); + + } + break; + case 38 : + // InternalRosLexer.g:1:430: Int32_1 + { + mInt32_1(); + + } + break; + case 39 : + // InternalRosLexer.g:1:438: Int64_1 + { + mInt64_1(); + + } + break; + case 40 : + // InternalRosLexer.g:1:446: Message + { + mMessage(); + + } + break; + case 41 : + // InternalRosLexer.g:1:454: Result_1 + { + mResult_1(); + + } + break; + case 42 : + // InternalRosLexer.g:1:463: Service + { + mService(); + + } + break; + case 43 : + // InternalRosLexer.g:1:471: Uint8_1 + { + mUint8_1(); + + } + break; + case 44 : + // InternalRosLexer.g:1:479: Array + { + mArray(); + + } + break; + case 45 : + // InternalRosLexer.g:1:485: Base64 + { + mBase64(); + + } + break; + case 46 : + // InternalRosLexer.g:1:492: Double + { + mDouble(); + + } + break; + case 47 : + // InternalRosLexer.g:1:499: Header + { + mHeader(); + + } + break; + case 48 : + // InternalRosLexer.g:1:506: String + { + mString(); + + } + break; + case 49 : + // InternalRosLexer.g:1:513: Struct + { + mStruct(); + + } + break; + case 50 : + // InternalRosLexer.g:1:520: Action + { + mAction(); + + } + break; + case 51 : + // InternalRosLexer.g:1:527: Bool_1 + { + mBool_1(); + + } + break; + case 52 : + // InternalRosLexer.g:1:534: Byte_1 + { + mByte_1(); + + } + break; + case 53 : + // InternalRosLexer.g:1:541: Int8_1 + { + mInt8_1(); + + } + break; + case 54 : + // InternalRosLexer.g:1:548: Result + { + mResult(); + + } + break; + case 55 : + // InternalRosLexer.g:1:555: Specs + { + mSpecs(); + + } + break; + case 56 : + // InternalRosLexer.g:1:561: String_1 + { + mString_1(); + + } + break; + case 57 : + // InternalRosLexer.g:1:570: Uint16 + { + mUint16(); + + } + break; + case 58 : + // InternalRosLexer.g:1:577: Uint32 + { + mUint32(); + + } + break; + case 59 : + // InternalRosLexer.g:1:584: Uint64 + { + mUint64(); + + } + break; + case 60 : + // InternalRosLexer.g:1:591: Goal_1 + { + mGoal_1(); + + } + break; + case 61 : + // InternalRosLexer.g:1:598: Int16 + { + mInt16(); + + } + break; + case 62 : + // InternalRosLexer.g:1:604: Int32 + { + mInt32(); + + } + break; + case 63 : + // InternalRosLexer.g:1:610: Int64 + { + mInt64(); + + } + break; + case 64 : + // InternalRosLexer.g:1:616: Node_1 + { + mNode_1(); + + } + break; + case 65 : + // InternalRosLexer.g:1:623: Type_1 + { + mType_1(); + + } + break; + case 66 : + // InternalRosLexer.g:1:630: Uint8 + { + mUint8(); + + } + break; + case 67 : + // InternalRosLexer.g:1:636: Value + { + mValue(); + + } + break; + case 68 : + // InternalRosLexer.g:1:642: Date + { + mDate(); + + } + break; + case 69 : + // InternalRosLexer.g:1:647: List + { + mList(); + + } + break; + case 70 : + // InternalRosLexer.g:1:652: Bool + { + mBool(); + + } + break; + case 71 : + // InternalRosLexer.g:1:657: Byte + { + mByte(); + + } + break; + case 72 : + // InternalRosLexer.g:1:662: Goal + { + mGoal(); + + } + break; + case 73 : + // InternalRosLexer.g:1:667: Int8 + { + mInt8(); + + } + break; + case 74 : + // InternalRosLexer.g:1:672: Msg + { + mMsg(); + + } + break; + case 75 : + // InternalRosLexer.g:1:676: Name + { + mName(); + + } + break; + case 76 : + // InternalRosLexer.g:1:681: Node + { + mNode(); + + } + break; + case 77 : + // InternalRosLexer.g:1:686: Srv + { + mSrv(); + + } + break; + case 78 : + // InternalRosLexer.g:1:690: Time + { + mTime(); + + } + break; + case 79 : + // InternalRosLexer.g:1:695: Type + { + mType(); + + } + break; + case 80 : + // InternalRosLexer.g:1:700: Any + { + mAny(); + + } + break; + case 81 : + // InternalRosLexer.g:1:704: Ns + { + mNs(); + + } + break; + case 82 : + // InternalRosLexer.g:1:707: LeftSquareBracketRightSquareBracket + { + mLeftSquareBracketRightSquareBracket(); + + } + break; + case 83 : + // InternalRosLexer.g:1:743: Comma + { + mComma(); + + } + break; + case 84 : + // InternalRosLexer.g:1:749: Colon + { + mColon(); + + } + break; + case 85 : + // InternalRosLexer.g:1:755: LeftSquareBracket + { + mLeftSquareBracket(); + + } + break; + case 86 : + // InternalRosLexer.g:1:773: RightSquareBracket + { + mRightSquareBracket(); + + } + break; + case 87 : + // InternalRosLexer.g:1:792: RightCurlyBracket + { + mRightCurlyBracket(); + + } + break; + case 88 : + // InternalRosLexer.g:1:810: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 89 : + // InternalRosLexer.g:1:826: RULE_ROS_CONVENTION_A + { + mRULE_ROS_CONVENTION_A(); + + } + break; + case 90 : + // InternalRosLexer.g:1:848: RULE_ROS_CONVENTION_PARAM + { + mRULE_ROS_CONVENTION_PARAM(); + + } + break; + case 91 : + // InternalRosLexer.g:1:874: RULE_BINARY + { + mRULE_BINARY(); + + } + break; + case 92 : + // InternalRosLexer.g:1:886: RULE_BOOLEAN + { + mRULE_BOOLEAN(); + + } + break; + case 93 : + // InternalRosLexer.g:1:899: RULE_DOUBLE + { + mRULE_DOUBLE(); + + } + break; + case 94 : + // InternalRosLexer.g:1:911: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + case 95 : + // InternalRosLexer.g:1:923: RULE_DATE_TIME + { + mRULE_DATE_TIME(); + + } + break; + case 96 : + // InternalRosLexer.g:1:938: RULE_MESSAGE_ASIGMENT + { + mRULE_MESSAGE_ASIGMENT(); + + } + break; + case 97 : + // InternalRosLexer.g:1:960: RULE_ID + { + mRULE_ID(); + + } + break; + case 98 : + // InternalRosLexer.g:1:968: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 99 : + // InternalRosLexer.g:1:980: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 100 : + // InternalRosLexer.g:1:996: RULE_WS + { + mRULE_WS(); + + } + break; + case 101 : + // InternalRosLexer.g:1:1004: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA11 dfa11 = new DFA11(this); + protected DFA28 dfa28 = new DFA28(this); + static final String DFA11_eotS = + "\1\uffff\1\5\1\uffff\2\5\1\uffff\2\5"; + static final String DFA11_eofS = + "\10\uffff"; + static final String DFA11_minS = + "\1\56\1\60\1\uffff\2\60\1\uffff\2\60"; + static final String DFA11_maxS = + "\2\145\1\uffff\2\145\1\uffff\2\145"; + static final String DFA11_acceptS = + "\2\uffff\1\2\2\uffff\1\1\2\uffff"; + static final String DFA11_specialS = + "\10\uffff}>"; + static final String[] DFA11_transitionS = { + "\1\1\26\uffff\1\2\37\uffff\1\2", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2" + }; + + static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); + static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); + static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); + static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); + static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); + static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); + static final short[][] DFA11_transition; + + static { + int numStates = DFA11_transitionS.length; + DFA11_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA28_transitionS = { + "\11\54\2\53\2\54\1\53\22\54\1\53\1\54\1\44\1\37\3\54\1\45\4\54\1\33\1\51\1\54\1\40\1\47\2\50\7\52\1\34\6\54\1\10\1\16\1\42\1\21\1\2\1\42\1\4\1\22\1\17\2\42\1\31\3\42\1\1\1\42\1\3\1\23\7\42\1\32\1\54\1\35\1\41\1\42\1\54\1\6\1\24\1\42\1\7\1\42\1\11\1\25\1\42\1\20\3\42\1\14\1\26\1\42\1\12\1\42\1\13\1\5\1\27\1\15\1\30\4\42\2\54\1\36\1\46\uff81\54", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\55\20\57\1\56\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\27\57\1\62\2\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\63\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\64\5\57\1\65\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\66\12\57\1\71\1\57\1\72\1\57\1\70\1\67\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\73\16\57\1\74\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\75\17\57\1\76\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\77\1\101\3\57\1\100\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\105\3\57\1\103\6\57\1\104\5\57\1\102\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\106\23\57\1\107\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\110\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\111\15\57\1\112\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\113\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\115\15\57\1\114\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\116\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\117\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\121\15\57\1\120\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\122\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\123\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\124\11\57\1\125\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\126\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\130\15\57\1\127\3\57\1\131\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\133\10\57\1\134\6\57\1\132\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\135\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\136\21\57", + "\1\137", + "", + "", + "", + "", + "", + "\1\147\4\uffff\1\147\2\uffff\1\146\26\uffff\32\43\3\uffff\2\43\1\uffff\32\43", + "\32\150\4\uffff\1\150\1\uffff\32\150", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\42\152\1\153\71\152\1\151\uffa3\152", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\1\147\4\uffff\1\147", + "\1\162\1\uffff\12\160\10\uffff\1\157\2\uffff\1\162\34\uffff\1\157\2\uffff\1\162", + "\1\162\1\uffff\12\163\13\uffff\1\162\37\uffff\1\162", + "\12\161", + "\1\162\26\uffff\1\162\37\uffff\1\162", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\165\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\166\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\167\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\170\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\171\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\172\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\173\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\174\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\175\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\176\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\177\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0080\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0081\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\5\57\1\u0083\11\57\1\u0082\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0084\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0085\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0086\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u0087\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u0088\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0089\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u008a\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u008b\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u008c\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u008d\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\20\57\1\u008f\1\57\1\u008e\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0090\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0091\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0092\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u0093\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0094\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0095\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0096\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u0097\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0098\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0099\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u009a\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u009b\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u009c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u009d\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u009e\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u009f\15\57", + "\1\43\12\57\1\u00a0\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00a1\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00a2\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00a3\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00a4\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00a5\7\57", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\0\u00a6", + "\42\152\1\153\71\152\1\151\uffa3\152", + "\1\147\15\uffff\1\61", + "\0\u00a8", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\1\147\15\uffff\1\61", + "", + "", + "", + "", + "\12\u00a9", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00aa\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u00ab\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ac\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00ad\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00ae\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00af\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u00b0\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00b1\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b2\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u00b3\27\57", + "\1\43\12\57\1\u00b4\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b5\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00b7\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00b8\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00b9\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00ba\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00bb\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00bd\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u00be\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00bf\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00c0\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00c1\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00c2\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00c3\4\57\1\u00c4\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00c5\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00c6\7\57", + "\1\43\12\57\1\u00c7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00c8\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00c9\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ca\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00cb\25\57", + "\1\43\1\57\1\u00cc\1\57\1\u00cd\2\57\1\u00ce\1\57\1\u00cf\1\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00d0\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d1\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u00d2\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00d3\13\57\1\u00d4\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00d5\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d6\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00d7\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d8\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d9\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00da\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00db\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00dc\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00dd\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00de\6\57", + "\42\152\1\153\71\152\1\151\uffa3\152", + "", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\12\u00df", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00e0\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00e1\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u00e2\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00e3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00e4\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\7\57\1\u00e5\22\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00e6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u00e7\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00e8\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00e9\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u00ea\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\5\57\1\u00eb\24\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00ec\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00ed\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00ee\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00ef\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u00f0\1\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\6\57\1\u00f1\23\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00f2\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00f3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00f4\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00f5\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00f6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u00f7\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00f8\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00f9\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00fa\31\57", + "", + "\1\43\1\57\1\u00fb\1\57\1\u00fc\2\57\1\u00fd\1\57\1\u00fe\1\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ff\25\57", + "\1\43\6\57\1\u0100\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0101\23\57", + "\1\43\6\57\1\u0102\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\2\57\1\u0103\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u0104\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0105\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0107\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0109\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u010a\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u010b\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u010c\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u010e\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0110\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0112\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0115\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0119\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\160", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u011b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u011c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u011d\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u011e\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u011f\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0120\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0121\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0122\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0123\23\57", + "\1\43\12\57\1\u0124\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0125\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0126\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u0127\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0128\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u0129\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\17\57\1\u012a\12\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u012b\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u012c\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u012d\31\57", + "\1\43\3\57\1\u012e\2\57\1\u012f\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0130\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0131\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0132\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0133\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0134\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0135\23\57", + "\1\43\6\57\1\u0136\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\2\57\1\u0137\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u0138\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0139\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u013b\31\57", + "\1\43\4\57\1\u013c\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u013d\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u013e\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0140\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0142\3\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0144\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0145\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0146\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0147\6\57", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0149\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u014a\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u014b\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u014c\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u014d\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u014e\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u014f\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u0150\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0151\3\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\1\u0155\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0153\17\57\1\u0154\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0157\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0158\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0159\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u015a\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u015b\31\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u015c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u015d\27\57", + "\1\43\2\57\1\u015e\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u015f\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0160\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\7\57\1\u0161\22\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0162\7\57", + "\1\43\12\57\1\u0163\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0165\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0166\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0167\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0169\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u016b\3\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u016d\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u016f\10\57", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0174\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0175\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0176\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0177\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0178\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u0179\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u017a\17\57\1\u017b\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u017d\30\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u017e\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u017f\25\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0180\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0181\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0183\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0184\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\21\57\1\u0185\10\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\12\57\1\u0186\17\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0187\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0189\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018c\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018d\25\57", + "", + "", + "\1\43\12\57\1\u018e\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u018f\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0193\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0194\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\3\57\1\u0195\26\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0196\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u0197\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0198\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0199\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u019a\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u019b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u019c\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u019d\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u019e\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u019f\27\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\12\57\1\u01a1\17\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01a2\25\57", + "\1\43\12\57\1\u01a3\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01a5\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01a6\10\57", + "\1\43\12\57\1\u01a7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\1\u01a9\21\57\1\u01a8\7\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01aa\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ab\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01ac\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ad\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u01af\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01b0\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01b1\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01b2\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u01b3\4\57", + "\1\43\12\57\1\u01b4\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u01b5\21\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01b6\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01b7\12\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01b8\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01b9\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01ba\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01bb\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01bc\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01bd\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01be\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01bf\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c0\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u01c1\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01c2\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01c3\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c4\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c5\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u01c6\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u01c7\13\57", + "\1\43\12\57\1\u01c8\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01c9\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01ca\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u01cb\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01cc\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01cd\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ce\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01cf\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01d0\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01d1\25\57", + "\1\43\12\57\1\u01d2\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01d3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01d4\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01d5\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01d6\25\57", + "\1\43\12\57\1\u01d7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u01d8\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01da\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01db\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01dc\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01dd\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01de\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01df\10\57", + "", + "\1\43\12\57\1\u01e0\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01e1\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01e2\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01e4\27\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01e5\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u01e6\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01e7\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01e8\27\57", + "\1\43\12\57\1\u01e9\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01ea\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01eb\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01ec\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ed\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01ee\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ef\25\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\14\57\1\u01f0\15\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f1\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01f2\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01f3\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f5\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01f7\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f8\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01f9\15\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u01fa\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u01fc\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01fe\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01ff\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "" + }; + + static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS); + static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS); + static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS); + static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS); + static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS); + static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS); + static final short[][] DFA28_transition; + + static { + int numStates = DFA28_transitionS.length; + DFA28_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA28_105<='\uFFFF')) ) {s = 166;} + + if ( s>=0 ) return s; + break; + case 1 : + int LA28_108 = input.LA(1); + + s = -1; + if ( ((LA28_108>='\u0000' && LA28_108<='\uFFFF')) ) {s = 168;} + + if ( s>=0 ) return s; + break; + case 2 : + int LA28_37 = input.LA(1); + + s = -1; + if ( (LA28_37=='\\') ) {s = 108;} + + else if ( ((LA28_37>='\u0000' && LA28_37<='&')||(LA28_37>='(' && LA28_37<='[')||(LA28_37>=']' && LA28_37<='\uFFFF')) ) {s = 109;} + + else if ( (LA28_37=='\'') ) {s = 110;} + + else s = 44; + + if ( s>=0 ) return s; + break; + case 3 : + int LA28_0 = input.LA(1); + + s = -1; + if ( (LA28_0=='P') ) {s = 1;} + + else if ( (LA28_0=='E') ) {s = 2;} + + else if ( (LA28_0=='R') ) {s = 3;} + + else if ( (LA28_0=='G') ) {s = 4;} + + else if ( (LA28_0=='s') ) {s = 5;} + + else if ( (LA28_0=='a') ) {s = 6;} + + else if ( (LA28_0=='d') ) {s = 7;} + + else if ( (LA28_0=='A') ) {s = 8;} + + else if ( (LA28_0=='f') ) {s = 9;} + + else if ( (LA28_0=='p') ) {s = 10;} + + else if ( (LA28_0=='r') ) {s = 11;} + + else if ( (LA28_0=='m') ) {s = 12;} + + else if ( (LA28_0=='u') ) {s = 13;} + + else if ( (LA28_0=='B') ) {s = 14;} + + else if ( (LA28_0=='I') ) {s = 15;} + + else if ( (LA28_0=='i') ) {s = 16;} + + else if ( (LA28_0=='D') ) {s = 17;} + + else if ( (LA28_0=='H') ) {s = 18;} + + else if ( (LA28_0=='S') ) {s = 19;} + + else if ( (LA28_0=='b') ) {s = 20;} + + else if ( (LA28_0=='g') ) {s = 21;} + + else if ( (LA28_0=='n') ) {s = 22;} + + else if ( (LA28_0=='t') ) {s = 23;} + + else if ( (LA28_0=='v') ) {s = 24;} + + else if ( (LA28_0=='L') ) {s = 25;} + + else if ( (LA28_0=='[') ) {s = 26;} + + else if ( (LA28_0==',') ) {s = 27;} + + else if ( (LA28_0==':') ) {s = 28;} + + else if ( (LA28_0==']') ) {s = 29;} + + else if ( (LA28_0=='}') ) {s = 30;} + + else if ( (LA28_0=='#') ) {s = 31;} + + else if ( (LA28_0=='/') ) {s = 32;} + + else if ( (LA28_0=='^') ) {s = 33;} + + else if ( (LA28_0=='C'||LA28_0=='F'||(LA28_0>='J' && LA28_0<='K')||(LA28_0>='M' && LA28_0<='O')||LA28_0=='Q'||(LA28_0>='T' && LA28_0<='Z')||LA28_0=='_'||LA28_0=='c'||LA28_0=='e'||LA28_0=='h'||(LA28_0>='j' && LA28_0<='l')||LA28_0=='o'||LA28_0=='q'||(LA28_0>='w' && LA28_0<='z')) ) {s = 34;} + + else if ( (LA28_0=='\"') ) {s = 36;} + + else if ( (LA28_0=='\'') ) {s = 37;} + + else if ( (LA28_0=='~') ) {s = 38;} + + else if ( (LA28_0=='0') ) {s = 39;} + + else if ( ((LA28_0>='1' && LA28_0<='2')) ) {s = 40;} + + else if ( (LA28_0=='-') ) {s = 41;} + + else if ( ((LA28_0>='3' && LA28_0<='9')) ) {s = 42;} + + else if ( ((LA28_0>='\t' && LA28_0<='\n')||LA28_0=='\r'||LA28_0==' ') ) {s = 43;} + + else if ( ((LA28_0>='\u0000' && LA28_0<='\b')||(LA28_0>='\u000B' && LA28_0<='\f')||(LA28_0>='\u000E' && LA28_0<='\u001F')||LA28_0=='!'||(LA28_0>='$' && LA28_0<='&')||(LA28_0>='(' && LA28_0<='+')||LA28_0=='.'||(LA28_0>=';' && LA28_0<='@')||LA28_0=='\\'||LA28_0=='`'||(LA28_0>='{' && LA28_0<='|')||(LA28_0>='\u007F' && LA28_0<='\uFFFF')) ) {s = 44;} + + else s = 35; + + if ( s>=0 ) return s; + break; + case 4 : + int LA28_166 = input.LA(1); + + s = -1; + if ( (LA28_166=='\"') ) {s = 107;} + + else if ( (LA28_166=='\\') ) {s = 105;} + + else if ( ((LA28_166>='\u0000' && LA28_166<='!')||(LA28_166>='#' && LA28_166<='[')||(LA28_166>=']' && LA28_166<='\uFFFF')) ) {s = 106;} + + if ( s>=0 ) return s; + break; + case 5 : + int LA28_106 = input.LA(1); + + s = -1; + if ( (LA28_106=='\"') ) {s = 107;} + + else if ( (LA28_106=='\\') ) {s = 105;} + + else if ( ((LA28_106>='\u0000' && LA28_106<='!')||(LA28_106>='#' && LA28_106<='[')||(LA28_106>=']' && LA28_106<='\uFFFF')) ) {s = 106;} + + if ( s>=0 ) return s; + break; + case 6 : + int LA28_36 = input.LA(1); + + s = -1; + if ( (LA28_36=='\\') ) {s = 105;} + + else if ( ((LA28_36>='\u0000' && LA28_36<='!')||(LA28_36>='#' && LA28_36<='[')||(LA28_36>=']' && LA28_36<='\uFFFF')) ) {s = 106;} + + else if ( (LA28_36=='\"') ) {s = 107;} + + else s = 44; + + if ( s>=0 ) return s; + break; + case 7 : + int LA28_168 = input.LA(1); + + s = -1; + if ( (LA28_168=='\'') ) {s = 110;} + + else if ( (LA28_168=='\\') ) {s = 108;} + + else if ( ((LA28_168>='\u0000' && LA28_168<='&')||(LA28_168>='(' && LA28_168<='[')||(LA28_168>=']' && LA28_168<='\uFFFF')) ) {s = 109;} + + if ( s>=0 ) return s; + break; + case 8 : + int LA28_109 = input.LA(1); + + s = -1; + if ( (LA28_109=='\'') ) {s = 110;} + + else if ( (LA28_109=='\\') ) {s = 108;} + + else if ( ((LA28_109>='\u0000' && LA28_109<='&')||(LA28_109>='(' && LA28_109<='[')||(LA28_109>=']' && LA28_109<='\uFFFF')) ) {s = 109;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 28, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/lexer/InternalRosLexer.tokens b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/lexer/InternalRosLexer.tokens new file mode 100644 index 000000000..135670e45 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/lexer/InternalRosLexer.tokens @@ -0,0 +1,110 @@ +Action=53 +Action_1=36 +Actionclient=11 +Actionserver=12 +AmentPackage=14 +Any=83 +Array=47 +Artifacts=20 +Base64=48 +Bool=73 +Bool_1=54 +Boolean=34 +Byte=74 +Byte_1=55 +Colon=87 +Comma=86 +Date=71 +Default=37 +Dependencies=13 +Double=49 +Duration=26 +ExternalDependency=5 +Feedback=27 +Feedback_1=22 +Float32=38 +Float32_1=23 +Float64=39 +Float64_1=24 +FromGitRepo=16 +GlobalNamespace=8 +Goal=75 +Goal_1=63 +GraphName=21 +Header=50 +Int16=64 +Int16_1=40 +Int32=65 +Int32_1=41 +Int64=66 +Int64_1=42 +Int8=76 +Int8_1=56 +Integer=35 +LeftSquareBracket=88 +LeftSquareBracketRightSquareBracket=85 +List=72 +Message=43 +Message_1=28 +Msg=77 +Name=78 +Node=79 +Node_1=67 +Ns=84 +ParameterAny=15 +ParameterStructMember=4 +Parameters=18 +PrivateNamespace=7 +Publishers=19 +RULE_ANY_OTHER=113 +RULE_BEGIN=91 +RULE_BINARY=99 +RULE_BOOLEAN=100 +RULE_DATE_TIME=108 +RULE_DAY=103 +RULE_DECINT=101 +RULE_DIGIT=98 +RULE_DOUBLE=102 +RULE_END=92 +RULE_HOUR=106 +RULE_ID=94 +RULE_INT=109 +RULE_MESSAGE_ASIGMENT=110 +RULE_MIN_SEC=107 +RULE_ML_COMMENT=111 +RULE_MONTH=104 +RULE_ROS_CONVENTION_A=95 +RULE_ROS_CONVENTION_PARAM=97 +RULE_SL_COMMENT=93 +RULE_STRING=96 +RULE_WS=112 +RULE_YEAR=105 +RelativeNamespace=6 +Request=29 +Response=25 +Result=57 +Result_1=44 +RightCurlyBracket=90 +RightSquareBracket=89 +Service=45 +Serviceclient=9 +Serviceserver=10 +Specs=58 +Srv=80 +String=51 +String_1=59 +String_2=30 +Struct=52 +Subscribers=17 +Time=81 +Type=82 +Type_1=68 +Uint16=60 +Uint16_1=31 +Uint32=61 +Uint32_1=32 +Uint64=62 +Uint64_1=33 +Uint8=69 +Uint8_1=46 +Value=70 diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/serializer/RosSemanticSequencer.java b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/serializer/RosSemanticSequencer.java index cd1aff643..10437f946 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/serializer/RosSemanticSequencer.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/serializer/RosSemanticSequencer.java @@ -376,17 +376,10 @@ protected void sequence_ActionSpec(ISerializationContext context, ActionSpec sem /** * Contexts: - * Package returns AmentPackage * AmentPackage returns AmentPackage * * Constraint: - * ( - * name=RosNames - * fromGitRepo=EString? - * (dependency+=Dependency dependency+=Dependency*)? - * (spec+=SpecBase spec+=SpecBase*)? - * (artifact+=Artifact artifact+=Artifact*)? - * ) + * (name=RosNames fromGitRepo=EString? artifact+=Artifact* (dependency+=Dependency dependency+=Dependency*)?) */ protected void sequence_AmentPackage(ISerializationContext context, AmentPackage semanticObject) { genericSequencer.createSequence(context, semanticObject); @@ -426,17 +419,10 @@ protected void sequence_Artifact(ISerializationContext context, Artifact semanti /** * Contexts: - * Package returns CatkinPackage * CatkinPackage returns CatkinPackage * * Constraint: - * ( - * name=RosNames - * fromGitRepo=EString? - * (dependency+=Dependency dependency+=Dependency*)? - * (spec+=SpecBase spec+=SpecBase*)? - * (artifact+=Artifact artifact+=Artifact*)? - * ) + * (name=RosNames fromGitRepo=EString? artifact+=Artifact* (dependency+=Dependency dependency+=Dependency*)?) */ protected void sequence_CatkinPackage(ISerializationContext context, CatkinPackage semanticObject) { genericSequencer.createSequence(context, semanticObject); @@ -493,7 +479,7 @@ protected void sequence_Header(ISerializationContext context, Header semanticObj * MessageDefinition returns MessageDefinition * * Constraint: - * (MessagePart+=MessagePart MessagePart+=MessagePart*)? + * MessagePart+=MessagePart* */ protected void sequence_MessageDefinition(ISerializationContext context, MessageDefinition semanticObject) { genericSequencer.createSequence(context, semanticObject); @@ -519,13 +505,15 @@ protected void sequence_MessagePart(ISerializationContext context, MessagePart s * Constraint: * ( * name=RosNames - * (serviceserver+=ServiceServer serviceserver+=ServiceServer*)? - * (publisher+=Publisher publisher+=Publisher*)? - * (subscriber+=Subscriber subscriber+=Subscriber*)? - * (serviceclient+=ServiceClient serviceclient+=ServiceClient*)? - * (actionserver+=ActionServer actionserver+=ActionServer*)? - * (actionclient+=ActionClient actionclient+=ActionClient*)? - * (parameter+=Parameter parameter+=Parameter*)? + * ( + * publisher+=Publisher | + * subscriber+=Subscriber | + * serviceserver+=ServiceServer | + * serviceclient+=ServiceClient | + * actionserver+=ActionServer | + * actionclient+=ActionClient | + * parameter+=Parameter + * )* * ) */ protected void sequence_Node(ISerializationContext context, Node semanticObject) { @@ -557,7 +545,7 @@ protected void sequence_PackageDependency(ISerializationContext context, Package * PackageSet returns PackageSet * * Constraint: - * (package+=Package package+=Package*)? + * package+=Package_Impl* */ protected void sequence_PackageSet(ISerializationContext context, PackageSet semanticObject) { genericSequencer.createSequence(context, semanticObject); @@ -570,7 +558,7 @@ protected void sequence_PackageSet(ISerializationContext context, PackageSet sem * Package_Impl returns Package * * Constraint: - * (name=EString fromGitRepo=EString? (spec+=SpecBase spec+=SpecBase*)? (artifact+=Artifact artifact+=Artifact*)?) + * (name=RosNames fromGitRepo=EString? spec+=SpecBase* (dependency+=Dependency dependency+=Dependency*)?) */ protected void sequence_Package_Impl(ISerializationContext context, ros.Package semanticObject) { genericSequencer.createSequence(context, semanticObject); @@ -903,7 +891,7 @@ protected void sequence_ParameterStruct(ISerializationContext context, Parameter * Parameter returns Parameter * * Constraint: - * (name=EString namespace=Namespace? type=ParameterType) + * (name=EString type=ParameterType namespace=Namespace?) */ protected void sequence_Parameter(ISerializationContext context, ros.Parameter semanticObject) { genericSequencer.createSequence(context, semanticObject); diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/serializer/RosSyntacticSequencer.java b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/serializer/RosSyntacticSequencer.java index 8e62e78ec..96824d2bb 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/serializer/RosSyntacticSequencer.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/serializer/RosSyntacticSequencer.java @@ -11,6 +11,10 @@ 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.AlternativeAlias; +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; @@ -18,17 +22,250 @@ public class RosSyntacticSequencer extends AbstractSyntacticSequencer { protected RosGrammarAccess grammarAccess; + protected AbstractElementAlias match_AmentPackage___ArtifactsKeyword_6_0_BEGINTerminalRuleCall_6_1_ENDTerminalRuleCall_6_3__q; + protected AbstractElementAlias match_CatkinPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q; + protected AbstractElementAlias match_Node___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q; @Inject protected void init(IGrammarAccess access) { grammarAccess = (RosGrammarAccess) access; + match_AmentPackage___ArtifactsKeyword_6_0_BEGINTerminalRuleCall_6_1_ENDTerminalRuleCall_6_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getAmentPackageAccess().getArtifactsKeyword_6_0()), new TokenAlias(false, false, grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_6_1()), new TokenAlias(false, false, grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_6_3())); + 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___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()), new TokenAlias(false, false, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()), new TokenAlias(false, false, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_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) { @@ -36,8 +273,2576 @@ protected void emitUnassignedTokens(EObject semanticObject, ISynTransition trans List transitionNodes = collectNodes(fromNode, toNode); for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) { List syntaxNodes = getNodesFor(transitionNodes, syntax); - acceptNodes(getLastNavigableState(), syntaxNodes); + if (match_AmentPackage___ArtifactsKeyword_6_0_BEGINTerminalRuleCall_6_1_ENDTerminalRuleCall_6_3__q.equals(syntax)) + emit_AmentPackage___ArtifactsKeyword_6_0_BEGINTerminalRuleCall_6_1_ENDTerminalRuleCall_6_3__q(semanticObject, getLastNavigableState(), syntaxNodes); + else 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___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a.equals(syntax)) + emit_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q.equals(syntax)) + emit_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_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_AmentPackage___ArtifactsKeyword_6_0_BEGINTerminalRuleCall_6_1_ENDTerminalRuleCall_6_3__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 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: + * ( + * 'actionclient:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'actionserver:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + * publisher+=Publisher (ambiguity) publisher+=Publisher + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + * subscriber+=Subscriber (ambiguity) subscriber+=Subscriber + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + * serviceserver+=ServiceServer (ambiguity) serviceserver+=ServiceServer + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + * serviceclient+=ServiceClient (ambiguity) serviceclient+=ServiceClient + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + * actionserver+=ActionServer (ambiguity) actionserver+=ActionServer + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))* + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + * actionclient+=ActionClient (ambiguity) actionclient+=ActionClient + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) + * )* + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))* + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + * parameter+=Parameter (ambiguity) parameter+=Parameter + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'parameters:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'publishers:' + * BEGIN + * END + * ( + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'serviceclient:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'serviceserver:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'subscribers:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + * subscriber+=Subscriber END (ambiguity) ('subscribers:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + * serviceserver+=ServiceServer END (ambiguity) ('serviceserver:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + * serviceclient+=ServiceClient END (ambiguity) ('serviceclient:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + * publisher+=Publisher END (ambiguity) ('publishers:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + * parameter+=Parameter END (ambiguity) ('parameters:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) ('actionserver:' BEGIN END (ambiguity))* END (rule end) + * name=RosNames BEGIN (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) ('actionclient:' BEGIN END (ambiguity))* END (rule end) + * name=RosNames BEGIN (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ('specs:' 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_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + } diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/services/RosGrammarAccess.java b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/services/RosGrammarAccess.java index e5a1f9323..373867fa5 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/services/RosGrammarAccess.java +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/services/RosGrammarAccess.java @@ -28,224 +28,167 @@ public class PackageSetElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.PackageSet"); private final Group cGroup = (Group)rule.eContents().get(1); private final Action cPackageSetAction_0 = (Action)cGroup.eContents().get(0); - private final Keyword cPackageSetKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Group cGroup_3 = (Group)cGroup.eContents().get(3); - private final Assignment cPackageAssignment_3_0 = (Assignment)cGroup_3.eContents().get(0); - private final RuleCall cPackagePackageParserRuleCall_3_0_0 = (RuleCall)cPackageAssignment_3_0.eContents().get(0); - private final Group cGroup_3_1 = (Group)cGroup_3.eContents().get(1); - private final Keyword cCommaKeyword_3_1_0 = (Keyword)cGroup_3_1.eContents().get(0); - private final Assignment cPackageAssignment_3_1_1 = (Assignment)cGroup_3_1.eContents().get(1); - private final RuleCall cPackagePackageParserRuleCall_3_1_1_0 = (RuleCall)cPackageAssignment_3_1_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Assignment cPackageAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cPackagePackage_ImplParserRuleCall_1_0 = (RuleCall)cPackageAssignment_1.eContents().get(0); //PackageSet returns PackageSet: // {PackageSet} - // 'PackageSet' - // '{' - // (package+=Package ( "," package+=Package)* )? - // '}'; + // package+=Package_Impl* + // ; @Override public ParserRule getRule() { return rule; } //{PackageSet} - //'PackageSet' - //'{' - // (package+=Package ( "," package+=Package)* )? - //'}' + //package+=Package_Impl* public Group getGroup() { return cGroup; } //{PackageSet} public Action getPackageSetAction_0() { return cPackageSetAction_0; } - //'PackageSet' - public Keyword getPackageSetKeyword_1() { return cPackageSetKeyword_1; } - - //'{' - public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; } - - //(package+=Package ( "," package+=Package)* )? - public Group getGroup_3() { return cGroup_3; } - - //package+=Package - public Assignment getPackageAssignment_3_0() { return cPackageAssignment_3_0; } - - //Package - public RuleCall getPackagePackageParserRuleCall_3_0_0() { return cPackagePackageParserRuleCall_3_0_0; } - - //( "," package+=Package)* - public Group getGroup_3_1() { return cGroup_3_1; } - - //"," - public Keyword getCommaKeyword_3_1_0() { return cCommaKeyword_3_1_0; } - - //package+=Package - public Assignment getPackageAssignment_3_1_1() { return cPackageAssignment_3_1_1; } - - //Package - public RuleCall getPackagePackageParserRuleCall_3_1_1_0() { return cPackagePackageParserRuleCall_3_1_1_0; } - - //'}' - public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; } - } - public class PackageElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Package"); - private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); - private final RuleCall cPackage_ImplParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); - private final RuleCall cCatkinPackageParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); - private final RuleCall cAmentPackageParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); - - //Package returns Package: - // Package_Impl | CatkinPackage | AmentPackage; - @Override public ParserRule getRule() { return rule; } - - //Package_Impl | CatkinPackage | AmentPackage - public Alternatives getAlternatives() { return cAlternatives; } + //package+=Package_Impl* + public Assignment getPackageAssignment_1() { return cPackageAssignment_1; } //Package_Impl - public RuleCall getPackage_ImplParserRuleCall_0() { return cPackage_ImplParserRuleCall_0; } - - //CatkinPackage - public RuleCall getCatkinPackageParserRuleCall_1() { return cCatkinPackageParserRuleCall_1; } - - //AmentPackage - public RuleCall getAmentPackageParserRuleCall_2() { return cAmentPackageParserRuleCall_2; } + public RuleCall getPackagePackage_ImplParserRuleCall_1_0() { return cPackagePackage_ImplParserRuleCall_1_0; } } - public class SpecBaseElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.SpecBase"); + public class EStringElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.EString"); private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); - private final RuleCall cServiceSpecParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); - private final RuleCall cTopicSpecParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); - private final RuleCall cActionSpecParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); + private final RuleCall cSTRINGTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cIDTerminalRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); - //SpecBase returns SpecBase: - // ServiceSpec | TopicSpec | ActionSpec; + ///////////////////// + //// CONVENTIONS AND NAMES + ///////////////////// + //EString returns ecore::EString: + // STRING | ID; @Override public ParserRule getRule() { return rule; } - //ServiceSpec | TopicSpec | ActionSpec + //STRING | ID public Alternatives getAlternatives() { return cAlternatives; } - //ServiceSpec - public RuleCall getServiceSpecParserRuleCall_0() { return cServiceSpecParserRuleCall_0; } - - //TopicSpec - public RuleCall getTopicSpecParserRuleCall_1() { return cTopicSpecParserRuleCall_1; } + //STRING + public RuleCall getSTRINGTerminalRuleCall_0() { return cSTRINGTerminalRuleCall_0; } - //ActionSpec - public RuleCall getActionSpecParserRuleCall_2() { return cActionSpecParserRuleCall_2; } + //ID + public RuleCall getIDTerminalRuleCall_1() { return cIDTerminalRuleCall_1; } } - public class DependencyElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Dependency"); + public class RosNamesElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.RosNames"); 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); + 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); - //Dependency returns Dependency: - // PackageDependency | ExternalDependency; + //RosNames returns ecore::EString: + // ROS_CONVENTION_A | ID | 'node' + //; @Override public ParserRule getRule() { return rule; } - //PackageDependency | ExternalDependency + //ROS_CONVENTION_A | ID | 'node' public Alternatives getAlternatives() { return cAlternatives; } - //PackageDependency - public RuleCall getPackageDependencyParserRuleCall_0() { return cPackageDependencyParserRuleCall_0; } + //ROS_CONVENTION_A + public RuleCall getROS_CONVENTION_ATerminalRuleCall_0() { return cROS_CONVENTION_ATerminalRuleCall_0; } - //ExternalDependency - public RuleCall getExternalDependencyParserRuleCall_1() { return cExternalDependencyParserRuleCall_1; } + //ID + public RuleCall getIDTerminalRuleCall_1() { return cIDTerminalRuleCall_1; } + + //'node' + public Keyword getNodeKeyword_2() { return cNodeKeyword_2; } } - public class NamespaceElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Namespace"); - private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); - private final RuleCall cGlobalNamespaceParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); - private final RuleCall cRelativeNamespace_ImplParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); - private final RuleCall cPrivateNamespaceParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); + public class PackageElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Package"); + private final RuleCall cPackage_ImplParserRuleCall = (RuleCall)rule.eContents().get(1); - //Namespace returns Namespace: - // GlobalNamespace | RelativeNamespace_Impl | PrivateNamespace; + ///////////////////// + ////PACKAGES + ///////////////////// + //Package returns Package: + // Package_Impl //| + // //CatkinPackage | + // //AmentPackage + // ; @Override public ParserRule getRule() { return rule; } - //GlobalNamespace | RelativeNamespace_Impl | PrivateNamespace - public Alternatives getAlternatives() { return cAlternatives; } - - //GlobalNamespace - public RuleCall getGlobalNamespaceParserRuleCall_0() { return cGlobalNamespaceParserRuleCall_0; } - - //RelativeNamespace_Impl - public RuleCall getRelativeNamespace_ImplParserRuleCall_1() { return cRelativeNamespace_ImplParserRuleCall_1; } - - //PrivateNamespace - public RuleCall getPrivateNamespaceParserRuleCall_2() { return cPrivateNamespaceParserRuleCall_2; } + //Package_Impl + public RuleCall getPackage_ImplParserRuleCall() { return cPackage_ImplParserRuleCall; } } public class Package_ImplElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Package_Impl"); private final Group cGroup = (Group)rule.eContents().get(1); private final Action cPackageAction_0 = (Action)cGroup.eContents().get(0); - private final Keyword cPackageKeyword_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); - private final Keyword cLeftCurlyBracketKeyword_3 = (Keyword)cGroup.eContents().get(3); + 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 cSpecsKeyword_5_0 = (Keyword)cGroup_5.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_5_1 = (Keyword)cGroup_5.eContents().get(1); + private final RuleCall cBEGINTerminalRuleCall_5_1 = (RuleCall)cGroup_5.eContents().get(1); private final Assignment cSpecAssignment_5_2 = (Assignment)cGroup_5.eContents().get(2); private final RuleCall cSpecSpecBaseParserRuleCall_5_2_0 = (RuleCall)cSpecAssignment_5_2.eContents().get(0); - private final Group cGroup_5_3 = (Group)cGroup_5.eContents().get(3); - private final Keyword cCommaKeyword_5_3_0 = (Keyword)cGroup_5_3.eContents().get(0); - private final Assignment cSpecAssignment_5_3_1 = (Assignment)cGroup_5_3.eContents().get(1); - private final RuleCall cSpecSpecBaseParserRuleCall_5_3_1_0 = (RuleCall)cSpecAssignment_5_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_5_4 = (Keyword)cGroup_5.eContents().get(4); + private final RuleCall cENDTerminalRuleCall_5_3 = (RuleCall)cGroup_5.eContents().get(3); private final Group cGroup_6 = (Group)cGroup.eContents().get(6); - private final Assignment cArtifactAssignment_6_0 = (Assignment)cGroup_6.eContents().get(0); - private final RuleCall cArtifactArtifactParserRuleCall_6_0_0 = (RuleCall)cArtifactAssignment_6_0.eContents().get(0); - private final Group cGroup_6_1 = (Group)cGroup_6.eContents().get(1); - private final Keyword cCommaKeyword_6_1_0 = (Keyword)cGroup_6_1.eContents().get(0); - private final Assignment cArtifactAssignment_6_1_1 = (Assignment)cGroup_6_1.eContents().get(1); - private final RuleCall cArtifactArtifactParserRuleCall_6_1_1_0 = (RuleCall)cArtifactAssignment_6_1_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_7 = (Keyword)cGroup.eContents().get(7); + 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); //Package_Impl returns Package: // {Package} - // 'Package' - // name=EString - // '{' - // ('FromGitRepo' fromGitRepo=EString)? - // ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - // (artifact+=Artifact ( "," artifact+=Artifact)*)? - // '}'; + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('specs:' + // BEGIN + // spec+=SpecBase* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; @Override public ParserRule getRule() { return rule; } //{Package} - //'Package' - //name=EString - //'{' - // ('FromGitRepo' fromGitRepo=EString)? - // ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - // (artifact+=Artifact ( "," artifact+=Artifact)*)? - //'}' + //name=RosNames':' + //BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('specs:' + // BEGIN + // spec+=SpecBase* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + //END public Group getGroup() { return cGroup; } //{Package} public Action getPackageAction_0() { return cPackageAction_0; } - //'Package' - public Keyword getPackageKeyword_1() { return cPackageKeyword_1; } + //name=RosNames + public Assignment getNameAssignment_1() { return cNameAssignment_1; } - //name=EString - public Assignment getNameAssignment_2() { return cNameAssignment_2; } + //RosNames + public RuleCall getNameRosNamesParserRuleCall_1_0() { return cNameRosNamesParserRuleCall_1_0; } - //EString - public RuleCall getNameEStringParserRuleCall_2_0() { return cNameEStringParserRuleCall_2_0; } + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } - //'{' - public Keyword getLeftCurlyBracketKeyword_3() { return cLeftCurlyBracketKeyword_3; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } - //('FromGitRepo' fromGitRepo=EString)? + //('fromGitRepo:' fromGitRepo=EString)? public Group getGroup_4() { return cGroup_4; } - //'FromGitRepo' + //'fromGitRepo:' public Keyword getFromGitRepoKeyword_4_0() { return cFromGitRepoKeyword_4_0; } //fromGitRepo=EString @@ -254,259 +197,137 @@ public class Package_ImplElements extends AbstractParserRuleElementFinder { //EString public RuleCall getFromGitRepoEStringParserRuleCall_4_1_0() { return cFromGitRepoEStringParserRuleCall_4_1_0; } - //('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? + //('specs:' + // BEGIN + // spec+=SpecBase* + // END + //)? public Group getGroup_5() { return cGroup_5; } - //'Specs' + //'specs:' public Keyword getSpecsKeyword_5_0() { return cSpecsKeyword_5_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_5_1() { return cLeftCurlyBracketKeyword_5_1; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_5_1() { return cBEGINTerminalRuleCall_5_1; } - //spec+=SpecBase + //spec+=SpecBase* public Assignment getSpecAssignment_5_2() { return cSpecAssignment_5_2; } //SpecBase public RuleCall getSpecSpecBaseParserRuleCall_5_2_0() { return cSpecSpecBaseParserRuleCall_5_2_0; } - //( "," spec+=SpecBase)* - public Group getGroup_5_3() { return cGroup_5_3; } - - //"," - public Keyword getCommaKeyword_5_3_0() { return cCommaKeyword_5_3_0; } + //END + public RuleCall getENDTerminalRuleCall_5_3() { return cENDTerminalRuleCall_5_3; } - //spec+=SpecBase - public Assignment getSpecAssignment_5_3_1() { return cSpecAssignment_5_3_1; } - - //SpecBase - public RuleCall getSpecSpecBaseParserRuleCall_5_3_1_0() { return cSpecSpecBaseParserRuleCall_5_3_1_0; } - - //'}' - public Keyword getRightCurlyBracketKeyword_5_4() { return cRightCurlyBracketKeyword_5_4; } - - //(artifact+=Artifact ( "," artifact+=Artifact)*)? + //('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? public Group getGroup_6() { return cGroup_6; } - //artifact+=Artifact - public Assignment getArtifactAssignment_6_0() { return cArtifactAssignment_6_0; } - - //Artifact - public RuleCall getArtifactArtifactParserRuleCall_6_0_0() { return cArtifactArtifactParserRuleCall_6_0_0; } + //'dependencies:' + public Keyword getDependenciesKeyword_6_0() { return cDependenciesKeyword_6_0; } - //( "," artifact+=Artifact)* - public Group getGroup_6_1() { return cGroup_6_1; } + //'[' + public Keyword getLeftSquareBracketKeyword_6_1() { return cLeftSquareBracketKeyword_6_1; } - //"," - public Keyword getCommaKeyword_6_1_0() { return cCommaKeyword_6_1_0; } - - //artifact+=Artifact - public Assignment getArtifactAssignment_6_1_1() { return cArtifactAssignment_6_1_1; } - - //Artifact - public RuleCall getArtifactArtifactParserRuleCall_6_1_1_0() { return cArtifactArtifactParserRuleCall_6_1_1_0; } - - //'}' - public Keyword getRightCurlyBracketKeyword_7() { return cRightCurlyBracketKeyword_7; } - } - public class EStringElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.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 RosNamesElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.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 RosParamNamesElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.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; } - } - public class ArtifactElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Artifact"); - private final Group cGroup = (Group)rule.eContents().get(1); - private final Action cArtifactAction_0 = (Action)cGroup.eContents().get(0); - private final Keyword cArtifactKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); - private final RuleCall cNameRosNamesParserRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_3 = (Keyword)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 Keyword cRightCurlyBracketKeyword_5 = (Keyword)cGroup.eContents().get(5); - - //Artifact returns Artifact: - // {Artifact} - // 'Artifact' - // name=RosNames - // '{' - // (node=Node)? - // '}'; - @Override public ParserRule getRule() { return rule; } - - //{Artifact} - //'Artifact' - //name=RosNames - //'{' - // (node=Node)? - //'}' - public Group getGroup() { return cGroup; } - - //{Artifact} - public Action getArtifactAction_0() { return cArtifactAction_0; } + //dependency+=Dependency + public Assignment getDependencyAssignment_6_2() { return cDependencyAssignment_6_2; } - //'Artifact' - public Keyword getArtifactKeyword_1() { return cArtifactKeyword_1; } + //Dependency + public RuleCall getDependencyDependencyParserRuleCall_6_2_0() { return cDependencyDependencyParserRuleCall_6_2_0; } - //name=RosNames - public Assignment getNameAssignment_2() { return cNameAssignment_2; } + //(',' dependency+=Dependency)* + public Group getGroup_6_3() { return cGroup_6_3; } - //RosNames - public RuleCall getNameRosNamesParserRuleCall_2_0() { return cNameRosNamesParserRuleCall_2_0; } + //',' + public Keyword getCommaKeyword_6_3_0() { return cCommaKeyword_6_3_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_3() { return cLeftCurlyBracketKeyword_3; } + //dependency+=Dependency + public Assignment getDependencyAssignment_6_3_1() { return cDependencyAssignment_6_3_1; } - //(node=Node)? - public Assignment getNodeAssignment_4() { return cNodeAssignment_4; } + //Dependency + public RuleCall getDependencyDependencyParserRuleCall_6_3_1_0() { return cDependencyDependencyParserRuleCall_6_3_1_0; } - //Node - public RuleCall getNodeNodeParserRuleCall_4_0() { return cNodeNodeParserRuleCall_4_0; } + //']' + public Keyword getRightSquareBracketKeyword_6_4() { return cRightSquareBracketKeyword_6_4; } - //'}' - public Keyword getRightCurlyBracketKeyword_5() { return cRightCurlyBracketKeyword_5; } + //END + public RuleCall getENDTerminalRuleCall_7() { return cENDTerminalRuleCall_7; } } public class CatkinPackageElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.CatkinPackage"); private final Group cGroup = (Group)rule.eContents().get(1); private final Action cCatkinPackageAction_0 = (Action)cGroup.eContents().get(0); - private final Keyword cCatkinPackageKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); - private final RuleCall cNameRosNamesParserRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_3 = (Keyword)cGroup.eContents().get(3); + 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 cDependenciesKeyword_5_0 = (Keyword)cGroup_5.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_5_1 = (Keyword)cGroup_5.eContents().get(1); - private final Assignment cDependencyAssignment_5_2 = (Assignment)cGroup_5.eContents().get(2); - private final RuleCall cDependencyDependencyParserRuleCall_5_2_0 = (RuleCall)cDependencyAssignment_5_2.eContents().get(0); - private final Group cGroup_5_3 = (Group)cGroup_5.eContents().get(3); - private final Keyword cCommaKeyword_5_3_0 = (Keyword)cGroup_5_3.eContents().get(0); - private final Assignment cDependencyAssignment_5_3_1 = (Assignment)cGroup_5_3.eContents().get(1); - private final RuleCall cDependencyDependencyParserRuleCall_5_3_1_0 = (RuleCall)cDependencyAssignment_5_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_5_4 = (Keyword)cGroup_5.eContents().get(4); + 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 cSpecsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_6_1 = (Keyword)cGroup_6.eContents().get(1); - private final Assignment cSpecAssignment_6_2 = (Assignment)cGroup_6.eContents().get(2); - private final RuleCall cSpecSpecBaseParserRuleCall_6_2_0 = (RuleCall)cSpecAssignment_6_2.eContents().get(0); + 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 cSpecAssignment_6_3_1 = (Assignment)cGroup_6_3.eContents().get(1); - private final RuleCall cSpecSpecBaseParserRuleCall_6_3_1_0 = (RuleCall)cSpecAssignment_6_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_6_4 = (Keyword)cGroup_6.eContents().get(4); - private final Group cGroup_7 = (Group)cGroup.eContents().get(7); - private final Assignment cArtifactAssignment_7_0 = (Assignment)cGroup_7.eContents().get(0); - private final RuleCall cArtifactArtifactParserRuleCall_7_0_0 = (RuleCall)cArtifactAssignment_7_0.eContents().get(0); - private final Group cGroup_7_1 = (Group)cGroup_7.eContents().get(1); - private final Keyword cCommaKeyword_7_1_0 = (Keyword)cGroup_7_1.eContents().get(0); - private final Assignment cArtifactAssignment_7_1_1 = (Assignment)cGroup_7_1.eContents().get(1); - private final RuleCall cArtifactArtifactParserRuleCall_7_1_1_0 = (RuleCall)cArtifactAssignment_7_1_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_8 = (Keyword)cGroup.eContents().get(8); + 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 CatkinPackage: // {CatkinPackage} - // 'CatkinPackage' - // name=RosNames - // '{' - // ('FromGitRepo' fromGitRepo=EString)? - // ('Dependencies' '{' dependency+=Dependency ( "," dependency+=Dependency)* '}' )? - // ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - // (artifact+=Artifact ( "," artifact+=Artifact)*)? - // '}'; + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; @Override public ParserRule getRule() { return rule; } //{CatkinPackage} - //'CatkinPackage' - //name=RosNames - //'{' - // ('FromGitRepo' fromGitRepo=EString)? - // ('Dependencies' '{' dependency+=Dependency ( "," dependency+=Dependency)* '}' )? - // ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - // (artifact+=Artifact ( "," artifact+=Artifact)*)? - //'}' + //name=RosNames':' + //BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + //END public Group getGroup() { return cGroup; } //{CatkinPackage} public Action getCatkinPackageAction_0() { return cCatkinPackageAction_0; } - //'CatkinPackage' - public Keyword getCatkinPackageKeyword_1() { return cCatkinPackageKeyword_1; } - //name=RosNames - public Assignment getNameAssignment_2() { return cNameAssignment_2; } + public Assignment getNameAssignment_1() { return cNameAssignment_1; } //RosNames - public RuleCall getNameRosNamesParserRuleCall_2_0() { return cNameRosNamesParserRuleCall_2_0; } + public RuleCall getNameRosNamesParserRuleCall_1_0() { return cNameRosNamesParserRuleCall_1_0; } + + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } - //'{' - public Keyword getLeftCurlyBracketKeyword_3() { return cLeftCurlyBracketKeyword_3; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } - //('FromGitRepo' fromGitRepo=EString)? + //('fromGitRepo:' fromGitRepo=EString)? public Group getGroup_4() { return cGroup_4; } - //'FromGitRepo' + //'fromGitRepo:' public Keyword getFromGitRepoKeyword_4_0() { return cFromGitRepoKeyword_4_0; } //fromGitRepo=EString @@ -515,89 +336,60 @@ public class CatkinPackageElements extends AbstractParserRuleElementFinder { //EString public RuleCall getFromGitRepoEStringParserRuleCall_4_1_0() { return cFromGitRepoEStringParserRuleCall_4_1_0; } - //('Dependencies' '{' dependency+=Dependency ( "," dependency+=Dependency)* '}' )? + //('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + //)? public Group getGroup_5() { return cGroup_5; } - //'Dependencies' - public Keyword getDependenciesKeyword_5_0() { return cDependenciesKeyword_5_0; } + //'artifacts:' + public Keyword getArtifactsKeyword_5_0() { return cArtifactsKeyword_5_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_5_1() { return cLeftCurlyBracketKeyword_5_1; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_5_1() { return cBEGINTerminalRuleCall_5_1; } - //dependency+=Dependency - public Assignment getDependencyAssignment_5_2() { return cDependencyAssignment_5_2; } - - //Dependency - public RuleCall getDependencyDependencyParserRuleCall_5_2_0() { return cDependencyDependencyParserRuleCall_5_2_0; } - - //( "," dependency+=Dependency)* - public Group getGroup_5_3() { return cGroup_5_3; } - - //"," - public Keyword getCommaKeyword_5_3_0() { return cCommaKeyword_5_3_0; } - - //dependency+=Dependency - public Assignment getDependencyAssignment_5_3_1() { return cDependencyAssignment_5_3_1; } + //artifact+=Artifact* + public Assignment getArtifactAssignment_5_2() { return cArtifactAssignment_5_2; } - //Dependency - public RuleCall getDependencyDependencyParserRuleCall_5_3_1_0() { return cDependencyDependencyParserRuleCall_5_3_1_0; } + //Artifact + public RuleCall getArtifactArtifactParserRuleCall_5_2_0() { return cArtifactArtifactParserRuleCall_5_2_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_5_4() { return cRightCurlyBracketKeyword_5_4; } + //END + public RuleCall getENDTerminalRuleCall_5_3() { return cENDTerminalRuleCall_5_3; } - //('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? + //('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? public Group getGroup_6() { return cGroup_6; } - //'Specs' - public Keyword getSpecsKeyword_6_0() { return cSpecsKeyword_6_0; } + //'dependencies:' + public Keyword getDependenciesKeyword_6_0() { return cDependenciesKeyword_6_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_6_1() { return cLeftCurlyBracketKeyword_6_1; } + //'[' + public Keyword getLeftSquareBracketKeyword_6_1() { return cLeftSquareBracketKeyword_6_1; } - //spec+=SpecBase - public Assignment getSpecAssignment_6_2() { return cSpecAssignment_6_2; } + //dependency+=Dependency + public Assignment getDependencyAssignment_6_2() { return cDependencyAssignment_6_2; } - //SpecBase - public RuleCall getSpecSpecBaseParserRuleCall_6_2_0() { return cSpecSpecBaseParserRuleCall_6_2_0; } + //Dependency + public RuleCall getDependencyDependencyParserRuleCall_6_2_0() { return cDependencyDependencyParserRuleCall_6_2_0; } - //( "," spec+=SpecBase)* + //(',' dependency+=Dependency)* public Group getGroup_6_3() { return cGroup_6_3; } - //"," + //',' public Keyword getCommaKeyword_6_3_0() { return cCommaKeyword_6_3_0; } - //spec+=SpecBase - public Assignment getSpecAssignment_6_3_1() { return cSpecAssignment_6_3_1; } - - //SpecBase - public RuleCall getSpecSpecBaseParserRuleCall_6_3_1_0() { return cSpecSpecBaseParserRuleCall_6_3_1_0; } - - //'}' - public Keyword getRightCurlyBracketKeyword_6_4() { return cRightCurlyBracketKeyword_6_4; } - - //(artifact+=Artifact ( "," artifact+=Artifact)*)? - public Group getGroup_7() { return cGroup_7; } - - //artifact+=Artifact - public Assignment getArtifactAssignment_7_0() { return cArtifactAssignment_7_0; } - - //Artifact - public RuleCall getArtifactArtifactParserRuleCall_7_0_0() { return cArtifactArtifactParserRuleCall_7_0_0; } - - //( "," artifact+=Artifact)* - public Group getGroup_7_1() { return cGroup_7_1; } - - //"," - public Keyword getCommaKeyword_7_1_0() { return cCommaKeyword_7_1_0; } + //dependency+=Dependency + public Assignment getDependencyAssignment_6_3_1() { return cDependencyAssignment_6_3_1; } - //artifact+=Artifact - public Assignment getArtifactAssignment_7_1_1() { return cArtifactAssignment_7_1_1; } + //Dependency + public RuleCall getDependencyDependencyParserRuleCall_6_3_1_0() { return cDependencyDependencyParserRuleCall_6_3_1_0; } - //Artifact - public RuleCall getArtifactArtifactParserRuleCall_7_1_1_0() { return cArtifactArtifactParserRuleCall_7_1_1_0; } + //']' + public Keyword getRightSquareBracketKeyword_6_4() { return cRightSquareBracketKeyword_6_4; } - //'}' - public Keyword getRightCurlyBracketKeyword_8() { return cRightCurlyBracketKeyword_8; } + //END + public RuleCall getENDTerminalRuleCall_7() { return cENDTerminalRuleCall_7; } } public class AmentPackageElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.AmentPackage"); @@ -606,61 +398,57 @@ public class AmentPackageElements extends AbstractParserRuleElementFinder { private final Keyword cAmentPackageKeyword_1 = (Keyword)cGroup.eContents().get(1); private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); private final RuleCall cNameRosNamesParserRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_3 = (Keyword)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 Keyword cColonKeyword_3 = (Keyword)cGroup.eContents().get(3); + private final RuleCall cBEGINTerminalRuleCall_4 = (RuleCall)cGroup.eContents().get(4); private final Group cGroup_5 = (Group)cGroup.eContents().get(5); - private final Keyword cDependenciesKeyword_5_0 = (Keyword)cGroup_5.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_5_1 = (Keyword)cGroup_5.eContents().get(1); - private final Assignment cDependencyAssignment_5_2 = (Assignment)cGroup_5.eContents().get(2); - private final RuleCall cDependencyDependencyParserRuleCall_5_2_0 = (RuleCall)cDependencyAssignment_5_2.eContents().get(0); - private final Group cGroup_5_3 = (Group)cGroup_5.eContents().get(3); - private final Keyword cCommaKeyword_5_3_0 = (Keyword)cGroup_5_3.eContents().get(0); - private final Assignment cDependencyAssignment_5_3_1 = (Assignment)cGroup_5_3.eContents().get(1); - private final RuleCall cDependencyDependencyParserRuleCall_5_3_1_0 = (RuleCall)cDependencyAssignment_5_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_5_4 = (Keyword)cGroup_5.eContents().get(4); + private final Keyword cFromGitRepoKeyword_5_0 = (Keyword)cGroup_5.eContents().get(0); + private final Assignment cFromGitRepoAssignment_5_1 = (Assignment)cGroup_5.eContents().get(1); + private final RuleCall cFromGitRepoEStringParserRuleCall_5_1_0 = (RuleCall)cFromGitRepoAssignment_5_1.eContents().get(0); private final Group cGroup_6 = (Group)cGroup.eContents().get(6); - private final Keyword cSpecsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_6_1 = (Keyword)cGroup_6.eContents().get(1); - private final Assignment cSpecAssignment_6_2 = (Assignment)cGroup_6.eContents().get(2); - private final RuleCall cSpecSpecBaseParserRuleCall_6_2_0 = (RuleCall)cSpecAssignment_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 cSpecAssignment_6_3_1 = (Assignment)cGroup_6_3.eContents().get(1); - private final RuleCall cSpecSpecBaseParserRuleCall_6_3_1_0 = (RuleCall)cSpecAssignment_6_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_6_4 = (Keyword)cGroup_6.eContents().get(4); + private final Keyword cArtifactsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_6_1 = (RuleCall)cGroup_6.eContents().get(1); + private final Assignment cArtifactAssignment_6_2 = (Assignment)cGroup_6.eContents().get(2); + private final RuleCall cArtifactArtifactParserRuleCall_6_2_0 = (RuleCall)cArtifactAssignment_6_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_6_3 = (RuleCall)cGroup_6.eContents().get(3); private final Group cGroup_7 = (Group)cGroup.eContents().get(7); - private final Assignment cArtifactAssignment_7_0 = (Assignment)cGroup_7.eContents().get(0); - private final RuleCall cArtifactArtifactParserRuleCall_7_0_0 = (RuleCall)cArtifactAssignment_7_0.eContents().get(0); - private final Group cGroup_7_1 = (Group)cGroup_7.eContents().get(1); - private final Keyword cCommaKeyword_7_1_0 = (Keyword)cGroup_7_1.eContents().get(0); - private final Assignment cArtifactAssignment_7_1_1 = (Assignment)cGroup_7_1.eContents().get(1); - private final RuleCall cArtifactArtifactParserRuleCall_7_1_1_0 = (RuleCall)cArtifactAssignment_7_1_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_8 = (Keyword)cGroup.eContents().get(8); + private final Keyword cDependenciesKeyword_7_0 = (Keyword)cGroup_7.eContents().get(0); + private final Keyword cLeftSquareBracketKeyword_7_1 = (Keyword)cGroup_7.eContents().get(1); + private final Assignment cDependencyAssignment_7_2 = (Assignment)cGroup_7.eContents().get(2); + private final RuleCall cDependencyDependencyParserRuleCall_7_2_0 = (RuleCall)cDependencyAssignment_7_2.eContents().get(0); + private final Group cGroup_7_3 = (Group)cGroup_7.eContents().get(3); + private final Keyword cCommaKeyword_7_3_0 = (Keyword)cGroup_7_3.eContents().get(0); + private final Assignment cDependencyAssignment_7_3_1 = (Assignment)cGroup_7_3.eContents().get(1); + private final RuleCall cDependencyDependencyParserRuleCall_7_3_1_0 = (RuleCall)cDependencyAssignment_7_3_1.eContents().get(0); + private final Keyword cRightSquareBracketKeyword_7_4 = (Keyword)cGroup_7.eContents().get(4); + private final RuleCall cENDTerminalRuleCall_8 = (RuleCall)cGroup.eContents().get(8); //AmentPackage returns AmentPackage: // {AmentPackage} // 'AmentPackage' - // name=RosNames - // '{' - // ('FromGitRepo' fromGitRepo=EString)? - // ('Dependencies' '{' dependency+=Dependency ( "," dependency+=Dependency)* '}' )? - // ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - // (artifact+=Artifact ( "," artifact+=Artifact)*)? - // '}'; + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; @Override public ParserRule getRule() { return rule; } //{AmentPackage} //'AmentPackage' - //name=RosNames - //'{' - // ('FromGitRepo' fromGitRepo=EString)? - // ('Dependencies' '{' dependency+=Dependency ( "," dependency+=Dependency)* '}' )? - // ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - // (artifact+=Artifact ( "," artifact+=Artifact)*)? - //'}' + //name=RosNames':' + //BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + //END public Group getGroup() { return cGroup; } //{AmentPackage} @@ -675,805 +463,891 @@ public class AmentPackageElements extends AbstractParserRuleElementFinder { //RosNames public RuleCall getNameRosNamesParserRuleCall_2_0() { return cNameRosNamesParserRuleCall_2_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_3() { return cLeftCurlyBracketKeyword_3; } + //':' + public Keyword getColonKeyword_3() { return cColonKeyword_3; } - //('FromGitRepo' fromGitRepo=EString)? - public Group getGroup_4() { return cGroup_4; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_4() { return cBEGINTerminalRuleCall_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; } - - //('Dependencies' '{' dependency+=Dependency ( "," dependency+=Dependency)* '}' )? + //('fromGitRepo:' fromGitRepo=EString)? public Group getGroup_5() { return cGroup_5; } - //'Dependencies' - public Keyword getDependenciesKeyword_5_0() { return cDependenciesKeyword_5_0; } - - //'{' - public Keyword getLeftCurlyBracketKeyword_5_1() { return cLeftCurlyBracketKeyword_5_1; } - - //dependency+=Dependency - public Assignment getDependencyAssignment_5_2() { return cDependencyAssignment_5_2; } - - //Dependency - public RuleCall getDependencyDependencyParserRuleCall_5_2_0() { return cDependencyDependencyParserRuleCall_5_2_0; } - - //( "," dependency+=Dependency)* - public Group getGroup_5_3() { return cGroup_5_3; } - - //"," - public Keyword getCommaKeyword_5_3_0() { return cCommaKeyword_5_3_0; } + //'fromGitRepo:' + public Keyword getFromGitRepoKeyword_5_0() { return cFromGitRepoKeyword_5_0; } - //dependency+=Dependency - public Assignment getDependencyAssignment_5_3_1() { return cDependencyAssignment_5_3_1; } - - //Dependency - public RuleCall getDependencyDependencyParserRuleCall_5_3_1_0() { return cDependencyDependencyParserRuleCall_5_3_1_0; } + //fromGitRepo=EString + public Assignment getFromGitRepoAssignment_5_1() { return cFromGitRepoAssignment_5_1; } - //'}' - public Keyword getRightCurlyBracketKeyword_5_4() { return cRightCurlyBracketKeyword_5_4; } + //EString + public RuleCall getFromGitRepoEStringParserRuleCall_5_1_0() { return cFromGitRepoEStringParserRuleCall_5_1_0; } - //('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? + //('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + //)? public Group getGroup_6() { return cGroup_6; } - //'Specs' - public Keyword getSpecsKeyword_6_0() { return cSpecsKeyword_6_0; } + //'artifacts:' + public Keyword getArtifactsKeyword_6_0() { return cArtifactsKeyword_6_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_6_1() { return cLeftCurlyBracketKeyword_6_1; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_6_1() { return cBEGINTerminalRuleCall_6_1; } - //spec+=SpecBase - public Assignment getSpecAssignment_6_2() { return cSpecAssignment_6_2; } - - //SpecBase - public RuleCall getSpecSpecBaseParserRuleCall_6_2_0() { return cSpecSpecBaseParserRuleCall_6_2_0; } + //artifact+=Artifact* + public Assignment getArtifactAssignment_6_2() { return cArtifactAssignment_6_2; } - //( "," spec+=SpecBase)* - public Group getGroup_6_3() { return cGroup_6_3; } + //Artifact + public RuleCall getArtifactArtifactParserRuleCall_6_2_0() { return cArtifactArtifactParserRuleCall_6_2_0; } - //"," - public Keyword getCommaKeyword_6_3_0() { return cCommaKeyword_6_3_0; } + //END + public RuleCall getENDTerminalRuleCall_6_3() { return cENDTerminalRuleCall_6_3; } - //spec+=SpecBase - public Assignment getSpecAssignment_6_3_1() { return cSpecAssignment_6_3_1; } + //('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + public Group getGroup_7() { return cGroup_7; } - //SpecBase - public RuleCall getSpecSpecBaseParserRuleCall_6_3_1_0() { return cSpecSpecBaseParserRuleCall_6_3_1_0; } + //'dependencies:' + public Keyword getDependenciesKeyword_7_0() { return cDependenciesKeyword_7_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_6_4() { return cRightCurlyBracketKeyword_6_4; } + //'[' + public Keyword getLeftSquareBracketKeyword_7_1() { return cLeftSquareBracketKeyword_7_1; } - //(artifact+=Artifact ( "," artifact+=Artifact)*)? - public Group getGroup_7() { return cGroup_7; } + //dependency+=Dependency + public Assignment getDependencyAssignment_7_2() { return cDependencyAssignment_7_2; } - //artifact+=Artifact - public Assignment getArtifactAssignment_7_0() { return cArtifactAssignment_7_0; } + //Dependency + public RuleCall getDependencyDependencyParserRuleCall_7_2_0() { return cDependencyDependencyParserRuleCall_7_2_0; } - //Artifact - public RuleCall getArtifactArtifactParserRuleCall_7_0_0() { return cArtifactArtifactParserRuleCall_7_0_0; } + //(',' dependency+=Dependency)* + public Group getGroup_7_3() { return cGroup_7_3; } - //( "," artifact+=Artifact)* - public Group getGroup_7_1() { return cGroup_7_1; } + //',' + public Keyword getCommaKeyword_7_3_0() { return cCommaKeyword_7_3_0; } - //"," - public Keyword getCommaKeyword_7_1_0() { return cCommaKeyword_7_1_0; } + //dependency+=Dependency + public Assignment getDependencyAssignment_7_3_1() { return cDependencyAssignment_7_3_1; } - //artifact+=Artifact - public Assignment getArtifactAssignment_7_1_1() { return cArtifactAssignment_7_1_1; } + //Dependency + public RuleCall getDependencyDependencyParserRuleCall_7_3_1_0() { return cDependencyDependencyParserRuleCall_7_3_1_0; } - //Artifact - public RuleCall getArtifactArtifactParserRuleCall_7_1_1_0() { return cArtifactArtifactParserRuleCall_7_1_1_0; } + //']' + public Keyword getRightSquareBracketKeyword_7_4() { return cRightSquareBracketKeyword_7_4; } - //'}' - public Keyword getRightCurlyBracketKeyword_8() { return cRightCurlyBracketKeyword_8; } + //END + public RuleCall getENDTerminalRuleCall_8() { return cENDTerminalRuleCall_8; } } - public class ServiceSpecElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ServiceSpec"); + public class ArtifactElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Artifact"); private final Group cGroup = (Group)rule.eContents().get(1); - private final Action cServiceSpecAction_0 = (Action)cGroup.eContents().get(0); - private final Keyword cServiceSpecKeyword_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); - private final Keyword cLeftCurlyBracketKeyword_3 = (Keyword)cGroup.eContents().get(3); - private final Group cGroup_4 = (Group)cGroup.eContents().get(4); - private final Keyword cRequestKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); - private final Assignment cRequestAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1); - private final RuleCall cRequestMessageDefinitionParserRuleCall_4_1_0 = (RuleCall)cRequestAssignment_4_1.eContents().get(0); - private final Group cGroup_5 = (Group)cGroup.eContents().get(5); - private final Keyword cResponseKeyword_5_0 = (Keyword)cGroup_5.eContents().get(0); - private final Assignment cResponseAssignment_5_1 = (Assignment)cGroup_5.eContents().get(1); - private final RuleCall cResponseMessageDefinitionParserRuleCall_5_1_0 = (RuleCall)cResponseAssignment_5_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_6 = (Keyword)cGroup.eContents().get(6); + 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); - //ServiceSpec returns ServiceSpec: - // {ServiceSpec} - // 'ServiceSpec' - // name=EString - // '{' - // ('request' request=MessageDefinition)? - // ('response' response=MessageDefinition)? - // '}'; + ///////////////////// + ////ARTIFACT AND NODE + ///////////////////// + //Artifact returns Artifact: + // {Artifact} + // name=RosNames':' + // BEGIN + // (node=Node)? + // END; @Override public ParserRule getRule() { return rule; } - //{ServiceSpec} - //'ServiceSpec' - //name=EString - //'{' - // ('request' request=MessageDefinition)? - // ('response' response=MessageDefinition)? - //'}' + //{Artifact} + // name=RosNames':' + // BEGIN + // (node=Node)? + // END public Group getGroup() { return cGroup; } - //{ServiceSpec} - public Action getServiceSpecAction_0() { return cServiceSpecAction_0; } - - //'ServiceSpec' - public Keyword getServiceSpecKeyword_1() { return cServiceSpecKeyword_1; } - - //name=EString - public Assignment getNameAssignment_2() { return cNameAssignment_2; } - - //EString - public RuleCall getNameEStringParserRuleCall_2_0() { return cNameEStringParserRuleCall_2_0; } - - //'{' - public Keyword getLeftCurlyBracketKeyword_3() { return cLeftCurlyBracketKeyword_3; } - - //('request' request=MessageDefinition)? - public Group getGroup_4() { return cGroup_4; } - - //'request' - public Keyword getRequestKeyword_4_0() { return cRequestKeyword_4_0; } + //{Artifact} + public Action getArtifactAction_0() { return cArtifactAction_0; } - //request=MessageDefinition - public Assignment getRequestAssignment_4_1() { return cRequestAssignment_4_1; } + //name=RosNames + public Assignment getNameAssignment_1() { return cNameAssignment_1; } - //MessageDefinition - public RuleCall getRequestMessageDefinitionParserRuleCall_4_1_0() { return cRequestMessageDefinitionParserRuleCall_4_1_0; } + //RosNames + public RuleCall getNameRosNamesParserRuleCall_1_0() { return cNameRosNamesParserRuleCall_1_0; } - //('response' response=MessageDefinition)? - public Group getGroup_5() { return cGroup_5; } + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } - //'response' - public Keyword getResponseKeyword_5_0() { return cResponseKeyword_5_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } - //response=MessageDefinition - public Assignment getResponseAssignment_5_1() { return cResponseAssignment_5_1; } + //(node=Node)? + public Assignment getNodeAssignment_4() { return cNodeAssignment_4; } - //MessageDefinition - public RuleCall getResponseMessageDefinitionParserRuleCall_5_1_0() { return cResponseMessageDefinitionParserRuleCall_5_1_0; } + //Node + public RuleCall getNodeNodeParserRuleCall_4_0() { return cNodeNodeParserRuleCall_4_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_6() { return cRightCurlyBracketKeyword_6; } + //END + public RuleCall getENDTerminalRuleCall_5() { return cENDTerminalRuleCall_5; } } - public class TopicSpecElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.TopicSpec"); + public class NodeElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Node"); private final Group cGroup = (Group)rule.eContents().get(1); - private final Action cTopicSpecAction_0 = (Action)cGroup.eContents().get(0); - private final Keyword cTopicSpecKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); - private final Alternatives cNameAlternatives_2_0 = (Alternatives)cNameAssignment_2.eContents().get(0); - private final RuleCall cNameEStringParserRuleCall_2_0_0 = (RuleCall)cNameAlternatives_2_0.eContents().get(0); - private final Keyword cNameHeaderKeyword_2_0_1 = (Keyword)cNameAlternatives_2_0.eContents().get(1); - private final Keyword cNameStringKeyword_2_0_2 = (Keyword)cNameAlternatives_2_0.eContents().get(2); - private final Keyword cLeftCurlyBracketKeyword_3 = (Keyword)cGroup.eContents().get(3); - private final Group cGroup_4 = (Group)cGroup.eContents().get(4); - private final Keyword cMessageKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); - private final Assignment cMessageAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1); - private final RuleCall cMessageMessageDefinitionParserRuleCall_4_1_0 = (RuleCall)cMessageAssignment_4_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_5 = (Keyword)cGroup.eContents().get(5); + 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 Alternatives cAlternatives_3 = (Alternatives)cGroup.eContents().get(3); + private final Group cGroup_3_0 = (Group)cAlternatives_3.eContents().get(0); + private final Keyword cPublishersKeyword_3_0_0 = (Keyword)cGroup_3_0.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_3_0_1 = (RuleCall)cGroup_3_0.eContents().get(1); + private final Assignment cPublisherAssignment_3_0_2 = (Assignment)cGroup_3_0.eContents().get(2); + private final RuleCall cPublisherPublisherParserRuleCall_3_0_2_0 = (RuleCall)cPublisherAssignment_3_0_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_3_0_3 = (RuleCall)cGroup_3_0.eContents().get(3); + private final Group cGroup_3_1 = (Group)cAlternatives_3.eContents().get(1); + private final Keyword cSubscribersKeyword_3_1_0 = (Keyword)cGroup_3_1.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_3_1_1 = (RuleCall)cGroup_3_1.eContents().get(1); + private final Assignment cSubscriberAssignment_3_1_2 = (Assignment)cGroup_3_1.eContents().get(2); + private final RuleCall cSubscriberSubscriberParserRuleCall_3_1_2_0 = (RuleCall)cSubscriberAssignment_3_1_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_3_1_3 = (RuleCall)cGroup_3_1.eContents().get(3); + private final Group cGroup_3_2 = (Group)cAlternatives_3.eContents().get(2); + private final Keyword cServiceserverKeyword_3_2_0 = (Keyword)cGroup_3_2.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_3_2_1 = (RuleCall)cGroup_3_2.eContents().get(1); + private final Assignment cServiceserverAssignment_3_2_2 = (Assignment)cGroup_3_2.eContents().get(2); + private final RuleCall cServiceserverServiceServerParserRuleCall_3_2_2_0 = (RuleCall)cServiceserverAssignment_3_2_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_3_2_3 = (RuleCall)cGroup_3_2.eContents().get(3); + private final Group cGroup_3_3 = (Group)cAlternatives_3.eContents().get(3); + private final Keyword cServiceclientKeyword_3_3_0 = (Keyword)cGroup_3_3.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_3_3_1 = (RuleCall)cGroup_3_3.eContents().get(1); + private final Assignment cServiceclientAssignment_3_3_2 = (Assignment)cGroup_3_3.eContents().get(2); + private final RuleCall cServiceclientServiceClientParserRuleCall_3_3_2_0 = (RuleCall)cServiceclientAssignment_3_3_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_3_3_3 = (RuleCall)cGroup_3_3.eContents().get(3); + private final Group cGroup_3_4 = (Group)cAlternatives_3.eContents().get(4); + private final Keyword cActionserverKeyword_3_4_0 = (Keyword)cGroup_3_4.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_3_4_1 = (RuleCall)cGroup_3_4.eContents().get(1); + private final Assignment cActionserverAssignment_3_4_2 = (Assignment)cGroup_3_4.eContents().get(2); + private final RuleCall cActionserverActionServerParserRuleCall_3_4_2_0 = (RuleCall)cActionserverAssignment_3_4_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_3_4_3 = (RuleCall)cGroup_3_4.eContents().get(3); + private final Group cGroup_3_5 = (Group)cAlternatives_3.eContents().get(5); + private final Keyword cActionclientKeyword_3_5_0 = (Keyword)cGroup_3_5.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_3_5_1 = (RuleCall)cGroup_3_5.eContents().get(1); + private final Assignment cActionclientAssignment_3_5_2 = (Assignment)cGroup_3_5.eContents().get(2); + private final RuleCall cActionclientActionClientParserRuleCall_3_5_2_0 = (RuleCall)cActionclientAssignment_3_5_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_3_5_3 = (RuleCall)cGroup_3_5.eContents().get(3); + private final Group cGroup_3_6 = (Group)cAlternatives_3.eContents().get(6); + private final Keyword cParametersKeyword_3_6_0 = (Keyword)cGroup_3_6.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_3_6_1 = (RuleCall)cGroup_3_6.eContents().get(1); + private final Assignment cParameterAssignment_3_6_2 = (Assignment)cGroup_3_6.eContents().get(2); + private final RuleCall cParameterParameterParserRuleCall_3_6_2_0 = (RuleCall)cParameterAssignment_3_6_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_3_6_3 = (RuleCall)cGroup_3_6.eContents().get(3); + private final RuleCall cENDTerminalRuleCall_4 = (RuleCall)cGroup.eContents().get(4); - //TopicSpec returns TopicSpec: - // {TopicSpec} - // 'TopicSpec' - // name=(EString|'Header'|'String') - // '{' - // ('message' message=MessageDefinition)? - // '}'; + //Node returns Node: + // 'node:' name=RosNames + // BEGIN + // ( + // ('publishers:' + // BEGIN + // publisher+=Publisher* + // END + // )| + // ('subscribers:' + // BEGIN + // subscriber+=Subscriber* + // END + // )| + // ('serviceserver:' + // BEGIN + // serviceserver+=ServiceServer* + // END + // )| + // ('serviceclient:' + // BEGIN + // serviceclient+=ServiceClient* + // END + // )| + // ('actionserver:' + // BEGIN + // actionserver+=ActionServer* + // END + // )| + // ('actionclient:' + // BEGIN + // actionclient+=ActionClient* + // END + // )| + // ('parameters:' + // BEGIN + // parameter+=Parameter* + // END + // ) + // )*END + // ; @Override public ParserRule getRule() { return rule; } - //{TopicSpec} - //'TopicSpec' - //name=(EString|'Header'|'String') - //'{' - // ('message' message=MessageDefinition)? - //'}' + //'node:' name=RosNames + // BEGIN + // ( + // ('publishers:' + // BEGIN + // publisher+=Publisher* + // END + // )| + // ('subscribers:' + // BEGIN + // subscriber+=Subscriber* + // END + // )| + // ('serviceserver:' + // BEGIN + // serviceserver+=ServiceServer* + // END + // )| + // ('serviceclient:' + // BEGIN + // serviceclient+=ServiceClient* + // END + // )| + // ('actionserver:' + // BEGIN + // actionserver+=ActionServer* + // END + // )| + // ('actionclient:' + // BEGIN + // actionclient+=ActionClient* + // END + // )| + // ('parameters:' + // BEGIN + // parameter+=Parameter* + // END + // ) + // )*END public Group getGroup() { return cGroup; } - //{TopicSpec} - public Action getTopicSpecAction_0() { return cTopicSpecAction_0; } - - //'TopicSpec' - public Keyword getTopicSpecKeyword_1() { return cTopicSpecKeyword_1; } - - //name=(EString|'Header'|'String') - public Assignment getNameAssignment_2() { return cNameAssignment_2; } - - //(EString|'Header'|'String') - public Alternatives getNameAlternatives_2_0() { return cNameAlternatives_2_0; } - - //EString - public RuleCall getNameEStringParserRuleCall_2_0_0() { return cNameEStringParserRuleCall_2_0_0; } - - //'Header' - public Keyword getNameHeaderKeyword_2_0_1() { return cNameHeaderKeyword_2_0_1; } - - //'String' - public Keyword getNameStringKeyword_2_0_2() { return cNameStringKeyword_2_0_2; } - - //'{' - public Keyword getLeftCurlyBracketKeyword_3() { return cLeftCurlyBracketKeyword_3; } - - //('message' message=MessageDefinition)? - public Group getGroup_4() { return cGroup_4; } + //'node:' + public Keyword getNodeKeyword_0() { return cNodeKeyword_0; } - //'message' - public Keyword getMessageKeyword_4_0() { return cMessageKeyword_4_0; } + //name=RosNames + public Assignment getNameAssignment_1() { return cNameAssignment_1; } - //message=MessageDefinition - public Assignment getMessageAssignment_4_1() { return cMessageAssignment_4_1; } + //RosNames + public RuleCall getNameRosNamesParserRuleCall_1_0() { return cNameRosNamesParserRuleCall_1_0; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_2() { return cBEGINTerminalRuleCall_2; } + + //( + //('publishers:' + // BEGIN + // publisher+=Publisher* + // END + //)| + //('subscribers:' + // BEGIN + // subscriber+=Subscriber* + // END + //)| + //('serviceserver:' + // BEGIN + // serviceserver+=ServiceServer* + // END + //)| + //('serviceclient:' + // BEGIN + // serviceclient+=ServiceClient* + // END + //)| + //('actionserver:' + // BEGIN + // actionserver+=ActionServer* + // END + //)| + //('actionclient:' + // BEGIN + // actionclient+=ActionClient* + // END + //)| + //('parameters:' + // BEGIN + // parameter+=Parameter* + // END + //) + //)* + public Alternatives getAlternatives_3() { return cAlternatives_3; } + + //('publishers:' + // BEGIN + // publisher+=Publisher* + // END + //) + public Group getGroup_3_0() { return cGroup_3_0; } + + //'publishers:' + public Keyword getPublishersKeyword_3_0_0() { return cPublishersKeyword_3_0_0; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3_0_1() { return cBEGINTerminalRuleCall_3_0_1; } + + //publisher+=Publisher* + public Assignment getPublisherAssignment_3_0_2() { return cPublisherAssignment_3_0_2; } - //MessageDefinition - public RuleCall getMessageMessageDefinitionParserRuleCall_4_1_0() { return cMessageMessageDefinitionParserRuleCall_4_1_0; } + //Publisher + public RuleCall getPublisherPublisherParserRuleCall_3_0_2_0() { return cPublisherPublisherParserRuleCall_3_0_2_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_5() { return cRightCurlyBracketKeyword_5; } - } - public class ActionSpecElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ActionSpec"); - private final Group cGroup = (Group)rule.eContents().get(1); - private final Action cActionSpecAction_0 = (Action)cGroup.eContents().get(0); - private final Keyword cActionSpecKeyword_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); - private final Keyword cLeftCurlyBracketKeyword_3 = (Keyword)cGroup.eContents().get(3); - private final Group cGroup_4 = (Group)cGroup.eContents().get(4); - private final Keyword cGoalKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); - private final Assignment cGoalAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1); - private final RuleCall cGoalMessageDefinitionParserRuleCall_4_1_0 = (RuleCall)cGoalAssignment_4_1.eContents().get(0); - private final Group cGroup_5 = (Group)cGroup.eContents().get(5); - private final Keyword cResultKeyword_5_0 = (Keyword)cGroup_5.eContents().get(0); - private final Assignment cResultAssignment_5_1 = (Assignment)cGroup_5.eContents().get(1); - private final RuleCall cResultMessageDefinitionParserRuleCall_5_1_0 = (RuleCall)cResultAssignment_5_1.eContents().get(0); - private final Group cGroup_6 = (Group)cGroup.eContents().get(6); - private final Keyword cFeedbackKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); - private final Assignment cFeedbackAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); - private final RuleCall cFeedbackMessageDefinitionParserRuleCall_6_1_0 = (RuleCall)cFeedbackAssignment_6_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_7 = (Keyword)cGroup.eContents().get(7); + //END + public RuleCall getENDTerminalRuleCall_3_0_3() { return cENDTerminalRuleCall_3_0_3; } - //ActionSpec returns ActionSpec: - // {ActionSpec} - // 'ActionSpec' - // name=EString - // '{' - // ('goal' goal=MessageDefinition)? - // ('result' result=MessageDefinition)? - // ('feedback' feedback=MessageDefinition)? - // '}'; - @Override public ParserRule getRule() { return rule; } + //('subscribers:' + // BEGIN + // subscriber+=Subscriber* + // END + //) + public Group getGroup_3_1() { return cGroup_3_1; } - //{ActionSpec} - //'ActionSpec' - //name=EString - //'{' - // ('goal' goal=MessageDefinition)? - // ('result' result=MessageDefinition)? - // ('feedback' feedback=MessageDefinition)? - //'}' - public Group getGroup() { return cGroup; } + //'subscribers:' + public Keyword getSubscribersKeyword_3_1_0() { return cSubscribersKeyword_3_1_0; } - //{ActionSpec} - public Action getActionSpecAction_0() { return cActionSpecAction_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3_1_1() { return cBEGINTerminalRuleCall_3_1_1; } - //'ActionSpec' - public Keyword getActionSpecKeyword_1() { return cActionSpecKeyword_1; } + //subscriber+=Subscriber* + public Assignment getSubscriberAssignment_3_1_2() { return cSubscriberAssignment_3_1_2; } - //name=EString - public Assignment getNameAssignment_2() { return cNameAssignment_2; } + //Subscriber + public RuleCall getSubscriberSubscriberParserRuleCall_3_1_2_0() { return cSubscriberSubscriberParserRuleCall_3_1_2_0; } - //EString - public RuleCall getNameEStringParserRuleCall_2_0() { return cNameEStringParserRuleCall_2_0; } + //END + public RuleCall getENDTerminalRuleCall_3_1_3() { return cENDTerminalRuleCall_3_1_3; } - //'{' - public Keyword getLeftCurlyBracketKeyword_3() { return cLeftCurlyBracketKeyword_3; } + //('serviceserver:' + // BEGIN + // serviceserver+=ServiceServer* + // END + //) + public Group getGroup_3_2() { return cGroup_3_2; } - //('goal' goal=MessageDefinition)? - public Group getGroup_4() { return cGroup_4; } + //'serviceserver:' + public Keyword getServiceserverKeyword_3_2_0() { return cServiceserverKeyword_3_2_0; } - //'goal' - public Keyword getGoalKeyword_4_0() { return cGoalKeyword_4_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3_2_1() { return cBEGINTerminalRuleCall_3_2_1; } - //goal=MessageDefinition - public Assignment getGoalAssignment_4_1() { return cGoalAssignment_4_1; } + //serviceserver+=ServiceServer* + public Assignment getServiceserverAssignment_3_2_2() { return cServiceserverAssignment_3_2_2; } - //MessageDefinition - public RuleCall getGoalMessageDefinitionParserRuleCall_4_1_0() { return cGoalMessageDefinitionParserRuleCall_4_1_0; } + //ServiceServer + public RuleCall getServiceserverServiceServerParserRuleCall_3_2_2_0() { return cServiceserverServiceServerParserRuleCall_3_2_2_0; } - //('result' result=MessageDefinition)? - public Group getGroup_5() { return cGroup_5; } + //END + public RuleCall getENDTerminalRuleCall_3_2_3() { return cENDTerminalRuleCall_3_2_3; } - //'result' - public Keyword getResultKeyword_5_0() { return cResultKeyword_5_0; } + //('serviceclient:' + // BEGIN + // serviceclient+=ServiceClient* + // END + //) + public Group getGroup_3_3() { return cGroup_3_3; } - //result=MessageDefinition - public Assignment getResultAssignment_5_1() { return cResultAssignment_5_1; } + //'serviceclient:' + public Keyword getServiceclientKeyword_3_3_0() { return cServiceclientKeyword_3_3_0; } - //MessageDefinition - public RuleCall getResultMessageDefinitionParserRuleCall_5_1_0() { return cResultMessageDefinitionParserRuleCall_5_1_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3_3_1() { return cBEGINTerminalRuleCall_3_3_1; } - //('feedback' feedback=MessageDefinition)? - public Group getGroup_6() { return cGroup_6; } + //serviceclient+=ServiceClient* + public Assignment getServiceclientAssignment_3_3_2() { return cServiceclientAssignment_3_3_2; } - //'feedback' - public Keyword getFeedbackKeyword_6_0() { return cFeedbackKeyword_6_0; } + //ServiceClient + public RuleCall getServiceclientServiceClientParserRuleCall_3_3_2_0() { return cServiceclientServiceClientParserRuleCall_3_3_2_0; } - //feedback=MessageDefinition - public Assignment getFeedbackAssignment_6_1() { return cFeedbackAssignment_6_1; } + //END + public RuleCall getENDTerminalRuleCall_3_3_3() { return cENDTerminalRuleCall_3_3_3; } - //MessageDefinition - public RuleCall getFeedbackMessageDefinitionParserRuleCall_6_1_0() { return cFeedbackMessageDefinitionParserRuleCall_6_1_0; } + //('actionserver:' + // BEGIN + // actionserver+=ActionServer* + // END + //) + public Group getGroup_3_4() { return cGroup_3_4; } - //'}' - public Keyword getRightCurlyBracketKeyword_7() { return cRightCurlyBracketKeyword_7; } - } - public class MessageDefinitionElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); - private final Group cGroup = (Group)rule.eContents().get(1); - private final Action cMessageDefinitionAction_0 = (Action)cGroup.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Group cGroup_2 = (Group)cGroup.eContents().get(2); - private final Assignment cMessagePartAssignment_2_0 = (Assignment)cGroup_2.eContents().get(0); - private final RuleCall cMessagePartMessagePartParserRuleCall_2_0_0 = (RuleCall)cMessagePartAssignment_2_0.eContents().get(0); - private final Assignment cMessagePartAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); - private final RuleCall cMessagePartMessagePartParserRuleCall_2_1_0 = (RuleCall)cMessagePartAssignment_2_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_3 = (Keyword)cGroup.eContents().get(3); + //'actionserver:' + public Keyword getActionserverKeyword_3_4_0() { return cActionserverKeyword_3_4_0; } - //MessageDefinition returns MessageDefinition: - // {MessageDefinition} - // '{' - // ( MessagePart+=MessagePart ( MessagePart+=MessagePart)* )? - // '}'; - @Override public ParserRule getRule() { return rule; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3_4_1() { return cBEGINTerminalRuleCall_3_4_1; } - //{MessageDefinition} - //'{' - // ( MessagePart+=MessagePart ( MessagePart+=MessagePart)* )? - //'}' - public Group getGroup() { return cGroup; } + //actionserver+=ActionServer* + public Assignment getActionserverAssignment_3_4_2() { return cActionserverAssignment_3_4_2; } - //{MessageDefinition} - public Action getMessageDefinitionAction_0() { return cMessageDefinitionAction_0; } + //ActionServer + public RuleCall getActionserverActionServerParserRuleCall_3_4_2_0() { return cActionserverActionServerParserRuleCall_3_4_2_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } + //END + public RuleCall getENDTerminalRuleCall_3_4_3() { return cENDTerminalRuleCall_3_4_3; } - //( MessagePart+=MessagePart ( MessagePart+=MessagePart)* )? - public Group getGroup_2() { return cGroup_2; } + //('actionclient:' + // BEGIN + // actionclient+=ActionClient* + // END + //) + public Group getGroup_3_5() { return cGroup_3_5; } - //MessagePart+=MessagePart - public Assignment getMessagePartAssignment_2_0() { return cMessagePartAssignment_2_0; } + //'actionclient:' + public Keyword getActionclientKeyword_3_5_0() { return cActionclientKeyword_3_5_0; } - //MessagePart - public RuleCall getMessagePartMessagePartParserRuleCall_2_0_0() { return cMessagePartMessagePartParserRuleCall_2_0_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3_5_1() { return cBEGINTerminalRuleCall_3_5_1; } - //( MessagePart+=MessagePart)* - public Assignment getMessagePartAssignment_2_1() { return cMessagePartAssignment_2_1; } + //actionclient+=ActionClient* + public Assignment getActionclientAssignment_3_5_2() { return cActionclientAssignment_3_5_2; } - //MessagePart - public RuleCall getMessagePartMessagePartParserRuleCall_2_1_0() { return cMessagePartMessagePartParserRuleCall_2_1_0; } + //ActionClient + public RuleCall getActionclientActionClientParserRuleCall_3_5_2_0() { return cActionclientActionClientParserRuleCall_3_5_2_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_3() { return cRightCurlyBracketKeyword_3; } - } - public class NodeElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Node"); - private final Group cGroup = (Group)rule.eContents().get(1); - private final Keyword cNodeKeyword_0 = (Keyword)cGroup.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cNameKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Assignment cNameAssignment_3 = (Assignment)cGroup.eContents().get(3); - private final RuleCall cNameRosNamesParserRuleCall_3_0 = (RuleCall)cNameAssignment_3.eContents().get(0); - private final Group cGroup_4 = (Group)cGroup.eContents().get(4); - private final Keyword cServiceServersKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_4_1 = (Keyword)cGroup_4.eContents().get(1); - private final Assignment cServiceserverAssignment_4_2 = (Assignment)cGroup_4.eContents().get(2); - private final RuleCall cServiceserverServiceServerParserRuleCall_4_2_0 = (RuleCall)cServiceserverAssignment_4_2.eContents().get(0); - private final Group cGroup_4_3 = (Group)cGroup_4.eContents().get(3); - private final Keyword cCommaKeyword_4_3_0 = (Keyword)cGroup_4_3.eContents().get(0); - private final Assignment cServiceserverAssignment_4_3_1 = (Assignment)cGroup_4_3.eContents().get(1); - private final RuleCall cServiceserverServiceServerParserRuleCall_4_3_1_0 = (RuleCall)cServiceserverAssignment_4_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_4_4 = (Keyword)cGroup_4.eContents().get(4); - private final Group cGroup_5 = (Group)cGroup.eContents().get(5); - private final Keyword cPublishersKeyword_5_0 = (Keyword)cGroup_5.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_5_1 = (Keyword)cGroup_5.eContents().get(1); - private final Assignment cPublisherAssignment_5_2 = (Assignment)cGroup_5.eContents().get(2); - private final RuleCall cPublisherPublisherParserRuleCall_5_2_0 = (RuleCall)cPublisherAssignment_5_2.eContents().get(0); - private final Group cGroup_5_3 = (Group)cGroup_5.eContents().get(3); - private final Keyword cCommaKeyword_5_3_0 = (Keyword)cGroup_5_3.eContents().get(0); - private final Assignment cPublisherAssignment_5_3_1 = (Assignment)cGroup_5_3.eContents().get(1); - private final RuleCall cPublisherPublisherParserRuleCall_5_3_1_0 = (RuleCall)cPublisherAssignment_5_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_5_4 = (Keyword)cGroup_5.eContents().get(4); - private final Group cGroup_6 = (Group)cGroup.eContents().get(6); - private final Keyword cSubscribersKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_6_1 = (Keyword)cGroup_6.eContents().get(1); - private final Assignment cSubscriberAssignment_6_2 = (Assignment)cGroup_6.eContents().get(2); - private final RuleCall cSubscriberSubscriberParserRuleCall_6_2_0 = (RuleCall)cSubscriberAssignment_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 cSubscriberAssignment_6_3_1 = (Assignment)cGroup_6_3.eContents().get(1); - private final RuleCall cSubscriberSubscriberParserRuleCall_6_3_1_0 = (RuleCall)cSubscriberAssignment_6_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_6_4 = (Keyword)cGroup_6.eContents().get(4); - private final Group cGroup_7 = (Group)cGroup.eContents().get(7); - private final Keyword cServiceClientsKeyword_7_0 = (Keyword)cGroup_7.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_7_1 = (Keyword)cGroup_7.eContents().get(1); - private final Assignment cServiceclientAssignment_7_2 = (Assignment)cGroup_7.eContents().get(2); - private final RuleCall cServiceclientServiceClientParserRuleCall_7_2_0 = (RuleCall)cServiceclientAssignment_7_2.eContents().get(0); - private final Group cGroup_7_3 = (Group)cGroup_7.eContents().get(3); - private final Keyword cCommaKeyword_7_3_0 = (Keyword)cGroup_7_3.eContents().get(0); - private final Assignment cServiceclientAssignment_7_3_1 = (Assignment)cGroup_7_3.eContents().get(1); - private final RuleCall cServiceclientServiceClientParserRuleCall_7_3_1_0 = (RuleCall)cServiceclientAssignment_7_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_7_4 = (Keyword)cGroup_7.eContents().get(4); - private final Group cGroup_8 = (Group)cGroup.eContents().get(8); - private final Keyword cActionServersKeyword_8_0 = (Keyword)cGroup_8.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_8_1 = (Keyword)cGroup_8.eContents().get(1); - private final Assignment cActionserverAssignment_8_2 = (Assignment)cGroup_8.eContents().get(2); - private final RuleCall cActionserverActionServerParserRuleCall_8_2_0 = (RuleCall)cActionserverAssignment_8_2.eContents().get(0); - private final Group cGroup_8_3 = (Group)cGroup_8.eContents().get(3); - private final Keyword cCommaKeyword_8_3_0 = (Keyword)cGroup_8_3.eContents().get(0); - private final Assignment cActionserverAssignment_8_3_1 = (Assignment)cGroup_8_3.eContents().get(1); - private final RuleCall cActionserverActionServerParserRuleCall_8_3_1_0 = (RuleCall)cActionserverAssignment_8_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_8_4 = (Keyword)cGroup_8.eContents().get(4); - private final Group cGroup_9 = (Group)cGroup.eContents().get(9); - private final Keyword cActionClientsKeyword_9_0 = (Keyword)cGroup_9.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_9_1 = (Keyword)cGroup_9.eContents().get(1); - private final Assignment cActionclientAssignment_9_2 = (Assignment)cGroup_9.eContents().get(2); - private final RuleCall cActionclientActionClientParserRuleCall_9_2_0 = (RuleCall)cActionclientAssignment_9_2.eContents().get(0); - private final Group cGroup_9_3 = (Group)cGroup_9.eContents().get(3); - private final Keyword cCommaKeyword_9_3_0 = (Keyword)cGroup_9_3.eContents().get(0); - private final Assignment cActionclientAssignment_9_3_1 = (Assignment)cGroup_9_3.eContents().get(1); - private final RuleCall cActionclientActionClientParserRuleCall_9_3_1_0 = (RuleCall)cActionclientAssignment_9_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_9_4 = (Keyword)cGroup_9.eContents().get(4); - private final Group cGroup_10 = (Group)cGroup.eContents().get(10); - private final Keyword cParametersKeyword_10_0 = (Keyword)cGroup_10.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_10_1 = (Keyword)cGroup_10.eContents().get(1); - private final Assignment cParameterAssignment_10_2 = (Assignment)cGroup_10.eContents().get(2); - private final RuleCall cParameterParameterParserRuleCall_10_2_0 = (RuleCall)cParameterAssignment_10_2.eContents().get(0); - private final Group cGroup_10_3 = (Group)cGroup_10.eContents().get(3); - private final Keyword cCommaKeyword_10_3_0 = (Keyword)cGroup_10_3.eContents().get(0); - private final Assignment cParameterAssignment_10_3_1 = (Assignment)cGroup_10_3.eContents().get(1); - private final RuleCall cParameterParameterParserRuleCall_10_3_1_0 = (RuleCall)cParameterAssignment_10_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_10_4 = (Keyword)cGroup_10.eContents().get(4); - private final Keyword cRightCurlyBracketKeyword_11 = (Keyword)cGroup.eContents().get(11); + //END + public RuleCall getENDTerminalRuleCall_3_5_3() { return cENDTerminalRuleCall_3_5_3; } - //Node returns Node: - // 'Node' - // '{' - // 'name' name=RosNames - // ('ServiceServers' '{' serviceserver+=ServiceServer ( "," serviceserver+=ServiceServer)* '}')? - // ('Publishers' '{' publisher+=Publisher ( "," publisher+=Publisher)* '}')? - // ('Subscribers' '{' subscriber+=Subscriber ( "," subscriber+=Subscriber)* '}')? - // ('ServiceClients' '{' serviceclient+=ServiceClient ( "," serviceclient+=ServiceClient)* '}')? - // ('ActionServers' '{' actionserver+=ActionServer ( "," actionserver+=ActionServer)* '}')? - // ('ActionClients' '{' actionclient+=ActionClient ( "," actionclient+=ActionClient)* '}' )? - // ('Parameters' '{' parameter+=Parameter ( "," parameter+=Parameter)* '}' )? - // '}'; - @Override public ParserRule getRule() { return rule; } + //('parameters:' + // BEGIN + // parameter+=Parameter* + // END + //) + public Group getGroup_3_6() { return cGroup_3_6; } - //'Node' - //'{' - // 'name' name=RosNames - // ('ServiceServers' '{' serviceserver+=ServiceServer ( "," serviceserver+=ServiceServer)* '}')? - // ('Publishers' '{' publisher+=Publisher ( "," publisher+=Publisher)* '}')? - // ('Subscribers' '{' subscriber+=Subscriber ( "," subscriber+=Subscriber)* '}')? - // ('ServiceClients' '{' serviceclient+=ServiceClient ( "," serviceclient+=ServiceClient)* '}')? - // ('ActionServers' '{' actionserver+=ActionServer ( "," actionserver+=ActionServer)* '}')? - // ('ActionClients' '{' actionclient+=ActionClient ( "," actionclient+=ActionClient)* '}' )? - // ('Parameters' '{' parameter+=Parameter ( "," parameter+=Parameter)* '}' )? - //'}' - public Group getGroup() { return cGroup; } + //'parameters:' + public Keyword getParametersKeyword_3_6_0() { return cParametersKeyword_3_6_0; } - //'Node' - public Keyword getNodeKeyword_0() { return cNodeKeyword_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3_6_1() { return cBEGINTerminalRuleCall_3_6_1; } - //'{' - public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } + //parameter+=Parameter* + public Assignment getParameterAssignment_3_6_2() { return cParameterAssignment_3_6_2; } - //'name' - public Keyword getNameKeyword_2() { return cNameKeyword_2; } + //Parameter + public RuleCall getParameterParameterParserRuleCall_3_6_2_0() { return cParameterParameterParserRuleCall_3_6_2_0; } - //name=RosNames - public Assignment getNameAssignment_3() { return cNameAssignment_3; } + //END + public RuleCall getENDTerminalRuleCall_3_6_3() { return cENDTerminalRuleCall_3_6_3; } - //RosNames - public RuleCall getNameRosNamesParserRuleCall_3_0() { return cNameRosNamesParserRuleCall_3_0; } + //END + public RuleCall getENDTerminalRuleCall_4() { return cENDTerminalRuleCall_4; } + } + public class SpecBaseElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.SpecBase"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cTopicSpecParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cServiceSpecParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + private final RuleCall cActionSpecParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); - //('ServiceServers' '{' serviceserver+=ServiceServer ( "," serviceserver+=ServiceServer)* '}')? - public Group getGroup_4() { return cGroup_4; } + ///////////////////// + ////OBJECTS/SPECIFICATIONS + ///////////////////// + //SpecBase returns SpecBase: + // TopicSpec | ServiceSpec | ActionSpec; + @Override public ParserRule getRule() { return rule; } - //'ServiceServers' - public Keyword getServiceServersKeyword_4_0() { return cServiceServersKeyword_4_0; } + //TopicSpec | ServiceSpec | ActionSpec + public Alternatives getAlternatives() { return cAlternatives; } - //'{' - public Keyword getLeftCurlyBracketKeyword_4_1() { return cLeftCurlyBracketKeyword_4_1; } + //TopicSpec + public RuleCall getTopicSpecParserRuleCall_0() { return cTopicSpecParserRuleCall_0; } - //serviceserver+=ServiceServer - public Assignment getServiceserverAssignment_4_2() { return cServiceserverAssignment_4_2; } + //ServiceSpec + public RuleCall getServiceSpecParserRuleCall_1() { return cServiceSpecParserRuleCall_1; } - //ServiceServer - public RuleCall getServiceserverServiceServerParserRuleCall_4_2_0() { return cServiceserverServiceServerParserRuleCall_4_2_0; } + //ActionSpec + public RuleCall getActionSpecParserRuleCall_2() { return cActionSpecParserRuleCall_2; } + } + public class TopicSpecElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.TopicSpec"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cTopicSpecAction_0 = (Action)cGroup.eContents().get(0); + private final Keyword cMsgKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); + private final Alternatives cNameAlternatives_2_0 = (Alternatives)cNameAssignment_2.eContents().get(0); + private final RuleCall cNameEStringParserRuleCall_2_0_0 = (RuleCall)cNameAlternatives_2_0.eContents().get(0); + private final Keyword cNameHeaderKeyword_2_0_1 = (Keyword)cNameAlternatives_2_0.eContents().get(1); + private final Keyword cNameStringKeyword_2_0_2 = (Keyword)cNameAlternatives_2_0.eContents().get(2); + private final RuleCall cBEGINTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); + private final Keyword cMessageKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Group cGroup_5 = (Group)cGroup.eContents().get(5); + private final RuleCall cBEGINTerminalRuleCall_5_0 = (RuleCall)cGroup_5.eContents().get(0); + private final Assignment cMessageAssignment_5_1 = (Assignment)cGroup_5.eContents().get(1); + private final RuleCall cMessageMessageDefinitionParserRuleCall_5_1_0 = (RuleCall)cMessageAssignment_5_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_5_2 = (RuleCall)cGroup_5.eContents().get(2); + private final RuleCall cENDTerminalRuleCall_6 = (RuleCall)cGroup.eContents().get(6); - //( "," serviceserver+=ServiceServer)* - public Group getGroup_4_3() { return cGroup_4_3; } + //TopicSpec returns TopicSpec: + // {TopicSpec} + // 'msg:'name=(EString|'Header'|'String') + // BEGIN + // 'message:' (BEGIN message=MessageDefinition END)? + // END + // ; + @Override public ParserRule getRule() { return rule; } - //"," - public Keyword getCommaKeyword_4_3_0() { return cCommaKeyword_4_3_0; } + //{TopicSpec} + //'msg:'name=(EString|'Header'|'String') + //BEGIN + // 'message:' (BEGIN message=MessageDefinition END)? + //END + public Group getGroup() { return cGroup; } - //serviceserver+=ServiceServer - public Assignment getServiceserverAssignment_4_3_1() { return cServiceserverAssignment_4_3_1; } + //{TopicSpec} + public Action getTopicSpecAction_0() { return cTopicSpecAction_0; } - //ServiceServer - public RuleCall getServiceserverServiceServerParserRuleCall_4_3_1_0() { return cServiceserverServiceServerParserRuleCall_4_3_1_0; } + //'msg:' + public Keyword getMsgKeyword_1() { return cMsgKeyword_1; } - //'}' - public Keyword getRightCurlyBracketKeyword_4_4() { return cRightCurlyBracketKeyword_4_4; } + //name=(EString|'Header'|'String') + public Assignment getNameAssignment_2() { return cNameAssignment_2; } - //('Publishers' '{' publisher+=Publisher ( "," publisher+=Publisher)* '}')? - public Group getGroup_5() { return cGroup_5; } + //(EString|'Header'|'String') + public Alternatives getNameAlternatives_2_0() { return cNameAlternatives_2_0; } - //'Publishers' - public Keyword getPublishersKeyword_5_0() { return cPublishersKeyword_5_0; } + //EString + public RuleCall getNameEStringParserRuleCall_2_0_0() { return cNameEStringParserRuleCall_2_0_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_5_1() { return cLeftCurlyBracketKeyword_5_1; } + //'Header' + public Keyword getNameHeaderKeyword_2_0_1() { return cNameHeaderKeyword_2_0_1; } - //publisher+=Publisher - public Assignment getPublisherAssignment_5_2() { return cPublisherAssignment_5_2; } + //'String' + public Keyword getNameStringKeyword_2_0_2() { return cNameStringKeyword_2_0_2; } - //Publisher - public RuleCall getPublisherPublisherParserRuleCall_5_2_0() { return cPublisherPublisherParserRuleCall_5_2_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } - //( "," publisher+=Publisher)* - public Group getGroup_5_3() { return cGroup_5_3; } + //'message:' + public Keyword getMessageKeyword_4() { return cMessageKeyword_4; } - //"," - public Keyword getCommaKeyword_5_3_0() { return cCommaKeyword_5_3_0; } + //(BEGIN message=MessageDefinition END)? + public Group getGroup_5() { return cGroup_5; } - //publisher+=Publisher - public Assignment getPublisherAssignment_5_3_1() { return cPublisherAssignment_5_3_1; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_5_0() { return cBEGINTerminalRuleCall_5_0; } - //Publisher - public RuleCall getPublisherPublisherParserRuleCall_5_3_1_0() { return cPublisherPublisherParserRuleCall_5_3_1_0; } + //message=MessageDefinition + public Assignment getMessageAssignment_5_1() { return cMessageAssignment_5_1; } - //'}' - public Keyword getRightCurlyBracketKeyword_5_4() { return cRightCurlyBracketKeyword_5_4; } + //MessageDefinition + public RuleCall getMessageMessageDefinitionParserRuleCall_5_1_0() { return cMessageMessageDefinitionParserRuleCall_5_1_0; } - //('Subscribers' '{' subscriber+=Subscriber ( "," subscriber+=Subscriber)* '}')? - public Group getGroup_6() { return cGroup_6; } + //END + public RuleCall getENDTerminalRuleCall_5_2() { return cENDTerminalRuleCall_5_2; } - //'Subscribers' - public Keyword getSubscribersKeyword_6_0() { return cSubscribersKeyword_6_0; } + //END + public RuleCall getENDTerminalRuleCall_6() { return cENDTerminalRuleCall_6; } + } + public class ServiceSpecElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ServiceSpec"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cServiceSpecAction_0 = (Action)cGroup.eContents().get(0); + private final Keyword cSrvKeyword_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); + private final RuleCall cBEGINTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); + private final Keyword cRequestKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Group cGroup_5 = (Group)cGroup.eContents().get(5); + private final RuleCall cBEGINTerminalRuleCall_5_0 = (RuleCall)cGroup_5.eContents().get(0); + private final Assignment cRequestAssignment_5_1 = (Assignment)cGroup_5.eContents().get(1); + private final RuleCall cRequestMessageDefinitionParserRuleCall_5_1_0 = (RuleCall)cRequestAssignment_5_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_5_2 = (RuleCall)cGroup_5.eContents().get(2); + private final Keyword cResponseKeyword_6 = (Keyword)cGroup.eContents().get(6); + private final Group cGroup_7 = (Group)cGroup.eContents().get(7); + private final RuleCall cBEGINTerminalRuleCall_7_0 = (RuleCall)cGroup_7.eContents().get(0); + private final Assignment cResponseAssignment_7_1 = (Assignment)cGroup_7.eContents().get(1); + private final RuleCall cResponseMessageDefinitionParserRuleCall_7_1_0 = (RuleCall)cResponseAssignment_7_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_7_2 = (RuleCall)cGroup_7.eContents().get(2); + private final RuleCall cENDTerminalRuleCall_8 = (RuleCall)cGroup.eContents().get(8); - //'{' - public Keyword getLeftCurlyBracketKeyword_6_1() { return cLeftCurlyBracketKeyword_6_1; } + //ServiceSpec returns ServiceSpec: + // {ServiceSpec} + // 'srv:'name=EString + // BEGIN + // 'request:' (BEGIN request=MessageDefinition END)? + // 'response:' (BEGIN response=MessageDefinition END)? + // END; + @Override public ParserRule getRule() { return rule; } - //subscriber+=Subscriber - public Assignment getSubscriberAssignment_6_2() { return cSubscriberAssignment_6_2; } + //{ServiceSpec} + //'srv:'name=EString + //BEGIN + // 'request:' (BEGIN request=MessageDefinition END)? + // 'response:' (BEGIN response=MessageDefinition END)? + //END + public Group getGroup() { return cGroup; } - //Subscriber - public RuleCall getSubscriberSubscriberParserRuleCall_6_2_0() { return cSubscriberSubscriberParserRuleCall_6_2_0; } + //{ServiceSpec} + public Action getServiceSpecAction_0() { return cServiceSpecAction_0; } - //( "," subscriber+=Subscriber)* - public Group getGroup_6_3() { return cGroup_6_3; } + //'srv:' + public Keyword getSrvKeyword_1() { return cSrvKeyword_1; } - //"," - public Keyword getCommaKeyword_6_3_0() { return cCommaKeyword_6_3_0; } + //name=EString + public Assignment getNameAssignment_2() { return cNameAssignment_2; } - //subscriber+=Subscriber - public Assignment getSubscriberAssignment_6_3_1() { return cSubscriberAssignment_6_3_1; } + //EString + public RuleCall getNameEStringParserRuleCall_2_0() { return cNameEStringParserRuleCall_2_0; } - //Subscriber - public RuleCall getSubscriberSubscriberParserRuleCall_6_3_1_0() { return cSubscriberSubscriberParserRuleCall_6_3_1_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } - //'}' - public Keyword getRightCurlyBracketKeyword_6_4() { return cRightCurlyBracketKeyword_6_4; } + //'request:' + public Keyword getRequestKeyword_4() { return cRequestKeyword_4; } - //('ServiceClients' '{' serviceclient+=ServiceClient ( "," serviceclient+=ServiceClient)* '}')? - public Group getGroup_7() { return cGroup_7; } + //(BEGIN request=MessageDefinition END)? + public Group getGroup_5() { return cGroup_5; } - //'ServiceClients' - public Keyword getServiceClientsKeyword_7_0() { return cServiceClientsKeyword_7_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_5_0() { return cBEGINTerminalRuleCall_5_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_7_1() { return cLeftCurlyBracketKeyword_7_1; } + //request=MessageDefinition + public Assignment getRequestAssignment_5_1() { return cRequestAssignment_5_1; } - //serviceclient+=ServiceClient - public Assignment getServiceclientAssignment_7_2() { return cServiceclientAssignment_7_2; } + //MessageDefinition + public RuleCall getRequestMessageDefinitionParserRuleCall_5_1_0() { return cRequestMessageDefinitionParserRuleCall_5_1_0; } - //ServiceClient - public RuleCall getServiceclientServiceClientParserRuleCall_7_2_0() { return cServiceclientServiceClientParserRuleCall_7_2_0; } + //END + public RuleCall getENDTerminalRuleCall_5_2() { return cENDTerminalRuleCall_5_2; } - //( "," serviceclient+=ServiceClient)* - public Group getGroup_7_3() { return cGroup_7_3; } + //'response:' + public Keyword getResponseKeyword_6() { return cResponseKeyword_6; } - //"," - public Keyword getCommaKeyword_7_3_0() { return cCommaKeyword_7_3_0; } + //(BEGIN response=MessageDefinition END)? + public Group getGroup_7() { return cGroup_7; } - //serviceclient+=ServiceClient - public Assignment getServiceclientAssignment_7_3_1() { return cServiceclientAssignment_7_3_1; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_7_0() { return cBEGINTerminalRuleCall_7_0; } - //ServiceClient - public RuleCall getServiceclientServiceClientParserRuleCall_7_3_1_0() { return cServiceclientServiceClientParserRuleCall_7_3_1_0; } + //response=MessageDefinition + public Assignment getResponseAssignment_7_1() { return cResponseAssignment_7_1; } - //'}' - public Keyword getRightCurlyBracketKeyword_7_4() { return cRightCurlyBracketKeyword_7_4; } + //MessageDefinition + public RuleCall getResponseMessageDefinitionParserRuleCall_7_1_0() { return cResponseMessageDefinitionParserRuleCall_7_1_0; } + + //END + public RuleCall getENDTerminalRuleCall_7_2() { return cENDTerminalRuleCall_7_2; } + + //END + public RuleCall getENDTerminalRuleCall_8() { return cENDTerminalRuleCall_8; } + } + public class ActionSpecElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ActionSpec"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cActionSpecAction_0 = (Action)cGroup.eContents().get(0); + private final Keyword cActionKeyword_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); + private final RuleCall cBEGINTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); + private final Keyword cGoalKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Group cGroup_5 = (Group)cGroup.eContents().get(5); + private final RuleCall cBEGINTerminalRuleCall_5_0 = (RuleCall)cGroup_5.eContents().get(0); + private final Assignment cGoalAssignment_5_1 = (Assignment)cGroup_5.eContents().get(1); + private final RuleCall cGoalMessageDefinitionParserRuleCall_5_1_0 = (RuleCall)cGoalAssignment_5_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_5_2 = (RuleCall)cGroup_5.eContents().get(2); + private final Keyword cResultKeyword_6 = (Keyword)cGroup.eContents().get(6); + private final Group cGroup_7 = (Group)cGroup.eContents().get(7); + private final RuleCall cBEGINTerminalRuleCall_7_0 = (RuleCall)cGroup_7.eContents().get(0); + private final Assignment cResultAssignment_7_1 = (Assignment)cGroup_7.eContents().get(1); + private final RuleCall cResultMessageDefinitionParserRuleCall_7_1_0 = (RuleCall)cResultAssignment_7_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_7_2 = (RuleCall)cGroup_7.eContents().get(2); + private final Keyword cFeedbackKeyword_8 = (Keyword)cGroup.eContents().get(8); + private final Group cGroup_9 = (Group)cGroup.eContents().get(9); + private final RuleCall cBEGINTerminalRuleCall_9_0 = (RuleCall)cGroup_9.eContents().get(0); + private final Assignment cFeedbackAssignment_9_1 = (Assignment)cGroup_9.eContents().get(1); + private final RuleCall cFeedbackMessageDefinitionParserRuleCall_9_1_0 = (RuleCall)cFeedbackAssignment_9_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_9_2 = (RuleCall)cGroup_9.eContents().get(2); + private final RuleCall cENDTerminalRuleCall_10 = (RuleCall)cGroup.eContents().get(10); - //('ActionServers' '{' actionserver+=ActionServer ( "," actionserver+=ActionServer)* '}')? - public Group getGroup_8() { return cGroup_8; } + //ActionSpec returns ActionSpec: + // {ActionSpec} + // 'action:'name=EString + // BEGIN + // 'goal:' (BEGIN goal=MessageDefinition END)? + // 'result:' (BEGIN result=MessageDefinition END)? + // 'feedback:' (BEGIN feedback=MessageDefinition END)? + // END; + @Override public ParserRule getRule() { return rule; } - //'ActionServers' - public Keyword getActionServersKeyword_8_0() { return cActionServersKeyword_8_0; } + //{ActionSpec} + //'action:'name=EString + //BEGIN + // 'goal:' (BEGIN goal=MessageDefinition END)? + // 'result:' (BEGIN result=MessageDefinition END)? + // 'feedback:' (BEGIN feedback=MessageDefinition END)? + //END + public Group getGroup() { return cGroup; } - //'{' - public Keyword getLeftCurlyBracketKeyword_8_1() { return cLeftCurlyBracketKeyword_8_1; } + //{ActionSpec} + public Action getActionSpecAction_0() { return cActionSpecAction_0; } - //actionserver+=ActionServer - public Assignment getActionserverAssignment_8_2() { return cActionserverAssignment_8_2; } + //'action:' + public Keyword getActionKeyword_1() { return cActionKeyword_1; } - //ActionServer - public RuleCall getActionserverActionServerParserRuleCall_8_2_0() { return cActionserverActionServerParserRuleCall_8_2_0; } + //name=EString + public Assignment getNameAssignment_2() { return cNameAssignment_2; } - //( "," actionserver+=ActionServer)* - public Group getGroup_8_3() { return cGroup_8_3; } + //EString + public RuleCall getNameEStringParserRuleCall_2_0() { return cNameEStringParserRuleCall_2_0; } - //"," - public Keyword getCommaKeyword_8_3_0() { return cCommaKeyword_8_3_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } - //actionserver+=ActionServer - public Assignment getActionserverAssignment_8_3_1() { return cActionserverAssignment_8_3_1; } + //'goal:' + public Keyword getGoalKeyword_4() { return cGoalKeyword_4; } - //ActionServer - public RuleCall getActionserverActionServerParserRuleCall_8_3_1_0() { return cActionserverActionServerParserRuleCall_8_3_1_0; } + //(BEGIN goal=MessageDefinition END)? + public Group getGroup_5() { return cGroup_5; } - //'}' - public Keyword getRightCurlyBracketKeyword_8_4() { return cRightCurlyBracketKeyword_8_4; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_5_0() { return cBEGINTerminalRuleCall_5_0; } - //('ActionClients' '{' actionclient+=ActionClient ( "," actionclient+=ActionClient)* '}' )? - public Group getGroup_9() { return cGroup_9; } + //goal=MessageDefinition + public Assignment getGoalAssignment_5_1() { return cGoalAssignment_5_1; } - //'ActionClients' - public Keyword getActionClientsKeyword_9_0() { return cActionClientsKeyword_9_0; } + //MessageDefinition + public RuleCall getGoalMessageDefinitionParserRuleCall_5_1_0() { return cGoalMessageDefinitionParserRuleCall_5_1_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_9_1() { return cLeftCurlyBracketKeyword_9_1; } + //END + public RuleCall getENDTerminalRuleCall_5_2() { return cENDTerminalRuleCall_5_2; } - //actionclient+=ActionClient - public Assignment getActionclientAssignment_9_2() { return cActionclientAssignment_9_2; } + //'result:' + public Keyword getResultKeyword_6() { return cResultKeyword_6; } - //ActionClient - public RuleCall getActionclientActionClientParserRuleCall_9_2_0() { return cActionclientActionClientParserRuleCall_9_2_0; } + //(BEGIN result=MessageDefinition END)? + public Group getGroup_7() { return cGroup_7; } - //( "," actionclient+=ActionClient)* - public Group getGroup_9_3() { return cGroup_9_3; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_7_0() { return cBEGINTerminalRuleCall_7_0; } - //"," - public Keyword getCommaKeyword_9_3_0() { return cCommaKeyword_9_3_0; } + //result=MessageDefinition + public Assignment getResultAssignment_7_1() { return cResultAssignment_7_1; } - //actionclient+=ActionClient - public Assignment getActionclientAssignment_9_3_1() { return cActionclientAssignment_9_3_1; } + //MessageDefinition + public RuleCall getResultMessageDefinitionParserRuleCall_7_1_0() { return cResultMessageDefinitionParserRuleCall_7_1_0; } - //ActionClient - public RuleCall getActionclientActionClientParserRuleCall_9_3_1_0() { return cActionclientActionClientParserRuleCall_9_3_1_0; } + //END + public RuleCall getENDTerminalRuleCall_7_2() { return cENDTerminalRuleCall_7_2; } - //'}' - public Keyword getRightCurlyBracketKeyword_9_4() { return cRightCurlyBracketKeyword_9_4; } + //'feedback:' + public Keyword getFeedbackKeyword_8() { return cFeedbackKeyword_8; } - //('Parameters' '{' parameter+=Parameter ( "," parameter+=Parameter)* '}' )? - public Group getGroup_10() { return cGroup_10; } + //(BEGIN feedback=MessageDefinition END)? + public Group getGroup_9() { return cGroup_9; } - //'Parameters' - public Keyword getParametersKeyword_10_0() { return cParametersKeyword_10_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_9_0() { return cBEGINTerminalRuleCall_9_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_10_1() { return cLeftCurlyBracketKeyword_10_1; } + //feedback=MessageDefinition + public Assignment getFeedbackAssignment_9_1() { return cFeedbackAssignment_9_1; } - //parameter+=Parameter - public Assignment getParameterAssignment_10_2() { return cParameterAssignment_10_2; } + //MessageDefinition + public RuleCall getFeedbackMessageDefinitionParserRuleCall_9_1_0() { return cFeedbackMessageDefinitionParserRuleCall_9_1_0; } - //Parameter - public RuleCall getParameterParameterParserRuleCall_10_2_0() { return cParameterParameterParserRuleCall_10_2_0; } + //END + public RuleCall getENDTerminalRuleCall_9_2() { return cENDTerminalRuleCall_9_2; } - //( "," parameter+=Parameter)* - public Group getGroup_10_3() { return cGroup_10_3; } + //END + public RuleCall getENDTerminalRuleCall_10() { return cENDTerminalRuleCall_10; } + } + public class MessageDefinitionElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cMessageDefinitionAction_0 = (Action)cGroup.eContents().get(0); + private final Assignment cMessagePartAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cMessagePartMessagePartParserRuleCall_1_0 = (RuleCall)cMessagePartAssignment_1.eContents().get(0); - //"," - public Keyword getCommaKeyword_10_3_0() { return cCommaKeyword_10_3_0; } + //MessageDefinition returns MessageDefinition: + // {MessageDefinition} + // MessagePart+=MessagePart*; + @Override public ParserRule getRule() { return rule; } - //parameter+=Parameter - public Assignment getParameterAssignment_10_3_1() { return cParameterAssignment_10_3_1; } + //{MessageDefinition} + // MessagePart+=MessagePart* + public Group getGroup() { return cGroup; } - //Parameter - public RuleCall getParameterParameterParserRuleCall_10_3_1_0() { return cParameterParameterParserRuleCall_10_3_1_0; } + //{MessageDefinition} + public Action getMessageDefinitionAction_0() { return cMessageDefinitionAction_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_10_4() { return cRightCurlyBracketKeyword_10_4; } + //MessagePart+=MessagePart* + public Assignment getMessagePartAssignment_1() { return cMessagePartAssignment_1; } - //'}' - public Keyword getRightCurlyBracketKeyword_11() { return cRightCurlyBracketKeyword_11; } + //MessagePart + public RuleCall getMessagePartMessagePartParserRuleCall_1_0() { return cMessagePartMessagePartParserRuleCall_1_0; } } - public class ServiceServerElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ServiceServer"); + public class PublisherElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Publisher"); private final Group cGroup = (Group)rule.eContents().get(1); - private final Keyword cServiceServerKeyword_0 = (Keyword)cGroup.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cNameKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Assignment cNameAssignment_3 = (Assignment)cGroup.eContents().get(3); - private final RuleCall cNameEStringParserRuleCall_3_0 = (RuleCall)cNameAssignment_3.eContents().get(0); - private final Keyword cServiceKeyword_4 = (Keyword)cGroup.eContents().get(4); - private final Assignment cServiceAssignment_5 = (Assignment)cGroup.eContents().get(5); - private final CrossReference cServiceServiceSpecCrossReference_5_0 = (CrossReference)cServiceAssignment_5.eContents().get(0); - private final RuleCall cServiceServiceSpecEStringParserRuleCall_5_0_1 = (RuleCall)cServiceServiceSpecCrossReference_5_0.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 Group cGroup_6 = (Group)cGroup.eContents().get(6); - private final Keyword cNamespaceKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_7 = (Keyword)cGroup.eContents().get(7); + private final RuleCall cENDTerminalRuleCall_7 = (RuleCall)cGroup.eContents().get(7); - //ServiceServer returns ServiceServer: - // 'ServiceServer' - // '{' - // 'name' name=EString - // 'service' service=[ServiceSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; + ///////////////////// + ////INTERFACES + ///////////////////// + //Publisher returns Publisher: + // {Publisher} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; @Override public ParserRule getRule() { return rule; } - //'ServiceServer' - //'{' - // 'name' name=EString - // 'service' service=[ServiceSpec|EString] - // ('namespace' namespace=Namespace)? - //'}' + //{Publisher} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // END public Group getGroup() { return cGroup; } - //'ServiceServer' - public Keyword getServiceServerKeyword_0() { return cServiceServerKeyword_0; } - - //'{' - public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } - - //'name' - public Keyword getNameKeyword_2() { return cNameKeyword_2; } + //{Publisher} + public Action getPublisherAction_0() { return cPublisherAction_0; } //name=EString - public Assignment getNameAssignment_3() { return cNameAssignment_3; } + public Assignment getNameAssignment_1() { return cNameAssignment_1; } //EString - public RuleCall getNameEStringParserRuleCall_3_0() { return cNameEStringParserRuleCall_3_0; } + public RuleCall getNameEStringParserRuleCall_1_0() { return cNameEStringParserRuleCall_1_0; } - //'service' - public Keyword getServiceKeyword_4() { return cServiceKeyword_4; } + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } - //service=[ServiceSpec|EString] - public Assignment getServiceAssignment_5() { return cServiceAssignment_5; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } - //[ServiceSpec|EString] - public CrossReference getServiceServiceSpecCrossReference_5_0() { return cServiceServiceSpecCrossReference_5_0; } + //'type:' + public Keyword getTypeKeyword_4() { return cTypeKeyword_4; } + + //message=[TopicSpec|EString] + public Assignment getMessageAssignment_5() { return cMessageAssignment_5; } + + //[TopicSpec|EString] + public CrossReference getMessageTopicSpecCrossReference_5_0() { return cMessageTopicSpecCrossReference_5_0; } //EString - public RuleCall getServiceServiceSpecEStringParserRuleCall_5_0_1() { return cServiceServiceSpecEStringParserRuleCall_5_0_1; } + public RuleCall getMessageTopicSpecEStringParserRuleCall_5_0_1() { return cMessageTopicSpecEStringParserRuleCall_5_0_1; } - //('namespace' namespace=Namespace)? + //('ns:' namespace=Namespace)? public Group getGroup_6() { return cGroup_6; } - //'namespace' - public Keyword getNamespaceKeyword_6_0() { return cNamespaceKeyword_6_0; } + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } //namespace=Namespace public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } @@ -1481,61 +1355,62 @@ public class ServiceServerElements extends AbstractParserRuleElementFinder { //Namespace public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_7() { return cRightCurlyBracketKeyword_7; } + //END + public RuleCall getENDTerminalRuleCall_7() { return cENDTerminalRuleCall_7; } } - public class PublisherElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Publisher"); + public class SubscriberElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Subscriber"); private final Group cGroup = (Group)rule.eContents().get(1); - private final Keyword cPublisherKeyword_0 = (Keyword)cGroup.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cNameKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Assignment cNameAssignment_3 = (Assignment)cGroup.eContents().get(3); - private final RuleCall cNameEStringParserRuleCall_3_0 = (RuleCall)cNameAssignment_3.eContents().get(0); - private final Keyword cMessageKeyword_4 = (Keyword)cGroup.eContents().get(4); + 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 Group cGroup_6 = (Group)cGroup.eContents().get(6); - private final Keyword cNamespaceKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_7 = (Keyword)cGroup.eContents().get(7); + private final RuleCall cENDTerminalRuleCall_7 = (RuleCall)cGroup.eContents().get(7); - //Publisher returns Publisher: - // 'Publisher' - // '{' - // 'name' name=EString - // 'message' message=[TopicSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; + //Subscriber returns Subscriber: + // {Subscriber} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; @Override public ParserRule getRule() { return rule; } - //'Publisher' - //'{' - // 'name' name=EString - // 'message' message=[TopicSpec|EString] - // ('namespace' namespace=Namespace)? - //'}' + //{Subscriber} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // END public Group getGroup() { return cGroup; } - //'Publisher' - public Keyword getPublisherKeyword_0() { return cPublisherKeyword_0; } - - //'{' - public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } - - //'name' - public Keyword getNameKeyword_2() { return cNameKeyword_2; } + //{Subscriber} + public Action getSubscriberAction_0() { return cSubscriberAction_0; } //name=EString - public Assignment getNameAssignment_3() { return cNameAssignment_3; } + public Assignment getNameAssignment_1() { return cNameAssignment_1; } //EString - public RuleCall getNameEStringParserRuleCall_3_0() { return cNameEStringParserRuleCall_3_0; } + public RuleCall getNameEStringParserRuleCall_1_0() { return cNameEStringParserRuleCall_1_0; } - //'message' - public Keyword getMessageKeyword_4() { return cMessageKeyword_4; } + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } + + //'type:' + public Keyword getTypeKeyword_4() { return cTypeKeyword_4; } //message=[TopicSpec|EString] public Assignment getMessageAssignment_5() { return cMessageAssignment_5; } @@ -1546,11 +1421,11 @@ public class PublisherElements extends AbstractParserRuleElementFinder { //EString public RuleCall getMessageTopicSpecEStringParserRuleCall_5_0_1() { return cMessageTopicSpecEStringParserRuleCall_5_0_1; } - //('namespace' namespace=Namespace)? + //('ns:' namespace=Namespace)? public Group getGroup_6() { return cGroup_6; } - //'namespace' - public Keyword getNamespaceKeyword_6_0() { return cNamespaceKeyword_6_0; } + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } //namespace=Namespace public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } @@ -1558,76 +1433,77 @@ public class PublisherElements extends AbstractParserRuleElementFinder { //Namespace public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_7() { return cRightCurlyBracketKeyword_7; } + //END + public RuleCall getENDTerminalRuleCall_7() { return cENDTerminalRuleCall_7; } } - public class SubscriberElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Subscriber"); + public class ServiceServerElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ServiceServer"); private final Group cGroup = (Group)rule.eContents().get(1); - private final Keyword cSubscriberKeyword_0 = (Keyword)cGroup.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cNameKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Assignment cNameAssignment_3 = (Assignment)cGroup.eContents().get(3); - private final RuleCall cNameEStringParserRuleCall_3_0 = (RuleCall)cNameAssignment_3.eContents().get(0); - private final Keyword cMessageKeyword_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 Action cServiceServerAction_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 cServiceAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final CrossReference cServiceServiceSpecCrossReference_5_0 = (CrossReference)cServiceAssignment_5.eContents().get(0); + private final RuleCall cServiceServiceSpecEStringParserRuleCall_5_0_1 = (RuleCall)cServiceServiceSpecCrossReference_5_0.eContents().get(1); private final Group cGroup_6 = (Group)cGroup.eContents().get(6); - private final Keyword cNamespaceKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_7 = (Keyword)cGroup.eContents().get(7); + private final RuleCall cENDTerminalRuleCall_7 = (RuleCall)cGroup.eContents().get(7); - //Subscriber returns Subscriber: - // 'Subscriber' - // '{' - // 'name' name=EString - // 'message' message=[TopicSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; + //ServiceServer returns ServiceServer: + // {ServiceServer} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; @Override public ParserRule getRule() { return rule; } - //'Subscriber' - //'{' - // 'name' name=EString - // 'message' message=[TopicSpec|EString] - // ('namespace' namespace=Namespace)? - //'}' + //{ServiceServer} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // END public Group getGroup() { return cGroup; } - //'Subscriber' - public Keyword getSubscriberKeyword_0() { return cSubscriberKeyword_0; } - - //'{' - public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } - - //'name' - public Keyword getNameKeyword_2() { return cNameKeyword_2; } + //{ServiceServer} + public Action getServiceServerAction_0() { return cServiceServerAction_0; } //name=EString - public Assignment getNameAssignment_3() { return cNameAssignment_3; } + public Assignment getNameAssignment_1() { return cNameAssignment_1; } //EString - public RuleCall getNameEStringParserRuleCall_3_0() { return cNameEStringParserRuleCall_3_0; } + public RuleCall getNameEStringParserRuleCall_1_0() { return cNameEStringParserRuleCall_1_0; } - //'message' - public Keyword getMessageKeyword_4() { return cMessageKeyword_4; } + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } - //message=[TopicSpec|EString] - public Assignment getMessageAssignment_5() { return cMessageAssignment_5; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } - //[TopicSpec|EString] - public CrossReference getMessageTopicSpecCrossReference_5_0() { return cMessageTopicSpecCrossReference_5_0; } + //'type:' + public Keyword getTypeKeyword_4() { return cTypeKeyword_4; } + + //service=[ServiceSpec|EString] + public Assignment getServiceAssignment_5() { return cServiceAssignment_5; } + + //[ServiceSpec|EString] + public CrossReference getServiceServiceSpecCrossReference_5_0() { return cServiceServiceSpecCrossReference_5_0; } //EString - public RuleCall getMessageTopicSpecEStringParserRuleCall_5_0_1() { return cMessageTopicSpecEStringParserRuleCall_5_0_1; } + public RuleCall getServiceServiceSpecEStringParserRuleCall_5_0_1() { return cServiceServiceSpecEStringParserRuleCall_5_0_1; } - //('namespace' namespace=Namespace)? + //('ns:' namespace=Namespace)? public Group getGroup_6() { return cGroup_6; } - //'namespace' - public Keyword getNamespaceKeyword_6_0() { return cNamespaceKeyword_6_0; } + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } //namespace=Namespace public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } @@ -1635,61 +1511,62 @@ public class SubscriberElements extends AbstractParserRuleElementFinder { //Namespace public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_7() { return cRightCurlyBracketKeyword_7; } + //END + public RuleCall getENDTerminalRuleCall_7() { return cENDTerminalRuleCall_7; } } public class ServiceClientElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ServiceClient"); private final Group cGroup = (Group)rule.eContents().get(1); - private final Keyword cServiceClientKeyword_0 = (Keyword)cGroup.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cNameKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Assignment cNameAssignment_3 = (Assignment)cGroup.eContents().get(3); - private final RuleCall cNameEStringParserRuleCall_3_0 = (RuleCall)cNameAssignment_3.eContents().get(0); - private final Keyword cServiceKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Action cServiceClientAction_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 cServiceAssignment_5 = (Assignment)cGroup.eContents().get(5); private final CrossReference cServiceServiceSpecCrossReference_5_0 = (CrossReference)cServiceAssignment_5.eContents().get(0); private final RuleCall cServiceServiceSpecEStringParserRuleCall_5_0_1 = (RuleCall)cServiceServiceSpecCrossReference_5_0.eContents().get(1); private final Group cGroup_6 = (Group)cGroup.eContents().get(6); - private final Keyword cNamespaceKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_7 = (Keyword)cGroup.eContents().get(7); + private final RuleCall cENDTerminalRuleCall_7 = (RuleCall)cGroup.eContents().get(7); //ServiceClient returns ServiceClient: - // 'ServiceClient' - // '{' - // 'name' name=EString - // 'service' service=[ServiceSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; + // {ServiceClient} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; @Override public ParserRule getRule() { return rule; } - //'ServiceClient' - //'{' - // 'name' name=EString - // 'service' service=[ServiceSpec|EString] - // ('namespace' namespace=Namespace)? - //'}' + //{ServiceClient} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // END public Group getGroup() { return cGroup; } - //'ServiceClient' - public Keyword getServiceClientKeyword_0() { return cServiceClientKeyword_0; } - - //'{' - public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } - - //'name' - public Keyword getNameKeyword_2() { return cNameKeyword_2; } + //{ServiceClient} + public Action getServiceClientAction_0() { return cServiceClientAction_0; } //name=EString - public Assignment getNameAssignment_3() { return cNameAssignment_3; } + public Assignment getNameAssignment_1() { return cNameAssignment_1; } //EString - public RuleCall getNameEStringParserRuleCall_3_0() { return cNameEStringParserRuleCall_3_0; } + public RuleCall getNameEStringParserRuleCall_1_0() { return cNameEStringParserRuleCall_1_0; } - //'service' - public Keyword getServiceKeyword_4() { return cServiceKeyword_4; } + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } + + //'type:' + public Keyword getTypeKeyword_4() { return cTypeKeyword_4; } //service=[ServiceSpec|EString] public Assignment getServiceAssignment_5() { return cServiceAssignment_5; } @@ -1700,11 +1577,11 @@ public class ServiceClientElements extends AbstractParserRuleElementFinder { //EString public RuleCall getServiceServiceSpecEStringParserRuleCall_5_0_1() { return cServiceServiceSpecEStringParserRuleCall_5_0_1; } - //('namespace' namespace=Namespace)? + //('ns:' namespace=Namespace)? public Group getGroup_6() { return cGroup_6; } - //'namespace' - public Keyword getNamespaceKeyword_6_0() { return cNamespaceKeyword_6_0; } + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } //namespace=Namespace public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } @@ -1712,61 +1589,62 @@ public class ServiceClientElements extends AbstractParserRuleElementFinder { //Namespace public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_7() { return cRightCurlyBracketKeyword_7; } + //END + public RuleCall getENDTerminalRuleCall_7() { return cENDTerminalRuleCall_7; } } public class ActionServerElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ActionServer"); private final Group cGroup = (Group)rule.eContents().get(1); - private final Keyword cActionServerKeyword_0 = (Keyword)cGroup.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cNameKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Assignment cNameAssignment_3 = (Assignment)cGroup.eContents().get(3); - private final RuleCall cNameEStringParserRuleCall_3_0 = (RuleCall)cNameAssignment_3.eContents().get(0); - private final Keyword cActionKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Action cActionServerAction_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 cActionAssignment_5 = (Assignment)cGroup.eContents().get(5); private final CrossReference cActionActionSpecCrossReference_5_0 = (CrossReference)cActionAssignment_5.eContents().get(0); private final RuleCall cActionActionSpecEStringParserRuleCall_5_0_1 = (RuleCall)cActionActionSpecCrossReference_5_0.eContents().get(1); private final Group cGroup_6 = (Group)cGroup.eContents().get(6); - private final Keyword cNamespaceKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_7 = (Keyword)cGroup.eContents().get(7); + private final RuleCall cENDTerminalRuleCall_7 = (RuleCall)cGroup.eContents().get(7); //ActionServer returns ActionServer: - // 'ActionServer' - // '{' - // 'name' name=EString - // 'action' action=[ActionSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; + // {ActionServer} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; @Override public ParserRule getRule() { return rule; } - //'ActionServer' - //'{' - // 'name' name=EString - // 'action' action=[ActionSpec|EString] - // ('namespace' namespace=Namespace)? - //'}' + //{ActionServer} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // END public Group getGroup() { return cGroup; } - //'ActionServer' - public Keyword getActionServerKeyword_0() { return cActionServerKeyword_0; } - - //'{' - public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } - - //'name' - public Keyword getNameKeyword_2() { return cNameKeyword_2; } + //{ActionServer} + public Action getActionServerAction_0() { return cActionServerAction_0; } //name=EString - public Assignment getNameAssignment_3() { return cNameAssignment_3; } + public Assignment getNameAssignment_1() { return cNameAssignment_1; } //EString - public RuleCall getNameEStringParserRuleCall_3_0() { return cNameEStringParserRuleCall_3_0; } + public RuleCall getNameEStringParserRuleCall_1_0() { return cNameEStringParserRuleCall_1_0; } - //'action' - public Keyword getActionKeyword_4() { return cActionKeyword_4; } + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } + + //'type:' + public Keyword getTypeKeyword_4() { return cTypeKeyword_4; } //action=[ActionSpec|EString] public Assignment getActionAssignment_5() { return cActionAssignment_5; } @@ -1777,11 +1655,11 @@ public class ActionServerElements extends AbstractParserRuleElementFinder { //EString public RuleCall getActionActionSpecEStringParserRuleCall_5_0_1() { return cActionActionSpecEStringParserRuleCall_5_0_1; } - //('namespace' namespace=Namespace)? + //('ns:' namespace=Namespace)? public Group getGroup_6() { return cGroup_6; } - //'namespace' - public Keyword getNamespaceKeyword_6_0() { return cNamespaceKeyword_6_0; } + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } //namespace=Namespace public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } @@ -1789,61 +1667,62 @@ public class ActionServerElements extends AbstractParserRuleElementFinder { //Namespace public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_7() { return cRightCurlyBracketKeyword_7; } + //END + public RuleCall getENDTerminalRuleCall_7() { return cENDTerminalRuleCall_7; } } public class ActionClientElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ActionClient"); private final Group cGroup = (Group)rule.eContents().get(1); - private final Keyword cActionClientKeyword_0 = (Keyword)cGroup.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cNameKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Assignment cNameAssignment_3 = (Assignment)cGroup.eContents().get(3); - private final RuleCall cNameEStringParserRuleCall_3_0 = (RuleCall)cNameAssignment_3.eContents().get(0); - private final Keyword cActionKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Action cActionClientAction_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 cActionAssignment_5 = (Assignment)cGroup.eContents().get(5); private final CrossReference cActionActionSpecCrossReference_5_0 = (CrossReference)cActionAssignment_5.eContents().get(0); private final RuleCall cActionActionSpecEStringParserRuleCall_5_0_1 = (RuleCall)cActionActionSpecCrossReference_5_0.eContents().get(1); private final Group cGroup_6 = (Group)cGroup.eContents().get(6); - private final Keyword cNamespaceKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_7 = (Keyword)cGroup.eContents().get(7); + private final RuleCall cENDTerminalRuleCall_7 = (RuleCall)cGroup.eContents().get(7); //ActionClient returns ActionClient: - // 'ActionClient' - // '{' - // 'name' name=EString - // 'action' action=[ActionSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; + // {ActionClient} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; @Override public ParserRule getRule() { return rule; } - //'ActionClient' - //'{' - // 'name' name=EString - // 'action' action=[ActionSpec|EString] - // ('namespace' namespace=Namespace)? - //'}' + //{ActionClient} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // END public Group getGroup() { return cGroup; } - //'ActionClient' - public Keyword getActionClientKeyword_0() { return cActionClientKeyword_0; } - - //'{' - public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } - - //'name' - public Keyword getNameKeyword_2() { return cNameKeyword_2; } + //{ActionClient} + public Action getActionClientAction_0() { return cActionClientAction_0; } //name=EString - public Assignment getNameAssignment_3() { return cNameAssignment_3; } + public Assignment getNameAssignment_1() { return cNameAssignment_1; } //EString - public RuleCall getNameEStringParserRuleCall_3_0() { return cNameEStringParserRuleCall_3_0; } + public RuleCall getNameEStringParserRuleCall_1_0() { return cNameEStringParserRuleCall_1_0; } - //'action' - public Keyword getActionKeyword_4() { return cActionKeyword_4; } + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } + + //'type:' + public Keyword getTypeKeyword_4() { return cTypeKeyword_4; } //action=[ActionSpec|EString] public Assignment getActionAssignment_5() { return cActionAssignment_5; } @@ -1854,11 +1733,11 @@ public class ActionClientElements extends AbstractParserRuleElementFinder { //EString public RuleCall getActionActionSpecEStringParserRuleCall_5_0_1() { return cActionActionSpecEStringParserRuleCall_5_0_1; } - //('namespace' namespace=Namespace)? + //('ns:' namespace=Namespace)? public Group getGroup_6() { return cGroup_6; } - //'namespace' - public Keyword getNamespaceKeyword_6_0() { return cNamespaceKeyword_6_0; } + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } //namespace=Namespace public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } @@ -1866,19 +1745,30 @@ public class ActionClientElements extends AbstractParserRuleElementFinder { //Namespace public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_7() { return cRightCurlyBracketKeyword_7; } + //END + public RuleCall getENDTerminalRuleCall_7() { return cENDTerminalRuleCall_7; } } - public class GraphNameElements extends AbstractParserRuleElementFinder { - private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.GraphName"); - private final Keyword cGraphNameKeyword = (Keyword)rule.eContents().get(1); + public class DependencyElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.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); - //GraphName returns GraphName: - // 'GraphName' ; + ///////////////////// + ////DEPENDENCIES + ///////////////////// + //Dependency returns Dependency: + // PackageDependency | ExternalDependency; @Override public ParserRule getRule() { return rule; } - //'GraphName' - public Keyword getGraphNameKeyword() { return cGraphNameKeyword; } + //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.ros.Ros.PackageDependency"); @@ -1887,8 +1777,7 @@ public class PackageDependencyElements extends AbstractParserRuleElementFinder { private final RuleCall cPackagePackageEStringParserRuleCall_0_1 = (RuleCall)cPackagePackageCrossReference_0.eContents().get(1); //PackageDependency returns PackageDependency: - // package=[Package|EString] - //; + // package=[Package|EString]; @Override public ParserRule getRule() { return rule; } //package=[Package|EString] @@ -1931,37 +1820,67 @@ public class ExternalDependencyElements extends AbstractParserRuleElementFinder //EString public RuleCall getNameEStringParserRuleCall_2_0() { return cNameEStringParserRuleCall_2_0; } } + public class NamespaceElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Namespace"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cGlobalNamespaceParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cRelativeNamespace_ImplParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + private final RuleCall cPrivateNamespaceParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); + + ///////////////////// + ////NAMESPACES + ///////////////////// + //Namespace returns Namespace: + // GlobalNamespace | RelativeNamespace_Impl | PrivateNamespace; + @Override public ParserRule getRule() { return rule; } + + //GlobalNamespace | RelativeNamespace_Impl | PrivateNamespace + public Alternatives getAlternatives() { return cAlternatives; } + + //GlobalNamespace + public RuleCall getGlobalNamespaceParserRuleCall_0() { return cGlobalNamespaceParserRuleCall_0; } + + //RelativeNamespace_Impl + public RuleCall getRelativeNamespace_ImplParserRuleCall_1() { return cRelativeNamespace_ImplParserRuleCall_1; } + + //PrivateNamespace + public RuleCall getPrivateNamespaceParserRuleCall_2() { return cPrivateNamespaceParserRuleCall_2; } + } + public class GraphNameElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.GraphName"); + private final Keyword cGraphNameKeyword = (Keyword)rule.eContents().get(1); + + //GraphName returns GraphName: + // 'GraphName' ; + @Override public ParserRule getRule() { return rule; } + + //'GraphName' + public Keyword getGraphNameKeyword() { return cGraphNameKeyword; } + } public class GlobalNamespaceElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.GlobalNamespace"); private final Group cGroup = (Group)rule.eContents().get(1); private final Action cGlobalNamespaceAction_0 = (Action)cGroup.eContents().get(0); private final Keyword cGlobalNamespaceKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Group cGroup_3 = (Group)cGroup.eContents().get(3); - private final Keyword cPartsKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_3_1 = (Keyword)cGroup_3.eContents().get(1); - private final Assignment cPartsAssignment_3_2 = (Assignment)cGroup_3.eContents().get(2); - private final RuleCall cPartsGraphNameParserRuleCall_3_2_0 = (RuleCall)cPartsAssignment_3_2.eContents().get(0); - private final Group cGroup_3_3 = (Group)cGroup_3.eContents().get(3); - private final Keyword cCommaKeyword_3_3_0 = (Keyword)cGroup_3_3.eContents().get(0); - private final Assignment cPartsAssignment_3_3_1 = (Assignment)cGroup_3_3.eContents().get(1); - private final RuleCall cPartsGraphNameParserRuleCall_3_3_1_0 = (RuleCall)cPartsAssignment_3_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_3_4 = (Keyword)cGroup_3.eContents().get(4); - private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Group cGroup_2 = (Group)cGroup.eContents().get(2); + private final Keyword cLeftSquareBracketKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); + private final Assignment cPartsAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); + private final RuleCall cPartsGraphNameParserRuleCall_2_1_0 = (RuleCall)cPartsAssignment_2_1.eContents().get(0); + private final Group cGroup_2_2 = (Group)cGroup_2.eContents().get(2); + private final Keyword cCommaKeyword_2_2_0 = (Keyword)cGroup_2_2.eContents().get(0); + private final Assignment cPartsAssignment_2_2_1 = (Assignment)cGroup_2_2.eContents().get(1); + private final RuleCall cPartsGraphNameParserRuleCall_2_2_1_0 = (RuleCall)cPartsAssignment_2_2_1.eContents().get(0); + private final Keyword cRightSquareBracketKeyword_2_3 = (Keyword)cGroup_2.eContents().get(3); //GlobalNamespace returns GlobalNamespace: // {GlobalNamespace} // 'GlobalNamespace' - // '{' - // ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - // '}'; + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; @Override public ParserRule getRule() { return rule; } //{GlobalNamespace} //'GlobalNamespace' - //'{' - // ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - //'}' + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )? public Group getGroup() { return cGroup; } //{GlobalNamespace} @@ -1970,73 +1889,57 @@ public class GlobalNamespaceElements extends AbstractParserRuleElementFinder { //'GlobalNamespace' public Keyword getGlobalNamespaceKeyword_1() { return cGlobalNamespaceKeyword_1; } - //'{' - public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; } - - //('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - public Group getGroup_3() { return cGroup_3; } - - //'parts' - public Keyword getPartsKeyword_3_0() { return cPartsKeyword_3_0; } + //('[' parts+=GraphName ( "," parts+=GraphName)* ']' )? + public Group getGroup_2() { return cGroup_2; } - //'{' - public Keyword getLeftCurlyBracketKeyword_3_1() { return cLeftCurlyBracketKeyword_3_1; } + //'[' + public Keyword getLeftSquareBracketKeyword_2_0() { return cLeftSquareBracketKeyword_2_0; } //parts+=GraphName - public Assignment getPartsAssignment_3_2() { return cPartsAssignment_3_2; } + public Assignment getPartsAssignment_2_1() { return cPartsAssignment_2_1; } //GraphName - public RuleCall getPartsGraphNameParserRuleCall_3_2_0() { return cPartsGraphNameParserRuleCall_3_2_0; } + public RuleCall getPartsGraphNameParserRuleCall_2_1_0() { return cPartsGraphNameParserRuleCall_2_1_0; } //( "," parts+=GraphName)* - public Group getGroup_3_3() { return cGroup_3_3; } + public Group getGroup_2_2() { return cGroup_2_2; } //"," - public Keyword getCommaKeyword_3_3_0() { return cCommaKeyword_3_3_0; } + public Keyword getCommaKeyword_2_2_0() { return cCommaKeyword_2_2_0; } //parts+=GraphName - public Assignment getPartsAssignment_3_3_1() { return cPartsAssignment_3_3_1; } + public Assignment getPartsAssignment_2_2_1() { return cPartsAssignment_2_2_1; } //GraphName - public RuleCall getPartsGraphNameParserRuleCall_3_3_1_0() { return cPartsGraphNameParserRuleCall_3_3_1_0; } - - //'}' - public Keyword getRightCurlyBracketKeyword_3_4() { return cRightCurlyBracketKeyword_3_4; } + public RuleCall getPartsGraphNameParserRuleCall_2_2_1_0() { return cPartsGraphNameParserRuleCall_2_2_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; } + //']' + public Keyword getRightSquareBracketKeyword_2_3() { return cRightSquareBracketKeyword_2_3; } } public class RelativeNamespace_ImplElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.RelativeNamespace_Impl"); private final Group cGroup = (Group)rule.eContents().get(1); private final Action cRelativeNamespaceAction_0 = (Action)cGroup.eContents().get(0); private final Keyword cRelativeNamespaceKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Group cGroup_3 = (Group)cGroup.eContents().get(3); - private final Keyword cPartsKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_3_1 = (Keyword)cGroup_3.eContents().get(1); - private final Assignment cPartsAssignment_3_2 = (Assignment)cGroup_3.eContents().get(2); - private final RuleCall cPartsGraphNameParserRuleCall_3_2_0 = (RuleCall)cPartsAssignment_3_2.eContents().get(0); - private final Group cGroup_3_3 = (Group)cGroup_3.eContents().get(3); - private final Keyword cCommaKeyword_3_3_0 = (Keyword)cGroup_3_3.eContents().get(0); - private final Assignment cPartsAssignment_3_3_1 = (Assignment)cGroup_3_3.eContents().get(1); - private final RuleCall cPartsGraphNameParserRuleCall_3_3_1_0 = (RuleCall)cPartsAssignment_3_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_3_4 = (Keyword)cGroup_3.eContents().get(4); - private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Group cGroup_2 = (Group)cGroup.eContents().get(2); + private final Keyword cLeftSquareBracketKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); + private final Assignment cPartsAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); + private final RuleCall cPartsGraphNameParserRuleCall_2_1_0 = (RuleCall)cPartsAssignment_2_1.eContents().get(0); + private final Group cGroup_2_2 = (Group)cGroup_2.eContents().get(2); + private final Keyword cCommaKeyword_2_2_0 = (Keyword)cGroup_2_2.eContents().get(0); + private final Assignment cPartsAssignment_2_2_1 = (Assignment)cGroup_2_2.eContents().get(1); + private final RuleCall cPartsGraphNameParserRuleCall_2_2_1_0 = (RuleCall)cPartsAssignment_2_2_1.eContents().get(0); + private final Keyword cRightSquareBracketKeyword_2_3 = (Keyword)cGroup_2.eContents().get(3); //RelativeNamespace_Impl returns RelativeNamespace: // {RelativeNamespace} // 'RelativeNamespace' - // '{' - // ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - // '}'; + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; @Override public ParserRule getRule() { return rule; } //{RelativeNamespace} //'RelativeNamespace' - //'{' - // ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - //'}' + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )? public Group getGroup() { return cGroup; } //{RelativeNamespace} @@ -2045,73 +1948,57 @@ public class RelativeNamespace_ImplElements extends AbstractParserRuleElementFin //'RelativeNamespace' public Keyword getRelativeNamespaceKeyword_1() { return cRelativeNamespaceKeyword_1; } - //'{' - public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; } - - //('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - public Group getGroup_3() { return cGroup_3; } - - //'parts' - public Keyword getPartsKeyword_3_0() { return cPartsKeyword_3_0; } + //('[' parts+=GraphName ( "," parts+=GraphName)* ']' )? + public Group getGroup_2() { return cGroup_2; } - //'{' - public Keyword getLeftCurlyBracketKeyword_3_1() { return cLeftCurlyBracketKeyword_3_1; } + //'[' + public Keyword getLeftSquareBracketKeyword_2_0() { return cLeftSquareBracketKeyword_2_0; } //parts+=GraphName - public Assignment getPartsAssignment_3_2() { return cPartsAssignment_3_2; } + public Assignment getPartsAssignment_2_1() { return cPartsAssignment_2_1; } //GraphName - public RuleCall getPartsGraphNameParserRuleCall_3_2_0() { return cPartsGraphNameParserRuleCall_3_2_0; } + public RuleCall getPartsGraphNameParserRuleCall_2_1_0() { return cPartsGraphNameParserRuleCall_2_1_0; } //( "," parts+=GraphName)* - public Group getGroup_3_3() { return cGroup_3_3; } + public Group getGroup_2_2() { return cGroup_2_2; } //"," - public Keyword getCommaKeyword_3_3_0() { return cCommaKeyword_3_3_0; } + public Keyword getCommaKeyword_2_2_0() { return cCommaKeyword_2_2_0; } //parts+=GraphName - public Assignment getPartsAssignment_3_3_1() { return cPartsAssignment_3_3_1; } + public Assignment getPartsAssignment_2_2_1() { return cPartsAssignment_2_2_1; } //GraphName - public RuleCall getPartsGraphNameParserRuleCall_3_3_1_0() { return cPartsGraphNameParserRuleCall_3_3_1_0; } - - //'}' - public Keyword getRightCurlyBracketKeyword_3_4() { return cRightCurlyBracketKeyword_3_4; } + public RuleCall getPartsGraphNameParserRuleCall_2_2_1_0() { return cPartsGraphNameParserRuleCall_2_2_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; } + //']' + public Keyword getRightSquareBracketKeyword_2_3() { return cRightSquareBracketKeyword_2_3; } } public class PrivateNamespaceElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.PrivateNamespace"); private final Group cGroup = (Group)rule.eContents().get(1); private final Action cPrivateNamespaceAction_0 = (Action)cGroup.eContents().get(0); private final Keyword cPrivateNamespaceKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Group cGroup_3 = (Group)cGroup.eContents().get(3); - private final Keyword cPartsKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_3_1 = (Keyword)cGroup_3.eContents().get(1); - private final Assignment cPartsAssignment_3_2 = (Assignment)cGroup_3.eContents().get(2); - private final RuleCall cPartsGraphNameParserRuleCall_3_2_0 = (RuleCall)cPartsAssignment_3_2.eContents().get(0); - private final Group cGroup_3_3 = (Group)cGroup_3.eContents().get(3); - private final Keyword cCommaKeyword_3_3_0 = (Keyword)cGroup_3_3.eContents().get(0); - private final Assignment cPartsAssignment_3_3_1 = (Assignment)cGroup_3_3.eContents().get(1); - private final RuleCall cPartsGraphNameParserRuleCall_3_3_1_0 = (RuleCall)cPartsAssignment_3_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_3_4 = (Keyword)cGroup_3.eContents().get(4); - private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Group cGroup_2 = (Group)cGroup.eContents().get(2); + private final Keyword cLeftSquareBracketKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); + private final Assignment cPartsAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); + private final RuleCall cPartsGraphNameParserRuleCall_2_1_0 = (RuleCall)cPartsAssignment_2_1.eContents().get(0); + private final Group cGroup_2_2 = (Group)cGroup_2.eContents().get(2); + private final Keyword cCommaKeyword_2_2_0 = (Keyword)cGroup_2_2.eContents().get(0); + private final Assignment cPartsAssignment_2_2_1 = (Assignment)cGroup_2_2.eContents().get(1); + private final RuleCall cPartsGraphNameParserRuleCall_2_2_1_0 = (RuleCall)cPartsAssignment_2_2_1.eContents().get(0); + private final Keyword cRightSquareBracketKeyword_2_3 = (Keyword)cGroup_2.eContents().get(3); //PrivateNamespace returns PrivateNamespace: // {PrivateNamespace} // 'PrivateNamespace' - // '{' - // ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - // '}'; + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; @Override public ParserRule getRule() { return rule; } //{PrivateNamespace} //'PrivateNamespace' - //'{' - // ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - //'}' + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )? public Group getGroup() { return cGroup; } //{PrivateNamespace} @@ -2120,115 +2007,134 @@ public class PrivateNamespaceElements extends AbstractParserRuleElementFinder { //'PrivateNamespace' public Keyword getPrivateNamespaceKeyword_1() { return cPrivateNamespaceKeyword_1; } - //'{' - public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; } - - //('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - public Group getGroup_3() { return cGroup_3; } - - //'parts' - public Keyword getPartsKeyword_3_0() { return cPartsKeyword_3_0; } + //('[' parts+=GraphName ( "," parts+=GraphName)* ']' )? + public Group getGroup_2() { return cGroup_2; } - //'{' - public Keyword getLeftCurlyBracketKeyword_3_1() { return cLeftCurlyBracketKeyword_3_1; } + //'[' + public Keyword getLeftSquareBracketKeyword_2_0() { return cLeftSquareBracketKeyword_2_0; } //parts+=GraphName - public Assignment getPartsAssignment_3_2() { return cPartsAssignment_3_2; } + public Assignment getPartsAssignment_2_1() { return cPartsAssignment_2_1; } //GraphName - public RuleCall getPartsGraphNameParserRuleCall_3_2_0() { return cPartsGraphNameParserRuleCall_3_2_0; } + public RuleCall getPartsGraphNameParserRuleCall_2_1_0() { return cPartsGraphNameParserRuleCall_2_1_0; } //( "," parts+=GraphName)* - public Group getGroup_3_3() { return cGroup_3_3; } + public Group getGroup_2_2() { return cGroup_2_2; } //"," - public Keyword getCommaKeyword_3_3_0() { return cCommaKeyword_3_3_0; } + public Keyword getCommaKeyword_2_2_0() { return cCommaKeyword_2_2_0; } //parts+=GraphName - public Assignment getPartsAssignment_3_3_1() { return cPartsAssignment_3_3_1; } + public Assignment getPartsAssignment_2_2_1() { return cPartsAssignment_2_2_1; } //GraphName - public RuleCall getPartsGraphNameParserRuleCall_3_3_1_0() { return cPartsGraphNameParserRuleCall_3_3_1_0; } + public RuleCall getPartsGraphNameParserRuleCall_2_2_1_0() { return cPartsGraphNameParserRuleCall_2_2_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_3_4() { return cRightCurlyBracketKeyword_3_4; } + //']' + public Keyword getRightSquareBracketKeyword_2_3() { return cRightSquareBracketKeyword_2_3; } + } + public class RosParamNamesElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.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); - //'}' - public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; } + ///////////////////// + ////PARAMETERS DEFINITION + ///////////////////// + //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; } } public class ParameterElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.Parameter"); private final Group cGroup = (Group)rule.eContents().get(1); - private final Keyword cParameterKeyword_0 = (Keyword)cGroup.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cNameKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Assignment cNameAssignment_3 = (Assignment)cGroup.eContents().get(3); - private final RuleCall cNameEStringParserRuleCall_3_0 = (RuleCall)cNameAssignment_3.eContents().get(0); - private final Group cGroup_4 = (Group)cGroup.eContents().get(4); - private final Keyword cNamespaceKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); - private final Assignment cNamespaceAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1); - private final RuleCall cNamespaceNamespaceParserRuleCall_4_1_0 = (RuleCall)cNamespaceAssignment_4_1.eContents().get(0); - private final Keyword cTypeKeyword_5 = (Keyword)cGroup.eContents().get(5); - private final Assignment cTypeAssignment_6 = (Assignment)cGroup.eContents().get(6); - private final RuleCall cTypeParameterTypeParserRuleCall_6_0 = (RuleCall)cTypeAssignment_6.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_7 = (Keyword)cGroup.eContents().get(7); + 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 Keyword cTypeKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Assignment cTypeAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final RuleCall cTypeParameterTypeParserRuleCall_5_0 = (RuleCall)cTypeAssignment_5.eContents().get(0); + private final Group cGroup_6 = (Group)cGroup.eContents().get(6); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); + private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_7 = (RuleCall)cGroup.eContents().get(7); + private final Keyword cRightCurlyBracketKeyword_8 = (Keyword)cGroup.eContents().get(8); - ////PARAMETERS DEFINITION //Parameter returns Parameter: - // 'Parameter' - // '{' - // 'name' name=EString - // ('namespace' namespace=Namespace)? + // {Parameter} + // name=EString':' + // BEGIN // 'type' type=ParameterType + // ('ns:' namespace=Namespace)? + // END // '}'; @Override public ParserRule getRule() { return rule; } - //'Parameter' - //'{' - // 'name' name=EString - // ('namespace' namespace=Namespace)? + //{Parameter} + // name=EString':' + // BEGIN // 'type' type=ParameterType + // ('ns:' namespace=Namespace)? + // END //'}' public Group getGroup() { return cGroup; } - //'Parameter' - public Keyword getParameterKeyword_0() { return cParameterKeyword_0; } - - //'{' - public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } - - //'name' - public Keyword getNameKeyword_2() { return cNameKeyword_2; } + //{Parameter} + public Action getParameterAction_0() { return cParameterAction_0; } //name=EString - public Assignment getNameAssignment_3() { return cNameAssignment_3; } + public Assignment getNameAssignment_1() { return cNameAssignment_1; } //EString - public RuleCall getNameEStringParserRuleCall_3_0() { return cNameEStringParserRuleCall_3_0; } - - //('namespace' namespace=Namespace)? - public Group getGroup_4() { return cGroup_4; } - - //'namespace' - public Keyword getNamespaceKeyword_4_0() { return cNamespaceKeyword_4_0; } + public RuleCall getNameEStringParserRuleCall_1_0() { return cNameEStringParserRuleCall_1_0; } - //namespace=Namespace - public Assignment getNamespaceAssignment_4_1() { return cNamespaceAssignment_4_1; } + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } - //Namespace - public RuleCall getNamespaceNamespaceParserRuleCall_4_1_0() { return cNamespaceNamespaceParserRuleCall_4_1_0; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } //'type' - public Keyword getTypeKeyword_5() { return cTypeKeyword_5; } + public Keyword getTypeKeyword_4() { return cTypeKeyword_4; } //type=ParameterType - public Assignment getTypeAssignment_6() { return cTypeAssignment_6; } + public Assignment getTypeAssignment_5() { return cTypeAssignment_5; } //ParameterType - public RuleCall getTypeParameterTypeParserRuleCall_6_0() { return cTypeParameterTypeParserRuleCall_6_0; } + public RuleCall getTypeParameterTypeParserRuleCall_5_0() { return cTypeParameterTypeParserRuleCall_5_0; } + + //('ns:' namespace=Namespace)? + public Group getGroup_6() { return cGroup_6; } + + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } + + //namespace=Namespace + public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } + + //Namespace + public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } + + //END + public RuleCall getENDTerminalRuleCall_7() { return cENDTerminalRuleCall_7; } //'}' - public Keyword getRightCurlyBracketKeyword_7() { return cRightCurlyBracketKeyword_7; } + public Keyword getRightCurlyBracketKeyword_8() { return cRightCurlyBracketKeyword_8; } } public class ParameterTypeElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ParameterType"); @@ -2318,29 +2224,29 @@ public class ParameterListTypeElements extends AbstractParserRuleElementFinder { private final Group cGroup = (Group)rule.eContents().get(1); private final Action cParameterListTypeAction_0 = (Action)cGroup.eContents().get(0); private final Keyword cListKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final Keyword cLeftSquareBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); private final Assignment cSequenceAssignment_3 = (Assignment)cGroup.eContents().get(3); private final RuleCall cSequenceParameterTypeParserRuleCall_3_0 = (RuleCall)cSequenceAssignment_3.eContents().get(0); private final Group cGroup_4 = (Group)cGroup.eContents().get(4); private final Keyword cCommaKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); private final Assignment cSequenceAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1); private final RuleCall cSequenceParameterTypeParserRuleCall_4_1_0 = (RuleCall)cSequenceAssignment_4_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_5 = (Keyword)cGroup.eContents().get(5); + private final Keyword cRightSquareBracketKeyword_5 = (Keyword)cGroup.eContents().get(5); // // | ParameterDate; //ParameterListType returns ParameterListType: // {ParameterListType} // 'List' - // '{' + // '[' // sequence+=ParameterType ( ',' sequence+=ParameterType )* - // '}'; + // ']'; @Override public ParserRule getRule() { return rule; } //{ParameterListType} //'List' - //'{' + //'[' // sequence+=ParameterType ( ',' sequence+=ParameterType )* - //'}' + //']' public Group getGroup() { return cGroup; } //{ParameterListType} @@ -2349,8 +2255,8 @@ public class ParameterListTypeElements extends AbstractParserRuleElementFinder { //'List' public Keyword getListKeyword_1() { return cListKeyword_1; } - //'{' - public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; } + //'[' + public Keyword getLeftSquareBracketKeyword_2() { return cLeftSquareBracketKeyword_2; } //sequence+=ParameterType public Assignment getSequenceAssignment_3() { return cSequenceAssignment_3; } @@ -2370,36 +2276,36 @@ public class ParameterListTypeElements extends AbstractParserRuleElementFinder { //ParameterType public RuleCall getSequenceParameterTypeParserRuleCall_4_1_0() { return cSequenceParameterTypeParserRuleCall_4_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_5() { return cRightCurlyBracketKeyword_5; } + //']' + public Keyword getRightSquareBracketKeyword_5() { return cRightSquareBracketKeyword_5; } } public class ParameterStructTypeElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ParameterStructType"); private final Group cGroup = (Group)rule.eContents().get(1); private final Action cParameterStructTypeAction_0 = (Action)cGroup.eContents().get(0); private final Keyword cStructKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final Keyword cLeftSquareBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); private final Assignment cParameterstructypetmemberAssignment_3 = (Assignment)cGroup.eContents().get(3); private final RuleCall cParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0 = (RuleCall)cParameterstructypetmemberAssignment_3.eContents().get(0); private final Group cGroup_4 = (Group)cGroup.eContents().get(4); private final Keyword cCommaKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); private final Assignment cParameterstructypetmemberAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1); private final RuleCall cParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0 = (RuleCall)cParameterstructypetmemberAssignment_4_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_5 = (Keyword)cGroup.eContents().get(5); + private final Keyword cRightSquareBracketKeyword_5 = (Keyword)cGroup.eContents().get(5); //ParameterStructType returns ParameterStructType: // {ParameterStructType} // 'Struct' - // '{' + // '[' // parameterstructypetmember+=ParameterStructTypeMember ( "," parameterstructypetmember+=ParameterStructTypeMember)* - // '}'; + // ']'; @Override public ParserRule getRule() { return rule; } //{ParameterStructType} //'Struct' - //'{' + //'[' // parameterstructypetmember+=ParameterStructTypeMember ( "," parameterstructypetmember+=ParameterStructTypeMember)* - //'}' + //']' public Group getGroup() { return cGroup; } //{ParameterStructType} @@ -2408,8 +2314,8 @@ public class ParameterStructTypeElements extends AbstractParserRuleElementFinder //'Struct' public Keyword getStructKeyword_1() { return cStructKeyword_1; } - //'{' - public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; } + //'[' + public Keyword getLeftSquareBracketKeyword_2() { return cLeftSquareBracketKeyword_2; } //parameterstructypetmember+=ParameterStructTypeMember public Assignment getParameterstructypetmemberAssignment_3() { return cParameterstructypetmemberAssignment_3; } @@ -2429,8 +2335,8 @@ public class ParameterStructTypeElements extends AbstractParserRuleElementFinder //ParameterStructTypeMember public RuleCall getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0() { return cParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_5() { return cRightCurlyBracketKeyword_5; } + //']' + public Keyword getRightSquareBracketKeyword_5() { return cRightSquareBracketKeyword_5; } } public class ParameterIntegerTypeElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ParameterIntegerType"); @@ -2709,7 +2615,7 @@ public class ParameterArrayTypeElements extends AbstractParserRuleElementFinder private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ParameterArrayType"); private final Group cGroup = (Group)rule.eContents().get(1); private final Keyword cArrayKeyword_0 = (Keyword)cGroup.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final RuleCall cBEGINTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1); private final Keyword cTypeKeyword_2 = (Keyword)cGroup.eContents().get(2); private final Assignment cTypeAssignment_3 = (Assignment)cGroup.eContents().get(3); private final RuleCall cTypeParameterTypeParserRuleCall_3_0 = (RuleCall)cTypeAssignment_3.eContents().get(0); @@ -2717,28 +2623,28 @@ public class ParameterArrayTypeElements extends AbstractParserRuleElementFinder private final Keyword cDefaultKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); private final Assignment cDefaultAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1); private final RuleCall cDefaultParameterListParserRuleCall_4_1_0 = (RuleCall)cDefaultAssignment_4_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_5 = (Keyword)cGroup.eContents().get(5); + private final RuleCall cENDTerminalRuleCall_5 = (RuleCall)cGroup.eContents().get(5); //ParameterArrayType returns ParameterArrayType: - // 'Array' - // '{' + // 'Array:' + // BEGIN // 'type' type=ParameterType // ('default' default=ParameterList)? - // '}'; + // END; @Override public ParserRule getRule() { return rule; } - //'Array' - //'{' + //'Array:' + //BEGIN // 'type' type=ParameterType // ('default' default=ParameterList)? - //'}' + //END public Group getGroup() { return cGroup; } - //'Array' + //'Array:' public Keyword getArrayKeyword_0() { return cArrayKeyword_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_1() { return cBEGINTerminalRuleCall_1; } //'type' public Keyword getTypeKeyword_2() { return cTypeKeyword_2; } @@ -2761,37 +2667,37 @@ public class ParameterArrayTypeElements extends AbstractParserRuleElementFinder //ParameterList public RuleCall getDefaultParameterListParserRuleCall_4_1_0() { return cDefaultParameterListParserRuleCall_4_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_5() { return cRightCurlyBracketKeyword_5; } + //END + public RuleCall getENDTerminalRuleCall_5() { return cENDTerminalRuleCall_5; } } public class ParameterListElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ParameterList"); private final Group cGroup = (Group)rule.eContents().get(1); private final Action cParameterSequenceAction_0 = (Action)cGroup.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final Keyword cLeftSquareBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); private final Assignment cValueAssignment_2 = (Assignment)cGroup.eContents().get(2); private final RuleCall cValueParameterValueParserRuleCall_2_0 = (RuleCall)cValueAssignment_2.eContents().get(0); private final Group cGroup_3 = (Group)cGroup.eContents().get(3); private final Keyword cCommaKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); private final Assignment cValueAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); private final RuleCall cValueParameterValueParserRuleCall_3_1_0 = (RuleCall)cValueAssignment_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Keyword cRightSquareBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); //ParameterList returns ParameterSequence: // {ParameterSequence} - // '{' value+=ParameterValue ( ',' value+=ParameterValue )* '}' + // '[' value+=ParameterValue ( ',' value+=ParameterValue )* ']' //; @Override public ParserRule getRule() { return rule; } //{ParameterSequence} - // '{' value+=ParameterValue ( ',' value+=ParameterValue )* '}' + // '[' value+=ParameterValue ( ',' value+=ParameterValue )* ']' public Group getGroup() { return cGroup; } //{ParameterSequence} public Action getParameterSequenceAction_0() { return cParameterSequenceAction_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } + //'[' + public Keyword getLeftSquareBracketKeyword_1() { return cLeftSquareBracketKeyword_1; } //value+=ParameterValue public Assignment getValueAssignment_2() { return cValueAssignment_2; } @@ -2811,34 +2717,29 @@ public class ParameterListElements extends AbstractParserRuleElementFinder { //ParameterValue public RuleCall getValueParameterValueParserRuleCall_3_1_0() { return cValueParameterValueParserRuleCall_3_1_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; } + //']' + public Keyword getRightSquareBracketKeyword_4() { return cRightSquareBracketKeyword_4; } } public class ParameterAnyElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ParameterAny"); private final Group cGroup = (Group)rule.eContents().get(1); private final Action cParameterAnyAction_0 = (Action)cGroup.eContents().get(0); private final Keyword cParameterAnyKeyword_1 = (Keyword)cGroup.eContents().get(1); - private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Group cGroup_3 = (Group)cGroup.eContents().get(3); - private final Keyword cValueKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); - private final Assignment cValueAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); - private final RuleCall cValueEStringParserRuleCall_3_1_0 = (RuleCall)cValueAssignment_3_1.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Group cGroup_2 = (Group)cGroup.eContents().get(2); + private final Keyword cValueKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); + private final Assignment cValueAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); + private final RuleCall cValueEStringParserRuleCall_2_1_0 = (RuleCall)cValueAssignment_2_1.eContents().get(0); //ParameterAny returns ParameterAny: // {ParameterAny} // 'ParameterAny' - // '{' // ('value' value=EString)? - // '}'; + // ; @Override public ParserRule getRule() { return rule; } //{ParameterAny} //'ParameterAny' - //'{' // ('value' value=EString)? - //'}' public Group getGroup() { return cGroup; } //{ParameterAny} @@ -2847,23 +2748,17 @@ public class ParameterAnyElements extends AbstractParserRuleElementFinder { //'ParameterAny' public Keyword getParameterAnyKeyword_1() { return cParameterAnyKeyword_1; } - //'{' - public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; } - //('value' value=EString)? - public Group getGroup_3() { return cGroup_3; } + public Group getGroup_2() { return cGroup_2; } //'value' - public Keyword getValueKeyword_3_0() { return cValueKeyword_3_0; } + public Keyword getValueKeyword_2_0() { return cValueKeyword_2_0; } //value=EString - public Assignment getValueAssignment_3_1() { return cValueAssignment_3_1; } + public Assignment getValueAssignment_2_1() { return cValueAssignment_2_1; } //EString - public RuleCall getValueEStringParserRuleCall_3_1_0() { return cValueEStringParserRuleCall_3_1_0; } - - //'}' - public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; } + public RuleCall getValueEStringParserRuleCall_2_1_0() { return cValueEStringParserRuleCall_2_1_0; } } public class ParameterStringElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ParameterString"); @@ -2950,35 +2845,35 @@ public class ParameterStructElements extends AbstractParserRuleElementFinder { private final Group cGroup = (Group)rule.eContents().get(1); private final Action cParameterStructAction_0 = (Action)cGroup.eContents().get(0); private final Group cGroup_1 = (Group)cGroup.eContents().get(1); - private final Keyword cLeftCurlyBracketKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); + private final Keyword cLeftSquareBracketKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); private final Assignment cValueAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); private final RuleCall cValueParameterStructMemberParserRuleCall_1_1_0 = (RuleCall)cValueAssignment_1_1.eContents().get(0); private final Group cGroup_1_2 = (Group)cGroup_1.eContents().get(2); private final Keyword cCommaKeyword_1_2_0 = (Keyword)cGroup_1_2.eContents().get(0); - private final Keyword cLeftCurlyBracketKeyword_1_2_1 = (Keyword)cGroup_1_2.eContents().get(1); + private final Keyword cLeftSquareBracketKeyword_1_2_1 = (Keyword)cGroup_1_2.eContents().get(1); private final Assignment cValueAssignment_1_2_2 = (Assignment)cGroup_1_2.eContents().get(2); private final RuleCall cValueParameterStructMemberParserRuleCall_1_2_2_0 = (RuleCall)cValueAssignment_1_2_2.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_1_2_3 = (Keyword)cGroup_1_2.eContents().get(3); - private final Keyword cRightCurlyBracketKeyword_1_3 = (Keyword)cGroup_1.eContents().get(3); + private final Keyword cRightSquareBracketKeyword_1_2_3 = (Keyword)cGroup_1_2.eContents().get(3); + private final Keyword cRightSquareBracketKeyword_1_3 = (Keyword)cGroup_1.eContents().get(3); //ParameterStruct returns ParameterStruct: // {ParameterStruct} - // ('{' value+=ParameterStructMember ( "," '{' value+=ParameterStructMember '}')* '}' )? + // ('[' value+=ParameterStructMember ( "," '[' value+=ParameterStructMember ']')* ']' )? //; @Override public ParserRule getRule() { return rule; } //{ParameterStruct} - // ('{' value+=ParameterStructMember ( "," '{' value+=ParameterStructMember '}')* '}' )? + // ('[' value+=ParameterStructMember ( "," '[' value+=ParameterStructMember ']')* ']' )? public Group getGroup() { return cGroup; } //{ParameterStruct} public Action getParameterStructAction_0() { return cParameterStructAction_0; } - //('{' value+=ParameterStructMember ( "," '{' value+=ParameterStructMember '}')* '}' )? + //('[' value+=ParameterStructMember ( "," '[' value+=ParameterStructMember ']')* ']' )? public Group getGroup_1() { return cGroup_1; } - //'{' - public Keyword getLeftCurlyBracketKeyword_1_0() { return cLeftCurlyBracketKeyword_1_0; } + //'[' + public Keyword getLeftSquareBracketKeyword_1_0() { return cLeftSquareBracketKeyword_1_0; } //value+=ParameterStructMember public Assignment getValueAssignment_1_1() { return cValueAssignment_1_1; } @@ -2986,14 +2881,14 @@ public class ParameterStructElements extends AbstractParserRuleElementFinder { //ParameterStructMember public RuleCall getValueParameterStructMemberParserRuleCall_1_1_0() { return cValueParameterStructMemberParserRuleCall_1_1_0; } - //( "," '{' value+=ParameterStructMember '}')* + //( "," '[' value+=ParameterStructMember ']')* public Group getGroup_1_2() { return cGroup_1_2; } //"," public Keyword getCommaKeyword_1_2_0() { return cCommaKeyword_1_2_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_1_2_1() { return cLeftCurlyBracketKeyword_1_2_1; } + //'[' + public Keyword getLeftSquareBracketKeyword_1_2_1() { return cLeftSquareBracketKeyword_1_2_1; } //value+=ParameterStructMember public Assignment getValueAssignment_1_2_2() { return cValueAssignment_1_2_2; } @@ -3001,11 +2896,11 @@ public class ParameterStructElements extends AbstractParserRuleElementFinder { //ParameterStructMember public RuleCall getValueParameterStructMemberParserRuleCall_1_2_2_0() { return cValueParameterStructMemberParserRuleCall_1_2_2_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_1_2_3() { return cRightCurlyBracketKeyword_1_2_3; } + //']' + public Keyword getRightSquareBracketKeyword_1_2_3() { return cRightSquareBracketKeyword_1_2_3; } - //'}' - public Keyword getRightCurlyBracketKeyword_1_3() { return cRightCurlyBracketKeyword_1_3; } + //']' + public Keyword getRightSquareBracketKeyword_1_3() { return cRightSquareBracketKeyword_1_3; } } public class ParameterDateElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ParameterDate"); @@ -3029,25 +2924,25 @@ public class ParameterStructMemberElements extends AbstractParserRuleElementFind private final Keyword cParameterStructMemberKeyword_0 = (Keyword)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 cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); - private final Keyword cValueKeyword_3 = (Keyword)cGroup.eContents().get(3); + private final Keyword cColonKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final RuleCall cBEGINTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); private final Assignment cValueAssignment_4 = (Assignment)cGroup.eContents().get(4); private final RuleCall cValueParameterValueParserRuleCall_4_0 = (RuleCall)cValueAssignment_4.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_5 = (Keyword)cGroup.eContents().get(5); + private final RuleCall cENDTerminalRuleCall_5 = (RuleCall)cGroup.eContents().get(5); //ParameterStructMember returns ParameterStructMember: // 'ParameterStructMember' - // name=EString - // '{' - // 'value' value=ParameterValue - // '}'; + // name=EString':' + // BEGIN + // value=ParameterValue + // END; @Override public ParserRule getRule() { return rule; } //'ParameterStructMember' - //name=EString - //'{' - // 'value' value=ParameterValue - //'}' + //name=EString':' + //BEGIN + // value=ParameterValue + //END public Group getGroup() { return cGroup; } //'ParameterStructMember' @@ -3059,11 +2954,11 @@ public class ParameterStructMemberElements extends AbstractParserRuleElementFind //EString public RuleCall getNameEStringParserRuleCall_1_0() { return cNameEStringParserRuleCall_1_0; } - //'{' - public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; } + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } - //'value' - public Keyword getValueKeyword_3() { return cValueKeyword_3; } + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } //value=ParameterValue public Assignment getValueAssignment_4() { return cValueAssignment_4; } @@ -3071,8 +2966,8 @@ public class ParameterStructMemberElements extends AbstractParserRuleElementFind //ParameterValue public RuleCall getValueParameterValueParserRuleCall_4_0() { return cValueParameterValueParserRuleCall_4_0; } - //'}' - public Keyword getRightCurlyBracketKeyword_5() { return cRightCurlyBracketKeyword_5; } + //END + public RuleCall getENDTerminalRuleCall_5() { return cENDTerminalRuleCall_5; } } public class ParameterStructTypeMemberElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ParameterStructTypeMember"); @@ -3170,7 +3065,9 @@ public class MessagePartElements extends AbstractParserRuleElementFinder { private final RuleCall cDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1 = (RuleCall)cDataAlternatives_1_0.eContents().get(1); private final RuleCall cDataEStringParserRuleCall_1_0_2 = (RuleCall)cDataAlternatives_1_0.eContents().get(2); + ///////////////////// ////MESSAGE PRIMITIVES DEFINITION + ///////////////////// //MessagePart returns primitives::MessagePart: // Type = AbstractType // Data =(KEYWORD | MESSAGE_ASIGMENT | EString) @@ -4084,36 +3981,39 @@ public class KEYWORDElements extends AbstractParserRuleElementFinder { private final PackageSetElements pPackageSet; - private final PackageElements pPackage; - private final SpecBaseElements pSpecBase; - private final DependencyElements pDependency; - private final NamespaceElements pNamespace; - private final Package_ImplElements pPackage_Impl; + private final TerminalRule tBEGIN; + private final TerminalRule tEND; + private final TerminalRule tSL_COMMENT; private final EStringElements pEString; private final RosNamesElements pRosNames; - private final RosParamNamesElements pRosParamNames; private final TerminalRule tROS_CONVENTION_A; private final TerminalRule tROS_CONVENTION_PARAM; - private final ArtifactElements pArtifact; + private final PackageElements pPackage; + private final Package_ImplElements pPackage_Impl; private final CatkinPackageElements pCatkinPackage; private final AmentPackageElements pAmentPackage; - private final ServiceSpecElements pServiceSpec; + private final ArtifactElements pArtifact; + private final NodeElements pNode; + private final SpecBaseElements pSpecBase; private final TopicSpecElements pTopicSpec; + private final ServiceSpecElements pServiceSpec; private final ActionSpecElements pActionSpec; private final MessageDefinitionElements pMessageDefinition; - private final NodeElements pNode; - private final ServiceServerElements pServiceServer; private final PublisherElements pPublisher; private final SubscriberElements pSubscriber; + private final ServiceServerElements pServiceServer; private final ServiceClientElements pServiceClient; private final ActionServerElements pActionServer; private final ActionClientElements pActionClient; - private final GraphNameElements pGraphName; + private final DependencyElements pDependency; private final PackageDependencyElements pPackageDependency; private final ExternalDependencyElements pExternalDependency; + private final NamespaceElements pNamespace; + private final GraphNameElements pGraphName; private final GlobalNamespaceElements pGlobalNamespace; private final RelativeNamespace_ImplElements pRelativeNamespace_Impl; private final PrivateNamespaceElements pPrivateNamespace; + private final RosParamNamesElements pRosParamNames; private final ParameterElements pParameter; private final ParameterTypeElements pParameterType; private final ParameterValueElements pParameterValue; @@ -4200,36 +4100,39 @@ public RosGrammarAccess(GrammarProvider grammarProvider, this.grammar = internalFindGrammar(grammarProvider); this.gaTerminals = gaTerminals; this.pPackageSet = new PackageSetElements(); - this.pPackage = new PackageElements(); - this.pSpecBase = new SpecBaseElements(); - this.pDependency = new DependencyElements(); - this.pNamespace = new NamespaceElements(); - this.pPackage_Impl = new Package_ImplElements(); + this.tBEGIN = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.BEGIN"); + this.tEND = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.END"); + this.tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.SL_COMMENT"); this.pEString = new EStringElements(); this.pRosNames = new RosNamesElements(); - this.pRosParamNames = new RosParamNamesElements(); this.tROS_CONVENTION_A = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ROS_CONVENTION_A"); this.tROS_CONVENTION_PARAM = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros.Ros.ROS_CONVENTION_PARAM"); - this.pArtifact = new ArtifactElements(); + this.pPackage = new PackageElements(); + this.pPackage_Impl = new Package_ImplElements(); this.pCatkinPackage = new CatkinPackageElements(); this.pAmentPackage = new AmentPackageElements(); - this.pServiceSpec = new ServiceSpecElements(); + this.pArtifact = new ArtifactElements(); + this.pNode = new NodeElements(); + this.pSpecBase = new SpecBaseElements(); this.pTopicSpec = new TopicSpecElements(); + this.pServiceSpec = new ServiceSpecElements(); this.pActionSpec = new ActionSpecElements(); this.pMessageDefinition = new MessageDefinitionElements(); - this.pNode = new NodeElements(); - this.pServiceServer = new ServiceServerElements(); this.pPublisher = new PublisherElements(); this.pSubscriber = new SubscriberElements(); + this.pServiceServer = new ServiceServerElements(); this.pServiceClient = new ServiceClientElements(); this.pActionServer = new ActionServerElements(); this.pActionClient = new ActionClientElements(); - this.pGraphName = new GraphNameElements(); + this.pDependency = new DependencyElements(); this.pPackageDependency = new PackageDependencyElements(); this.pExternalDependency = new ExternalDependencyElements(); + this.pNamespace = new NamespaceElements(); + this.pGraphName = new GraphNameElements(); this.pGlobalNamespace = new GlobalNamespaceElements(); this.pRelativeNamespace_Impl = new RelativeNamespace_ImplElements(); this.pPrivateNamespace = new PrivateNamespaceElements(); + this.pRosParamNames = new RosParamNamesElements(); this.pParameter = new ParameterElements(); this.pParameterType = new ParameterTypeElements(); this.pParameterValue = new ParameterValueElements(); @@ -4336,10 +4239,8 @@ public TerminalsGrammarAccess getTerminalsGrammarAccess() { //PackageSet returns PackageSet: // {PackageSet} - // 'PackageSet' - // '{' - // (package+=Package ( "," package+=Package)* )? - // '}'; + // package+=Package_Impl* + // ; public PackageSetElements getPackageSetAccess() { return pPackageSet; } @@ -4348,63 +4249,28 @@ public ParserRule getPackageSetRule() { return getPackageSetAccess().getRule(); } - //Package returns Package: - // Package_Impl | CatkinPackage | AmentPackage; - public PackageElements getPackageAccess() { - return pPackage; - } - - public ParserRule getPackageRule() { - return getPackageAccess().getRule(); - } - - //SpecBase returns SpecBase: - // ServiceSpec | TopicSpec | ActionSpec; - public SpecBaseElements getSpecBaseAccess() { - return pSpecBase; - } - - public ParserRule getSpecBaseRule() { - return getSpecBaseAccess().getRule(); - } - - //Dependency returns Dependency: - // PackageDependency | ExternalDependency; - public DependencyElements getDependencyAccess() { - return pDependency; - } - - public ParserRule getDependencyRule() { - return getDependencyAccess().getRule(); - } - - //Namespace returns Namespace: - // GlobalNamespace | RelativeNamespace_Impl | PrivateNamespace; - public NamespaceElements getNamespaceAccess() { - return pNamespace; - } - - public ParserRule getNamespaceRule() { - return getNamespaceAccess().getRule(); + ///////////////////// + //// YAML format + ///////////////////// + //terminal BEGIN: 'synthetic:BEGIN'; + public TerminalRule getBEGINRule() { + return tBEGIN; } - //Package_Impl returns Package: - // {Package} - // 'Package' - // name=EString - // '{' - // ('FromGitRepo' fromGitRepo=EString)? - // ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - // (artifact+=Artifact ( "," artifact+=Artifact)*)? - // '}'; - public Package_ImplElements getPackage_ImplAccess() { - return pPackage_Impl; + //terminal END: 'synthetic:END'; + public TerminalRule getENDRule() { + return tEND; } - public ParserRule getPackage_ImplRule() { - return getPackage_ImplAccess().getRule(); + //@Override + //terminal SL_COMMENT: '#' !('\n'|'\r')*; + public TerminalRule getSL_COMMENTRule() { + return tSL_COMMENT; } + ///////////////////// + //// CONVENTIONS AND NAMES + ///////////////////// //EString returns ecore::EString: // STRING | ID; public EStringElements getEStringAccess() { @@ -4426,17 +4292,6 @@ public ParserRule getRosNamesRule() { return getRosNamesAccess().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() { @@ -4449,31 +4304,54 @@ public TerminalRule getROS_CONVENTION_PARAMRule() { return tROS_CONVENTION_PARAM; } - //Artifact returns Artifact: - // {Artifact} - // 'Artifact' - // name=RosNames - // '{' - // (node=Node)? - // '}'; - public ArtifactElements getArtifactAccess() { - return pArtifact; + ///////////////////// + ////PACKAGES + ///////////////////// + //Package returns Package: + // Package_Impl //| + // //CatkinPackage | + // //AmentPackage + // ; + public PackageElements getPackageAccess() { + return pPackage; } - public ParserRule getArtifactRule() { - return getArtifactAccess().getRule(); + public ParserRule getPackageRule() { + return getPackageAccess().getRule(); + } + + //Package_Impl returns Package: + // {Package} + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('specs:' + // BEGIN + // spec+=SpecBase* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; + public Package_ImplElements getPackage_ImplAccess() { + return pPackage_Impl; + } + + public ParserRule getPackage_ImplRule() { + return getPackage_ImplAccess().getRule(); } //CatkinPackage returns CatkinPackage: // {CatkinPackage} - // 'CatkinPackage' - // name=RosNames - // '{' - // ('FromGitRepo' fromGitRepo=EString)? - // ('Dependencies' '{' dependency+=Dependency ( "," dependency+=Dependency)* '}' )? - // ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - // (artifact+=Artifact ( "," artifact+=Artifact)*)? - // '}'; + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; public CatkinPackageElements getCatkinPackageAccess() { return pCatkinPackage; } @@ -4485,13 +4363,16 @@ public ParserRule getCatkinPackageRule() { //AmentPackage returns AmentPackage: // {AmentPackage} // 'AmentPackage' - // name=RosNames - // '{' - // ('FromGitRepo' fromGitRepo=EString)? - // ('Dependencies' '{' dependency+=Dependency ( "," dependency+=Dependency)* '}' )? - // ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - // (artifact+=Artifact ( "," artifact+=Artifact)*)? - // '}'; + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; public AmentPackageElements getAmentPackageAccess() { return pAmentPackage; } @@ -4500,29 +4381,92 @@ public ParserRule getAmentPackageRule() { return getAmentPackageAccess().getRule(); } - //ServiceSpec returns ServiceSpec: - // {ServiceSpec} - // 'ServiceSpec' - // name=EString - // '{' - // ('request' request=MessageDefinition)? - // ('response' response=MessageDefinition)? - // '}'; - public ServiceSpecElements getServiceSpecAccess() { - return pServiceSpec; + ///////////////////// + ////ARTIFACT AND NODE + ///////////////////// + //Artifact returns Artifact: + // {Artifact} + // name=RosNames':' + // BEGIN + // (node=Node)? + // END; + public ArtifactElements getArtifactAccess() { + return pArtifact; } - public ParserRule getServiceSpecRule() { - return getServiceSpecAccess().getRule(); + public ParserRule getArtifactRule() { + return getArtifactAccess().getRule(); + } + + //Node returns Node: + // 'node:' name=RosNames + // BEGIN + // ( + // ('publishers:' + // BEGIN + // publisher+=Publisher* + // END + // )| + // ('subscribers:' + // BEGIN + // subscriber+=Subscriber* + // END + // )| + // ('serviceserver:' + // BEGIN + // serviceserver+=ServiceServer* + // END + // )| + // ('serviceclient:' + // BEGIN + // serviceclient+=ServiceClient* + // END + // )| + // ('actionserver:' + // BEGIN + // actionserver+=ActionServer* + // END + // )| + // ('actionclient:' + // BEGIN + // actionclient+=ActionClient* + // END + // )| + // ('parameters:' + // BEGIN + // parameter+=Parameter* + // END + // ) + // )*END + // ; + public NodeElements getNodeAccess() { + return pNode; + } + + public ParserRule getNodeRule() { + return getNodeAccess().getRule(); + } + + ///////////////////// + ////OBJECTS/SPECIFICATIONS + ///////////////////// + //SpecBase returns SpecBase: + // TopicSpec | ServiceSpec | ActionSpec; + public SpecBaseElements getSpecBaseAccess() { + return pSpecBase; + } + + public ParserRule getSpecBaseRule() { + return getSpecBaseAccess().getRule(); } //TopicSpec returns TopicSpec: // {TopicSpec} - // 'TopicSpec' - // name=(EString|'Header'|'String') - // '{' - // ('message' message=MessageDefinition)? - // '}'; + // 'msg:'name=(EString|'Header'|'String') + // BEGIN + // 'message:' (BEGIN message=MessageDefinition END)? + // END + // ; public TopicSpecElements getTopicSpecAccess() { return pTopicSpec; } @@ -4531,15 +4475,29 @@ public ParserRule getTopicSpecRule() { return getTopicSpecAccess().getRule(); } + //ServiceSpec returns ServiceSpec: + // {ServiceSpec} + // 'srv:'name=EString + // BEGIN + // 'request:' (BEGIN request=MessageDefinition END)? + // 'response:' (BEGIN response=MessageDefinition END)? + // END; + public ServiceSpecElements getServiceSpecAccess() { + return pServiceSpec; + } + + public ParserRule getServiceSpecRule() { + return getServiceSpecAccess().getRule(); + } + //ActionSpec returns ActionSpec: // {ActionSpec} - // 'ActionSpec' - // name=EString - // '{' - // ('goal' goal=MessageDefinition)? - // ('result' result=MessageDefinition)? - // ('feedback' feedback=MessageDefinition)? - // '}'; + // 'action:'name=EString + // BEGIN + // 'goal:' (BEGIN goal=MessageDefinition END)? + // 'result:' (BEGIN result=MessageDefinition END)? + // 'feedback:' (BEGIN feedback=MessageDefinition END)? + // END; public ActionSpecElements getActionSpecAccess() { return pActionSpec; } @@ -4550,9 +4508,7 @@ public ParserRule getActionSpecRule() { //MessageDefinition returns MessageDefinition: // {MessageDefinition} - // '{' - // ( MessagePart+=MessagePart ( MessagePart+=MessagePart)* )? - // '}'; + // MessagePart+=MessagePart*; public MessageDefinitionElements getMessageDefinitionAccess() { return pMessageDefinition; } @@ -4561,48 +4517,17 @@ public ParserRule getMessageDefinitionRule() { return getMessageDefinitionAccess().getRule(); } - //Node returns Node: - // 'Node' - // '{' - // 'name' name=RosNames - // ('ServiceServers' '{' serviceserver+=ServiceServer ( "," serviceserver+=ServiceServer)* '}')? - // ('Publishers' '{' publisher+=Publisher ( "," publisher+=Publisher)* '}')? - // ('Subscribers' '{' subscriber+=Subscriber ( "," subscriber+=Subscriber)* '}')? - // ('ServiceClients' '{' serviceclient+=ServiceClient ( "," serviceclient+=ServiceClient)* '}')? - // ('ActionServers' '{' actionserver+=ActionServer ( "," actionserver+=ActionServer)* '}')? - // ('ActionClients' '{' actionclient+=ActionClient ( "," actionclient+=ActionClient)* '}' )? - // ('Parameters' '{' parameter+=Parameter ( "," parameter+=Parameter)* '}' )? - // '}'; - public NodeElements getNodeAccess() { - return pNode; - } - - public ParserRule getNodeRule() { - return getNodeAccess().getRule(); - } - - //ServiceServer returns ServiceServer: - // 'ServiceServer' - // '{' - // 'name' name=EString - // 'service' service=[ServiceSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; - public ServiceServerElements getServiceServerAccess() { - return pServiceServer; - } - - public ParserRule getServiceServerRule() { - return getServiceServerAccess().getRule(); - } - + ///////////////////// + ////INTERFACES + ///////////////////// //Publisher returns Publisher: - // 'Publisher' - // '{' - // 'name' name=EString - // 'message' message=[TopicSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; + // {Publisher} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; public PublisherElements getPublisherAccess() { return pPublisher; } @@ -4612,12 +4537,13 @@ public ParserRule getPublisherRule() { } //Subscriber returns Subscriber: - // 'Subscriber' - // '{' - // 'name' name=EString - // 'message' message=[TopicSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; + // {Subscriber} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; public SubscriberElements getSubscriberAccess() { return pSubscriber; } @@ -4626,13 +4552,30 @@ public ParserRule getSubscriberRule() { return getSubscriberAccess().getRule(); } + //ServiceServer returns ServiceServer: + // {ServiceServer} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; + public ServiceServerElements getServiceServerAccess() { + return pServiceServer; + } + + public ParserRule getServiceServerRule() { + return getServiceServerAccess().getRule(); + } + //ServiceClient returns ServiceClient: - // 'ServiceClient' - // '{' - // 'name' name=EString - // 'service' service=[ServiceSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; + // {ServiceClient} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; public ServiceClientElements getServiceClientAccess() { return pServiceClient; } @@ -4642,12 +4585,13 @@ public ParserRule getServiceClientRule() { } //ActionServer returns ActionServer: - // 'ActionServer' - // '{' - // 'name' name=EString - // 'action' action=[ActionSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; + // {ActionServer} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; public ActionServerElements getActionServerAccess() { return pActionServer; } @@ -4657,12 +4601,13 @@ public ParserRule getActionServerRule() { } //ActionClient returns ActionClient: - // 'ActionClient' - // '{' - // 'name' name=EString - // 'action' action=[ActionSpec|EString] - // ('namespace' namespace=Namespace)? - // '}'; + // {ActionClient} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; public ActionClientElements getActionClientAccess() { return pActionClient; } @@ -4671,19 +4616,21 @@ public ParserRule getActionClientRule() { return getActionClientAccess().getRule(); } - //GraphName returns GraphName: - // 'GraphName' ; - public GraphNameElements getGraphNameAccess() { - return pGraphName; + ///////////////////// + ////DEPENDENCIES + ///////////////////// + //Dependency returns Dependency: + // PackageDependency | ExternalDependency; + public DependencyElements getDependencyAccess() { + return pDependency; } - public ParserRule getGraphNameRule() { - return getGraphNameAccess().getRule(); + public ParserRule getDependencyRule() { + return getDependencyAccess().getRule(); } //PackageDependency returns PackageDependency: - // package=[Package|EString] - //; + // package=[Package|EString]; public PackageDependencyElements getPackageDependencyAccess() { return pPackageDependency; } @@ -4704,12 +4651,33 @@ public ParserRule getExternalDependencyRule() { return getExternalDependencyAccess().getRule(); } + ///////////////////// + ////NAMESPACES + ///////////////////// + //Namespace returns Namespace: + // GlobalNamespace | RelativeNamespace_Impl | PrivateNamespace; + public NamespaceElements getNamespaceAccess() { + return pNamespace; + } + + public ParserRule getNamespaceRule() { + return getNamespaceAccess().getRule(); + } + + //GraphName returns GraphName: + // 'GraphName' ; + public GraphNameElements getGraphNameAccess() { + return pGraphName; + } + + public ParserRule getGraphNameRule() { + return getGraphNameAccess().getRule(); + } + //GlobalNamespace returns GlobalNamespace: // {GlobalNamespace} // 'GlobalNamespace' - // '{' - // ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - // '}'; + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; public GlobalNamespaceElements getGlobalNamespaceAccess() { return pGlobalNamespace; } @@ -4721,9 +4689,7 @@ public ParserRule getGlobalNamespaceRule() { //RelativeNamespace_Impl returns RelativeNamespace: // {RelativeNamespace} // 'RelativeNamespace' - // '{' - // ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - // '}'; + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; public RelativeNamespace_ImplElements getRelativeNamespace_ImplAccess() { return pRelativeNamespace_Impl; } @@ -4735,9 +4701,7 @@ public ParserRule getRelativeNamespace_ImplRule() { //PrivateNamespace returns PrivateNamespace: // {PrivateNamespace} // 'PrivateNamespace' - // '{' - // ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - // '}'; + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; public PrivateNamespaceElements getPrivateNamespaceAccess() { return pPrivateNamespace; } @@ -4746,13 +4710,27 @@ public ParserRule getPrivateNamespaceRule() { return getPrivateNamespaceAccess().getRule(); } + ///////////////////// ////PARAMETERS DEFINITION + ///////////////////// + //RosParamNames returns ecore::EString: + // ROS_CONVENTION_PARAM | ID + //; + public RosParamNamesElements getRosParamNamesAccess() { + return pRosParamNames; + } + + public ParserRule getRosParamNamesRule() { + return getRosParamNamesAccess().getRule(); + } + //Parameter returns Parameter: - // 'Parameter' - // '{' - // 'name' name=EString - // ('namespace' namespace=Namespace)? + // {Parameter} + // name=EString':' + // BEGIN // 'type' type=ParameterType + // ('ns:' namespace=Namespace)? + // END // '}'; public ParameterElements getParameterAccess() { return pParameter; @@ -4787,9 +4765,9 @@ public ParserRule getParameterValueRule() { //ParameterListType returns ParameterListType: // {ParameterListType} // 'List' - // '{' + // '[' // sequence+=ParameterType ( ',' sequence+=ParameterType )* - // '}'; + // ']'; public ParameterListTypeElements getParameterListTypeAccess() { return pParameterListType; } @@ -4801,9 +4779,9 @@ public ParserRule getParameterListTypeRule() { //ParameterStructType returns ParameterStructType: // {ParameterStructType} // 'Struct' - // '{' + // '[' // parameterstructypetmember+=ParameterStructTypeMember ( "," parameterstructypetmember+=ParameterStructTypeMember)* - // '}'; + // ']'; public ParameterStructTypeElements getParameterStructTypeAccess() { return pParameterStructType; } @@ -4897,11 +4875,11 @@ public ParserRule getParameterAnyTypeRule() { } //ParameterArrayType returns ParameterArrayType: - // 'Array' - // '{' + // 'Array:' + // BEGIN // 'type' type=ParameterType // ('default' default=ParameterList)? - // '}'; + // END; public ParameterArrayTypeElements getParameterArrayTypeAccess() { return pParameterArrayType; } @@ -4912,7 +4890,7 @@ public ParserRule getParameterArrayTypeRule() { //ParameterList returns ParameterSequence: // {ParameterSequence} - // '{' value+=ParameterValue ( ',' value+=ParameterValue )* '}' + // '[' value+=ParameterValue ( ',' value+=ParameterValue )* ']' //; public ParameterListElements getParameterListAccess() { return pParameterList; @@ -4925,9 +4903,8 @@ public ParserRule getParameterListRule() { //ParameterAny returns ParameterAny: // {ParameterAny} // 'ParameterAny' - // '{' // ('value' value=EString)? - // '}'; + // ; public ParameterAnyElements getParameterAnyAccess() { return pParameterAny; } @@ -4993,7 +4970,7 @@ public ParserRule getParameterBooleanRule() { //ParameterStruct returns ParameterStruct: // {ParameterStruct} - // ('{' value+=ParameterStructMember ( "," '{' value+=ParameterStructMember '}')* '}' )? + // ('[' value+=ParameterStructMember ( "," '[' value+=ParameterStructMember ']')* ']' )? //; public ParameterStructElements getParameterStructAccess() { return pParameterStruct; @@ -5016,10 +4993,10 @@ public ParserRule getParameterDateRule() { //ParameterStructMember returns ParameterStructMember: // 'ParameterStructMember' - // name=EString - // '{' - // 'value' value=ParameterValue - // '}'; + // name=EString':' + // BEGIN + // value=ParameterValue + // END; public ParameterStructMemberElements getParameterStructMemberAccess() { return pParameterStructMember; } @@ -5040,8 +5017,10 @@ public ParserRule getParameterStructTypeMemberRule() { return getParameterStructTypeMemberAccess().getRule(); } + ///////////////////// ////PARAMETERS PRIMITIVES TYPES - //terminal fragment DIGIT: '0'..'9'; + ///////////////////// + //terminal DIGIT: '0'..'9'; public TerminalRule getDIGITRule() { return tDIGIT; } @@ -5056,7 +5035,7 @@ public TerminalRule getBOOLEANRule() { return tBOOLEAN; } - //terminal DOUBLE returns ecore::EDouble: DECINT (('.' DIGIT*) | (('.' DIGIT*)? ('E'|'e') ('-'|'+')? DECINT)); + //terminal DOUBLE returns ecore::EDouble: DIGIT (('.' DECINT*) | (('.' DIGIT*)? ('E'|'e') ('-'|'+')? DIGIT)); public TerminalRule getDOUBLERule() { return tDOUBLE; } @@ -5147,7 +5126,9 @@ public ParserRule getDateTime0Rule() { return getDateTime0Access().getRule(); } + ///////////////////// ////MESSAGE PRIMITIVES DEFINITION + ///////////////////// //MessagePart returns primitives::MessagePart: // Type = AbstractType // Data =(KEYWORD | MESSAGE_ASIGMENT | EString) @@ -5581,11 +5562,6 @@ public TerminalRule getML_COMMENTRule() { return gaTerminals.getML_COMMENTRule(); } - //terminal SL_COMMENT : '//' !('\n'|'\r')* ('\r'? '\n')?; - public TerminalRule getSL_COMMENTRule() { - return gaTerminals.getSL_COMMENTRule(); - } - //terminal WS : (' '|'\t'|'\r'|'\n')+; public TerminalRule getWSRule() { return gaTerminals.getWSRule(); diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/GenerateRos.mwe2 b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/GenerateRos.mwe2 index 252ca81c8..50586d825 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/GenerateRos.mwe2 +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/GenerateRos.mwe2 @@ -20,12 +20,12 @@ Workflow { } createEclipseMetaData = true - } code = { encoding = "UTF-8" lineDelimiter = "\n" fileHeader = "/*\n * generated by Xtext \${version}\n */" + preferXtendStubs = true } } language = StandardLanguage { @@ -37,6 +37,7 @@ Workflow { formatter = { generateStub = true + generateXtendStub = true } serializer = { @@ -44,8 +45,15 @@ Workflow { } 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.ros.xtext/src/de/fraunhofer/ipa/ros/Ros.xtext b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/Ros.xtext index 3d2a0d86e..90e76852c 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/Ros.xtext +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/Ros.xtext @@ -6,38 +6,23 @@ import "http://www.ipa.fraunhofer.de/primitives" as primitives import "http://www.eclipse.org/emf/2002/Ecore" as ecore import "http://www.eclipse.org/emf/2003/XMLType" as type - - PackageSet returns PackageSet: {PackageSet} - 'PackageSet' - '{' - (package+=Package ( "," package+=Package)* )? - '}'; - -Package returns Package: - Package_Impl | CatkinPackage | AmentPackage; - -SpecBase returns SpecBase: - ServiceSpec | TopicSpec | ActionSpec; - -Dependency returns Dependency: - PackageDependency | ExternalDependency; + package+=Package_Impl* + ; +/////////////////// +// YAML format +/////////////////// +terminal BEGIN: 'synthetic:BEGIN'; +terminal END: 'synthetic:END'; -Namespace returns Namespace: - GlobalNamespace | RelativeNamespace_Impl | PrivateNamespace; - -Package_Impl returns Package: - {Package} - 'Package' - name=EString - '{' - ('FromGitRepo' fromGitRepo=EString)? - ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - (artifact+=Artifact ( "," artifact+=Artifact)*)? - '}'; +@Override +terminal SL_COMMENT: '#' !('\n'|'\r')*; +/////////////////// +// CONVENTIONS AND NAMES +/////////////////// EString returns ecore::EString: STRING | ID; @@ -45,182 +30,258 @@ RosNames returns ecore::EString: ROS_CONVENTION_A | ID | 'node' ; -RosParamNames returns ecore::EString: - ROS_CONVENTION_PARAM | ID -; - terminal ROS_CONVENTION_A: ( ('/' ID ) | ( ID '/' ) )* ; terminal ROS_CONVENTION_PARAM: ( ('/' STRING ) | ( STRING '/' ) | ('~' STRING ) )* ; - -Artifact returns Artifact: - {Artifact} - 'Artifact' - name=RosNames - '{' - (node=Node)? - '}'; + +/////////////////// +//PACKAGES +/////////////////// +Package returns Package: + Package_Impl //| + //CatkinPackage | + //AmentPackage + ; + +Package_Impl returns Package: + {Package} + name=RosNames':' + BEGIN + ('fromGitRepo:' fromGitRepo=EString)? + ('specs:' + BEGIN + spec+=SpecBase* + END + )? + ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + END; CatkinPackage returns CatkinPackage: {CatkinPackage} - 'CatkinPackage' - name=RosNames - '{' - ('FromGitRepo' fromGitRepo=EString)? - ('Dependencies' '{' dependency+=Dependency ( "," dependency+=Dependency)* '}' )? - ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - (artifact+=Artifact ( "," artifact+=Artifact)*)? - '}'; - + name=RosNames':' + BEGIN + ('fromGitRepo:' fromGitRepo=EString)? + ('artifacts:' + BEGIN + artifact+=Artifact* + END + )? + ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + END; + AmentPackage returns AmentPackage: {AmentPackage} 'AmentPackage' - name=RosNames - '{' - ('FromGitRepo' fromGitRepo=EString)? - ('Dependencies' '{' dependency+=Dependency ( "," dependency+=Dependency)* '}' )? - ('Specs' '{' spec+=SpecBase ( "," spec+=SpecBase)* '}')? - (artifact+=Artifact ( "," artifact+=Artifact)*)? - '}'; + name=RosNames':' + BEGIN + ('fromGitRepo:' fromGitRepo=EString)? + ('artifacts:' + BEGIN + artifact+=Artifact* + END + )? + ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + END; + +/////////////////// +//ARTIFACT AND NODE +/////////////////// +Artifact returns Artifact: + {Artifact} + name=RosNames':' + BEGIN + (node=Node)? + END; -ServiceSpec returns ServiceSpec: - {ServiceSpec} - 'ServiceSpec' - name=EString - '{' - ('request' request=MessageDefinition)? - ('response' response=MessageDefinition)? - '}'; +Node returns Node: + 'node:' name=RosNames + BEGIN + ( + ('publishers:' + BEGIN + publisher+=Publisher* + END + )| + ('subscribers:' + BEGIN + subscriber+=Subscriber* + END + )| + ('serviceserver:' + BEGIN + serviceserver+=ServiceServer* + END + )| + ('serviceclient:' + BEGIN + serviceclient+=ServiceClient* + END + )| + ('actionserver:' + BEGIN + actionserver+=ActionServer* + END + )| + ('actionclient:' + BEGIN + actionclient+=ActionClient* + END + )| + ('parameters:' + BEGIN + parameter+=Parameter* + END + ) + )*END + ; + +/////////////////// +//OBJECTS/SPECIFICATIONS +/////////////////// +SpecBase returns SpecBase: + TopicSpec | ServiceSpec | ActionSpec; TopicSpec returns TopicSpec: {TopicSpec} - 'TopicSpec' - name=(EString|'Header'|'String') - '{' - ('message' message=MessageDefinition)? - '}'; + 'msg:'name=(EString|'Header'|'String') + BEGIN + 'message:' (BEGIN message=MessageDefinition END)? + END + ; +ServiceSpec returns ServiceSpec: + {ServiceSpec} + 'srv:'name=EString + BEGIN + 'request:' (BEGIN request=MessageDefinition END)? + 'response:' (BEGIN response=MessageDefinition END)? + END; + ActionSpec returns ActionSpec: {ActionSpec} - 'ActionSpec' - name=EString - '{' - ('goal' goal=MessageDefinition)? - ('result' result=MessageDefinition)? - ('feedback' feedback=MessageDefinition)? - '}'; + 'action:'name=EString + BEGIN + 'goal:' (BEGIN goal=MessageDefinition END)? + 'result:' (BEGIN result=MessageDefinition END)? + 'feedback:' (BEGIN feedback=MessageDefinition END)? + END; MessageDefinition returns MessageDefinition: {MessageDefinition} - '{' - ( MessagePart+=MessagePart ( MessagePart+=MessagePart)* )? - '}'; - -Node returns Node: - 'Node' - '{' - 'name' name=RosNames - ('ServiceServers' '{' serviceserver+=ServiceServer ( "," serviceserver+=ServiceServer)* '}')? - ('Publishers' '{' publisher+=Publisher ( "," publisher+=Publisher)* '}')? - ('Subscribers' '{' subscriber+=Subscriber ( "," subscriber+=Subscriber)* '}')? - ('ServiceClients' '{' serviceclient+=ServiceClient ( "," serviceclient+=ServiceClient)* '}')? - ('ActionServers' '{' actionserver+=ActionServer ( "," actionserver+=ActionServer)* '}')? - ('ActionClients' '{' actionclient+=ActionClient ( "," actionclient+=ActionClient)* '}' )? - ('Parameters' '{' parameter+=Parameter ( "," parameter+=Parameter)* '}' )? - '}'; - -ServiceServer returns ServiceServer: - 'ServiceServer' - '{' - 'name' name=EString - 'service' service=[ServiceSpec|EString] - ('namespace' namespace=Namespace)? - '}'; + MessagePart+=MessagePart*; +/////////////////// +//INTERFACES +/////////////////// Publisher returns Publisher: - 'Publisher' - '{' - 'name' name=EString - 'message' message=[TopicSpec|EString] - ('namespace' namespace=Namespace)? - '}'; + {Publisher} + name=EString':' + BEGIN + 'type:' message=[TopicSpec|EString] + ('ns:' namespace=Namespace)? + END + ; Subscriber returns Subscriber: - 'Subscriber' - '{' - 'name' name=EString - 'message' message=[TopicSpec|EString] - ('namespace' namespace=Namespace)? - '}'; + {Subscriber} + name=EString':' + BEGIN + 'type:' message=[TopicSpec|EString] + ('ns:' namespace=Namespace)? + END + ; + +ServiceServer returns ServiceServer: + {ServiceServer} + name=EString':' + BEGIN + 'type:' service=[ServiceSpec|EString] + ('ns:' namespace=Namespace)? + END + ; ServiceClient returns ServiceClient: - 'ServiceClient' - '{' - 'name' name=EString - 'service' service=[ServiceSpec|EString] - ('namespace' namespace=Namespace)? - '}'; + {ServiceClient} + name=EString':' + BEGIN + 'type:' service=[ServiceSpec|EString] + ('ns:' namespace=Namespace)? + END + ; ActionServer returns ActionServer: - 'ActionServer' - '{' - 'name' name=EString - 'action' action=[ActionSpec|EString] - ('namespace' namespace=Namespace)? - '}'; + {ActionServer} + name=EString':' + BEGIN + 'type:' action=[ActionSpec|EString] + ('ns:' namespace=Namespace)? + END + ; ActionClient returns ActionClient: - 'ActionClient' - '{' - 'name' name=EString - 'action' action=[ActionSpec|EString] - ('namespace' namespace=Namespace)? - '}'; - -GraphName returns GraphName: - 'GraphName' ; + {ActionClient} + name=EString':' + BEGIN + 'type:' action=[ActionSpec|EString] + ('ns:' namespace=Namespace)? + END + ; +/////////////////// +//DEPENDENCIES +/////////////////// +Dependency returns Dependency: + PackageDependency | ExternalDependency; PackageDependency returns PackageDependency: - package=[Package|EString] -; + package=[Package|EString]; ExternalDependency returns ExternalDependency: {ExternalDependency} 'ExternalDependency' name=EString; +/////////////////// +//NAMESPACES +/////////////////// +Namespace returns Namespace: + GlobalNamespace | RelativeNamespace_Impl | PrivateNamespace; + +GraphName returns GraphName: + 'GraphName' ; + GlobalNamespace returns GlobalNamespace: {GlobalNamespace} 'GlobalNamespace' - '{' - ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - '}'; + ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; RelativeNamespace_Impl returns RelativeNamespace: {RelativeNamespace} 'RelativeNamespace' - '{' - ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - '}'; + ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; PrivateNamespace returns PrivateNamespace: {PrivateNamespace} 'PrivateNamespace' - '{' - ('parts' '{' parts+=GraphName ( "," parts+=GraphName)* '}' )? - '}'; + ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; +/////////////////// //PARAMETERS DEFINITION +/////////////////// +RosParamNames returns ecore::EString: + ROS_CONVENTION_PARAM | ID +; + Parameter returns Parameter: - 'Parameter' - '{' - 'name' name=EString - ('namespace' namespace=Namespace)? + {Parameter} + name=EString':' + BEGIN 'type' type=ParameterType + ('ns:' namespace=Namespace)? + END '}'; ParameterType returns ParameterType: @@ -233,16 +294,16 @@ ParameterValue returns ParameterValue: ParameterListType returns ParameterListType: {ParameterListType} 'List' - '{' + '[' sequence+=ParameterType ( ',' sequence+=ParameterType )* - '}'; + ']'; ParameterStructType returns ParameterStructType: {ParameterStructType} 'Struct' - '{' + '[' parameterstructypetmember+=ParameterStructTypeMember ( "," parameterstructypetmember+=ParameterStructTypeMember)* - '}'; + ']'; ParameterIntegerType returns ParameterIntegerType: {ParameterIntegerType} @@ -280,23 +341,22 @@ ParameterAnyType returns ParameterAnyType: ('default' default=ParameterAny)?; ParameterArrayType returns ParameterArrayType: - 'Array' - '{' + 'Array:' + BEGIN 'type' type=ParameterType ('default' default=ParameterList)? - '}'; + END; ParameterList returns ParameterSequence: {ParameterSequence} - '{' value+=ParameterValue ( ',' value+=ParameterValue )* '}' + '[' value+=ParameterValue ( ',' value+=ParameterValue )* ']' ; ParameterAny returns ParameterAny: {ParameterAny} 'ParameterAny' - '{' ('value' value=EString)? - '}'; + ; ParameterString returns ParameterString: value=EString @@ -320,7 +380,7 @@ ParameterBoolean returns ParameterBoolean: ParameterStruct returns ParameterStruct: {ParameterStruct} - ('{' value+=ParameterStructMember ( "," '{' value+=ParameterStructMember '}')* '}' )? + ('[' value+=ParameterStructMember ( "," '[' value+=ParameterStructMember ']')* ']' )? ; ParameterDate returns ParameterDate: @@ -330,10 +390,10 @@ ParameterDate returns ParameterDate: ParameterStructMember returns ParameterStructMember: 'ParameterStructMember' - name=EString - '{' - 'value' value=ParameterValue - '}'; + name=EString':' + BEGIN + value=ParameterValue + END; ParameterStructTypeMember returns ParameterStructTypeMember: @@ -341,14 +401,15 @@ ParameterStructTypeMember returns ParameterStructTypeMember: type=ParameterType ; - +/////////////////// //PARAMETERS PRIMITIVES TYPES -terminal fragment DIGIT: '0'..'9'; +/////////////////// +terminal DIGIT: '0'..'9'; terminal BINARY: ('0b'|'0B')('0'|'1')+; terminal BOOLEAN: 'true'|'false'; -terminal DOUBLE returns ecore::EDouble: DECINT (('.' DIGIT*) | (('.' DIGIT*)? ('E'|'e') ('-'|'+')? DECINT)); // Use terminal to avoid 'e' turning into a keyword +terminal DOUBLE returns ecore::EDouble: DIGIT (('.' DECINT*) | (('.' DIGIT*)? ('E'|'e') ('-'|'+')? DIGIT)); // Use terminal to avoid 'e' turning into a keyword terminal DECINT: '0' | ('1'..'9' DIGIT*) | ('-''0'..'9' DIGIT*) ; terminal DAY:'1'..'9' | '1'..'3' '0'..'9'; terminal MONTH:'1'..'9' | '1' '0'..'2'; @@ -372,8 +433,9 @@ Integer0 returns type::Int: DateTime0 returns type::DateTime: DATE_TIME; +/////////////////// //MESSAGE PRIMITIVES DEFINITION - +/////////////////// MessagePart returns primitives::MessagePart: Type = AbstractType Data =(KEYWORD | MESSAGE_ASIGMENT | EString) diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/RosRuntimeModule.xtend b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/RosRuntimeModule.xtend index 52ad080b2..287c582f3 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/RosRuntimeModule.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/RosRuntimeModule.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/RosStandaloneSetup.xtend b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/RosStandaloneSetup.xtend index 539a80f03..2325f2572 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/RosStandaloneSetup.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/RosStandaloneSetup.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/formatting2/RosFormatter.xtend b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/formatting2/RosFormatter.xtend index ac434c351..51f182dab 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/formatting2/RosFormatter.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/formatting2/RosFormatter.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.formatting2 diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/generator/RosGenerator.xtend b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/generator/RosGenerator.xtend index 3c135b26f..4221c7ca7 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/generator/RosGenerator.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/generator/RosGenerator.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.generator diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/parser/antlr/RosTokenSource.java b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/parser/antlr/RosTokenSource.java new file mode 100644 index 000000000..5b9aff1a2 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/parser/antlr/RosTokenSource.java @@ -0,0 +1,35 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros.parser.antlr; + +import de.fraunhofer.ipa.ros.parser.antlr.internal.InternalRosParser; +import org.antlr.runtime.Token; +import org.antlr.runtime.TokenSource; +import org.eclipse.xtext.parser.antlr.AbstractIndentationTokenSource; + +public class RosTokenSource extends AbstractIndentationTokenSource { + + public RosTokenSource(TokenSource delegate) { + super(delegate); + } + + @Override + protected boolean shouldSplitTokenImpl(Token token) { + // TODO Review assumption + return token.getType() == InternalRosParser.RULE_WS; + } + + @Override + protected int getBeginTokenType() { + // TODO Review assumption + return InternalRosParser.RULE_BEGIN; + } + + @Override + protected int getEndTokenType() { + // TODO Review assumption + return InternalRosParser.RULE_END; + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/scoping/RosScopeProvider.xtend b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/scoping/RosScopeProvider.xtend index cbd7a01f6..456cd0e47 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/scoping/RosScopeProvider.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/scoping/RosScopeProvider.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.scoping diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/validation/RosValidator.xtend b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/validation/RosValidator.xtend index 2123cf53f..f2ead9bab 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/validation/RosValidator.xtend +++ b/plugins/de.fraunhofer.ipa.ros.xtext/src/de/fraunhofer/ipa/ros/validation/RosValidator.xtend @@ -1,5 +1,5 @@ /* - * generated by Xtext 2.12.0 + * generated by Xtext 2.25.0 */ package de.fraunhofer.ipa.ros.validation diff --git a/plugins/de.fraunhofer.ipa.ros/basic_msgs/common_msgs.ros b/plugins/de.fraunhofer.ipa.ros/basic_msgs/common_msgs.ros deleted file mode 100644 index d0232226c..000000000 --- a/plugins/de.fraunhofer.ipa.ros/basic_msgs/common_msgs.ros +++ /dev/null @@ -1,120 +0,0 @@ -PackageSet{package{ - Package geometry_msgs{spec{ - TopicSpec Accel{}, - TopicSpec AccelStamped{}, - TopicSpec AccelWithCovariance{}, - TopicSpec AccelWithCovarianceStamped{}, - TopicSpec Inertia{}, - TopicSpec InertiaStamped{}, - TopicSpec Point{}, - TopicSpec Point32{}, - TopicSpec PointStamped{}, - TopicSpec Polygon{}, - TopicSpec PolygonStamped{}, - TopicSpec Pose{}, - TopicSpec Pose2D{}, - TopicSpec PoseArray{}, - TopicSpec PoseStamped{}, - TopicSpec PoseWithCovariance{}, - TopicSpec PoseWithCovarianceStamped{}, - TopicSpec Quaternion{}, - TopicSpec QuaternionStamped{}, - TopicSpec Transform{}, - TopicSpec TransformStamped{}, - TopicSpec Twist{}, - TopicSpec TwistStamped{}, - TopicSpec TwistWithCovariance{}, - TopicSpec TwistWithCovarianceStamped{}, - TopicSpec Vector3{}, - TopicSpec Vector3Stamped{}, - TopicSpec Wrench{}, - TopicSpec WrenchStamped{} - }}, - Package actionlib_msgs{spec{ - TopicSpec GoalID{}, - TopicSpec GoalStatus{}, - TopicSpec GoalStatusArray{} - }}, - Package diagnostic_msgs{spec{ - TopicSpec DiagnosticArray{}, - TopicSpec DiagnosticStatus{}, - TopicSpec KeyValue{}, - ServiceSpec AddDiagnostics{}, - ServiceSpec SelfTest{} - }}, - Package nav_msgs{spec{ - TopicSpec GetMapAction{}, - TopicSpec GetMapActionFeedback{}, - TopicSpec GetMapActionGoal{}, - TopicSpec GetMapActionResult{}, - TopicSpec GetMapFeedback{}, - TopicSpec GetMapGoal{}, - TopicSpec GetMapResult{}, - TopicSpec GridCells{}, - TopicSpec MapMetaData{}, - TopicSpec OccupancyGrid{}, - TopicSpec Odometry{}, - TopicSpec Path{}, - ServiceSpec GetMap{}, - ServiceSpec GetPlan{}, - ServiceSpec SetMap{} - }}, - Package sensor_msgs{spec{ - TopicSpec BatteryState{}, - TopicSpec CameraInfo{}, - TopicSpec ChannelFloat32{}, - TopicSpec CompressedImage{}, - TopicSpec FluidPressure{}, - TopicSpec Illuminance{}, - TopicSpec Image{}, - TopicSpec Imu{}, - TopicSpec JointState{}, - TopicSpec Joy{}, - TopicSpec JoyFeedback{}, - TopicSpec JoyFeedbackArray{}, - TopicSpec LaserEcho{}, - TopicSpec LaserScan{}, - TopicSpec MagneticField{}, - TopicSpec MultiDOFJointState{}, - TopicSpec MultiEchoLaserScan{}, - TopicSpec NavSatFix{}, - TopicSpec NavSatStatus{}, - TopicSpec PointCloud{}, - TopicSpec PointCloud2{}, - TopicSpec PointField{}, - TopicSpec Range{}, - TopicSpec RegionOfInterest{}, - TopicSpec RelativeHumidity{}, - TopicSpec Temperature{}, - TopicSpec TimeReference{}, - ServiceSpec SetCameraInfo{} - }}, - Package shape_msgs{spec{ - TopicSpec Mesh{}, - TopicSpec MeshTriangle{}, - TopicSpec Plane{}, - TopicSpec SolidPrimitive{} - }}, - Package stereo_msgs{spec{ - TopicSpec DisparityImage{} - }}, - Package trajectory_msgs{spec{ - TopicSpec JointTrajectory{}, - TopicSpec JointTrajectoryPoint{}, - TopicSpec MultiDOFJointTrajectory{}, - TopicSpec MultiDOFJointTrajectoryPoint{} - }}, - Package visualization_msgs{spec{ - TopicSpec ImageMarker{}, - TopicSpec InteractiveMarker{}, - TopicSpec InteractiveMarkerControl{}, - TopicSpec InteractiveMarkerFeedback{}, - TopicSpec InteractiveMarkerInit{}, - TopicSpec InteractiveMarkerPose{}, - TopicSpec InteractiveMarkerUpdate{}, - TopicSpec Marker{}, - TopicSpec MarkerArray{}, - TopicSpec MenuEntry{} - }} - } -} diff --git a/plugins/de.fraunhofer.ipa.ros/basic_msgs/generate_messages_model_helper.sh b/plugins/de.fraunhofer.ipa.ros/basic_msgs/generate_messages_model_helper.sh deleted file mode 100755 index 92942aa00..000000000 --- a/plugins/de.fraunhofer.ipa.ros/basic_msgs/generate_messages_model_helper.sh +++ /dev/null @@ -1,49 +0,0 @@ -#!/bin/bash -package_list=$@ - -echo 'PackageSet{package{' -arr_pkg=($package_list) -cout_pkg=${#arr_pkg[@]} - -for p in $package_list -do - cout_pkg=$((cout_pkg-1)) - messages_fullname=$(rosmsg list | grep $p) - arr_msg=($messages_fullname) - cout_msg=${#arr_msg[@]} - services_fullname=$(rossrv list | grep $p) - arr_srv=($services_fullname) - cout_srv=${#arr_srv[@]} - - echo ' Package '$p'{spec{' - - for i in $messages_fullname - do - cout_msg=$((cout_msg-1)) - message=${i/$p\//} - echo -n ' TopicSpec '$message'{}' - if (("$cout_msg" >= "1" || "$cout_srv" >= "1" )) - then - echo ',' - fi - done - - for i in $services_fullname - do - cout_srv=$((cout_srv-1)) - service=${i/$p\//} - echo -n ' ServiceSpec '$service'{}' - if (("$cout_srv" >= "1")) - then - echo ',' - fi - done - echo -n $'\n }}' - if (("$cout_pkg" >= "1")) - then - echo ',' - fi -done - -echo $'\n }' -echo '}' diff --git a/plugins/de.fraunhofer.ipa.ros/basic_msgs/ros_core.ros b/plugins/de.fraunhofer.ipa.ros/basic_msgs/ros_core.ros deleted file mode 100644 index 882aae8b0..000000000 --- a/plugins/de.fraunhofer.ipa.ros/basic_msgs/ros_core.ros +++ /dev/null @@ -1,42 +0,0 @@ -PackageSet{package{ - Package std_msgs{spec{ - TopicSpec Bool{}, - TopicSpec Byte{}, - TopicSpec ByteMultiArray{}, - TopicSpec Char{}, - TopicSpec ColorRGBA{}, - TopicSpec Duration{}, - TopicSpec Empty{}, - TopicSpec Float32{}, - TopicSpec Float32MultiArray{}, - TopicSpec Float64{}, - TopicSpec Float64MultiArray{}, - TopicSpec Header{}, - TopicSpec Int16{}, - TopicSpec Int16MultiArray{}, - TopicSpec Int32{}, - TopicSpec Int32MultiArray{}, - TopicSpec Int64{}, - TopicSpec Int64MultiArray{}, - TopicSpec Int8{}, - TopicSpec Int8MultiArray{}, - TopicSpec MultiArrayDimension{}, - TopicSpec MultiArrayLayout{}, - TopicSpec String{}, - TopicSpec Time{}, - TopicSpec UInt16{}, - TopicSpec UInt16MultiArray{}, - TopicSpec UInt32{}, - TopicSpec UInt32MultiArray{}, - TopicSpec UInt64{}, - TopicSpec UInt64MultiArray{}, - TopicSpec UInt8{}, - TopicSpec UInt8MultiArray{} - }}, - Package std_srvs{spec{ - ServiceSpec Empty{}, - ServiceSpec SetBool{}, - ServiceSpec Trigger{} - }} - } -} diff --git a/plugins/de.fraunhofer.ipa.ros/model/ros.aird b/plugins/de.fraunhofer.ipa.ros/model/ros.aird index 591b213d4..c61d80a6d 100644 --- a/plugins/de.fraunhofer.ipa.ros/model/ros.aird +++ b/plugins/de.fraunhofer.ipa.ros/model/ros.aird @@ -1,6 +1,6 @@ - - + + ros.ecore http://www.eclipse.org/emf/2002/Ecore http://www.eclipse.org/emf/2003/XMLType @@ -8,11 +8,11 @@ PrimitivesTypes.ecore - + - + @@ -21,7 +21,7 @@ - + @@ -83,7 +83,7 @@ - + @@ -92,11 +92,15 @@ + + + + - + @@ -105,7 +109,7 @@ - + @@ -114,7 +118,7 @@ - + @@ -123,7 +127,7 @@ - + @@ -132,7 +136,7 @@ - + @@ -141,7 +145,7 @@ - + @@ -150,7 +154,7 @@ - + @@ -163,7 +167,7 @@ - + @@ -172,7 +176,7 @@ - + @@ -185,7 +189,7 @@ - + @@ -202,7 +206,7 @@ - + @@ -211,7 +215,7 @@ - + @@ -220,7 +224,7 @@ - + @@ -229,7 +233,7 @@ - + @@ -238,7 +242,7 @@ - + @@ -247,7 +251,7 @@ - + @@ -256,20 +260,20 @@ - + - - - + + + - + @@ -282,7 +286,7 @@ - + @@ -291,7 +295,7 @@ - + @@ -300,7 +304,7 @@ - + @@ -309,7 +313,7 @@ - + @@ -322,7 +326,7 @@ - + @@ -335,7 +339,7 @@ - + @@ -344,7 +348,7 @@ - + @@ -353,7 +357,7 @@ - + @@ -362,7 +366,7 @@ - + @@ -371,7 +375,7 @@ - + @@ -380,7 +384,7 @@ - + @@ -389,7 +393,7 @@ - + @@ -398,7 +402,7 @@ - + @@ -407,7 +411,7 @@ - + @@ -416,7 +420,7 @@ - + @@ -425,7 +429,7 @@ - + @@ -434,7 +438,7 @@ - + @@ -447,7 +451,7 @@ - + @@ -456,7 +460,7 @@ - + @@ -465,7 +469,7 @@ - + @@ -478,7 +482,7 @@ - + @@ -491,7 +495,7 @@ - + @@ -504,7 +508,7 @@ - + @@ -517,7 +521,7 @@ - + @@ -530,7 +534,7 @@ - + @@ -543,7 +547,7 @@ - + @@ -552,7 +556,7 @@ - + @@ -561,7 +565,7 @@ - + @@ -574,7 +578,7 @@ - + @@ -587,936 +591,728 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + + + + + + + + + + + + + + + + + - + - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + - + - + - - - + + + - - + + - - + + - - - - - + + + + + - + - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + + + + + + + + + + + + + + + + + - + - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - + - + - + - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + - - - - - - + + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + @@ -1530,24 +1326,24 @@ - - + + - + - + - + - - + + @@ -1579,7 +1375,7 @@ - + @@ -1598,22 +1394,6 @@ - - - - - - - - - - - - - - - - @@ -1650,49 +1430,257 @@ - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + - - - + + + - - + + - - + + - - - - - + + + + + @@ -1808,18 +1796,18 @@ - + - + - - + + @@ -1838,27 +1826,62 @@ - - - + + + - - + + - - + + - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -1872,9 +1895,12 @@ - + + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -1887,10 +1913,21 @@ + + + + + + + + - + + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO italic @@ -1900,6 +1937,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -1908,6 +1948,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -1916,6 +1959,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -1924,6 +1970,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -1932,6 +1981,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -1940,6 +1992,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -1953,9 +2008,12 @@ - + + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -1964,6 +2022,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -1980,6 +2041,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO italic @@ -2005,6 +2069,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2013,6 +2080,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2021,6 +2091,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2029,6 +2102,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2037,6 +2113,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2045,6 +2124,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2053,16 +2135,18 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO - - - - - italic - + + + + + @@ -2070,6 +2154,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO italic @@ -2087,6 +2174,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2095,6 +2185,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2103,6 +2196,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2111,6 +2207,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2127,6 +2226,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2147,6 +2249,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO italic @@ -2156,6 +2261,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2164,6 +2272,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2172,6 +2283,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2180,6 +2294,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2188,14 +2305,20 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO - + + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2204,6 +2327,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2212,6 +2338,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2220,6 +2349,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2228,6 +2360,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2236,6 +2371,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2252,14 +2390,20 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO - + + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO italic @@ -2269,6 +2413,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2285,6 +2432,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2301,6 +2451,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2317,11 +2470,14 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO - + @@ -2333,6 +2489,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2349,6 +2508,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2365,6 +2527,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2373,6 +2538,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2381,6 +2549,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2397,6 +2568,9 @@ + KEEP_LOCATION + KEEP_SIZE + KEEP_RATIO @@ -2604,19 +2778,6 @@ - - - - - - labelSize - - - labelSize - - - - @@ -3402,6 +3563,32 @@ + + + + + + labelSize + + + labelSize + + + + + + + + + + labelSize + + + labelSize + + + + @@ -3410,7 +3597,7 @@ - + diff --git a/plugins/de.fraunhofer.ipa.ros/model/ros.ecore b/plugins/de.fraunhofer.ipa.ros/model/ros.ecore index 5ae5caf01..44624fbca 100644 --- a/plugins/de.fraunhofer.ipa.ros/model/ros.ecore +++ b/plugins/de.fraunhofer.ipa.ros/model/ros.ecore @@ -36,7 +36,7 @@ - + @@ -52,7 +52,7 @@ - + @@ -70,11 +70,11 @@ volatile="true" transient="true" defaultValueLiteral="" unsettable="true" iD="true"/> - + - + @@ -90,11 +90,11 @@ - + - + @@ -109,10 +109,12 @@ - + + @@ -138,7 +140,7 @@ - + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros/model/ros.genmodel b/plugins/de.fraunhofer.ipa.ros/model/ros.genmodel index ac6b9c122..0c48ed606 100644 --- a/plugins/de.fraunhofer.ipa.ros/model/ros.genmodel +++ b/plugins/de.fraunhofer.ipa.ros/model/ros.genmodel @@ -83,9 +83,10 @@ - - - + + + + @@ -162,6 +163,13 @@ + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros/model/ros_class_diagram.jpg b/plugins/de.fraunhofer.ipa.ros/model/ros_class_diagram.jpg new file mode 100644 index 000000000..5ce5a5c9c Binary files /dev/null and b/plugins/de.fraunhofer.ipa.ros/model/ros_class_diagram.jpg differ diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/ActionClient.java b/plugins/de.fraunhofer.ipa.ros/src/ros/ActionClient.java index 3f9def6f0..cc3995d7b 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/ActionClient.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/ActionClient.java @@ -19,7 +19,7 @@ * @model * @generated */ -public interface ActionClient extends NamespacedElement { +public interface ActionClient extends InterfaceType { /** * Returns the value of the 'Action' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/ActionServer.java b/plugins/de.fraunhofer.ipa.ros/src/ros/ActionServer.java index 1f29fd89b..d8e70d976 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/ActionServer.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/ActionServer.java @@ -19,7 +19,7 @@ * @model * @generated */ -public interface ActionServer extends NamespacedElement { +public interface ActionServer extends InterfaceType { /** * Returns the value of the 'Action' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/InterfaceType.java b/plugins/de.fraunhofer.ipa.ros/src/ros/InterfaceType.java new file mode 100644 index 000000000..85d4d1019 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/InterfaceType.java @@ -0,0 +1,92 @@ +/** + */ +package ros; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Interface Type'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link ros.InterfaceType#getNamespace Namespace}
    • + *
  • {@link ros.InterfaceType#getName Name}
    • + *
  • {@link ros.InterfaceType#getQos Qos}
    • + *
+ * + * @see ros.RosPackage#getInterfaceType() + * @model + * @generated + */ +public interface InterfaceType extends EObject { + /** + * Returns the value of the 'Namespace' containment reference. + * + * + * @return the value of the 'Namespace' containment reference. + * @see #setNamespace(Namespace) + * @see ros.RosPackage#getInterfaceType_Namespace() + * @model containment="true" + * @generated + */ + Namespace getNamespace(); + + /** + * Sets the value of the '{@link ros.InterfaceType#getNamespace Namespace}' containment reference. + * + * + * @param value the new value of the 'Namespace' containment reference. + * @see #getNamespace() + * @generated + */ + void setNamespace(Namespace value); + + /** + * Returns the value of the 'Name' attribute. + * + * + * @return the value of the 'Name' attribute. + * @see #setName(String) + * @see ros.RosPackage#getInterfaceType_Name() + * @model dataType="ros.GraphName" required="true" + * @generated + */ + String getName(); + + /** + * Sets the value of the '{@link ros.InterfaceType#getName Name}' attribute. + * + * + * @param value the new value of the 'Name' attribute. + * @see #getName() + * @generated + */ + void setName(String value); + + /** + * Returns the value of the 'Qos' containment reference. + * + * + * @return the value of the 'Qos' containment reference. + * @see #setQos(QualityOfService) + * @see ros.RosPackage#getInterfaceType_Qos() + * @model containment="true" + * @generated + */ + QualityOfService getQos(); + + /** + * Sets the value of the '{@link ros.InterfaceType#getQos Qos}' containment reference. + * + * + * @param value the new value of the 'Qos' containment reference. + * @see #getQos() + * @generated + */ + void setQos(QualityOfService value); + +} // InterfaceType diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/Parameter.java b/plugins/de.fraunhofer.ipa.ros/src/ros/Parameter.java index 8e57407a5..52016cb26 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/Parameter.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/Parameter.java @@ -20,7 +20,7 @@ * @model * @generated */ -public interface Parameter extends NamespacedElement { +public interface Parameter extends InterfaceType { /** * Returns the value of the 'Type' containment reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/Publisher.java b/plugins/de.fraunhofer.ipa.ros/src/ros/Publisher.java index ea4b97c41..9f2e00d95 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/Publisher.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/Publisher.java @@ -19,7 +19,7 @@ * @model * @generated */ -public interface Publisher extends NamespacedElement { +public interface Publisher extends InterfaceType { /** * Returns the value of the 'Message' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/QualityOfService.java b/plugins/de.fraunhofer.ipa.ros/src/ros/QualityOfService.java new file mode 100644 index 000000000..2a34be0f5 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/QualityOfService.java @@ -0,0 +1,142 @@ +/** + */ +package ros; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Quality Of Service'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link ros.QualityOfService#getQoSProfile Qo SProfile}
    • + *
  • {@link ros.QualityOfService#getHistory History}
    • + *
  • {@link ros.QualityOfService#getDepth Depth}
    • + *
  • {@link ros.QualityOfService#getReliability Reliability}
    • + *
  • {@link ros.QualityOfService#getDurability Durability}
    • + *
+ * + * @see ros.RosPackage#getQualityOfService() + * @model + * @generated + */ +public interface QualityOfService extends EObject { + /** + * Returns the value of the 'Qo SProfile' attribute. + * The default value is "default_qos". + * + * + * @return the value of the 'Qo SProfile' attribute. + * @see #setQoSProfile(String) + * @see ros.RosPackage#getQualityOfService_QoSProfile() + * @model default="default_qos" + * @generated + */ + String getQoSProfile(); + + /** + * Sets the value of the '{@link ros.QualityOfService#getQoSProfile Qo SProfile}' attribute. + * + * + * @param value the new value of the 'Qo SProfile' attribute. + * @see #getQoSProfile() + * @generated + */ + void setQoSProfile(String value); + + /** + * Returns the value of the 'History' attribute. + * The default value is "keep_all". + * + * + * @return the value of the 'History' attribute. + * @see #setHistory(String) + * @see ros.RosPackage#getQualityOfService_History() + * @model default="keep_all" + * @generated + */ + String getHistory(); + + /** + * Sets the value of the '{@link ros.QualityOfService#getHistory History}' attribute. + * + * + * @param value the new value of the 'History' attribute. + * @see #getHistory() + * @generated + */ + void setHistory(String value); + + /** + * Returns the value of the 'Depth' attribute. + * + * + * @return the value of the 'Depth' attribute. + * @see #setDepth(int) + * @see ros.RosPackage#getQualityOfService_Depth() + * @model dataType="org.eclipse.emf.ecore.xml.type.Int" + * @generated + */ + int getDepth(); + + /** + * Sets the value of the '{@link ros.QualityOfService#getDepth Depth}' attribute. + * + * + * @param value the new value of the 'Depth' attribute. + * @see #getDepth() + * @generated + */ + void setDepth(int value); + + /** + * Returns the value of the 'Reliability' attribute. + * The default value is "reliable". + * + * + * @return the value of the 'Reliability' attribute. + * @see #setReliability(String) + * @see ros.RosPackage#getQualityOfService_Reliability() + * @model default="reliable" + * @generated + */ + String getReliability(); + + /** + * Sets the value of the '{@link ros.QualityOfService#getReliability Reliability}' attribute. + * + * + * @param value the new value of the 'Reliability' attribute. + * @see #getReliability() + * @generated + */ + void setReliability(String value); + + /** + * Returns the value of the 'Durability' attribute. + * The default value is "transient_local". + * + * + * @return the value of the 'Durability' attribute. + * @see #setDurability(String) + * @see ros.RosPackage#getQualityOfService_Durability() + * @model default="transient_local" + * @generated + */ + String getDurability(); + + /** + * Sets the value of the '{@link ros.QualityOfService#getDurability Durability}' attribute. + * + * + * @param value the new value of the 'Durability' attribute. + * @see #getDurability() + * @generated + */ + void setDurability(String value); + +} // QualityOfService diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/RosFactory.java b/plugins/de.fraunhofer.ipa.ros/src/ros/RosFactory.java index 022681105..da599a52c 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/RosFactory.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/RosFactory.java @@ -202,13 +202,13 @@ public interface RosFactory extends EFactory { PrivateNamespace createPrivateNamespace(); /** - * Returns a new object of class 'Namespaced Element'. + * Returns a new object of class 'Interface Type'. * * - * @return a new object of class 'Namespaced Element'. + * @return a new object of class 'Interface Type'. * @generated */ - NamespacedElement createNamespacedElement(); + InterfaceType createInterfaceType(); /** * Returns a new object of class 'Parameter List Type'. @@ -417,6 +417,15 @@ public interface RosFactory extends EFactory { */ AmentPackage createAmentPackage(); + /** + * Returns a new object of class 'Quality Of Service'. + * + * + * @return a new object of class 'Quality Of Service'. + * @generated + */ + QualityOfService createQualityOfService(); + /** * Returns the package supported by this factory. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/RosPackage.java b/plugins/de.fraunhofer.ipa.ros/src/ros/RosPackage.java index 567ce77ca..22ed7a6f8 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/RosPackage.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/RosPackage.java @@ -387,14 +387,14 @@ public interface RosPackage extends EPackage { int SERVICE_SPEC_OPERATION_COUNT = SPEC_BASE_OPERATION_COUNT + 0; /** - * The meta object id for the '{@link ros.impl.NamespacedElementImpl Namespaced Element}' class. + * The meta object id for the '{@link ros.impl.InterfaceTypeImpl Interface Type}' class. * * - * @see ros.impl.NamespacedElementImpl - * @see ros.impl.RosPackageImpl#getNamespacedElement() + * @see ros.impl.InterfaceTypeImpl + * @see ros.impl.RosPackageImpl#getInterfaceType() * @generated */ - int NAMESPACED_ELEMENT = 23; + int INTERFACE_TYPE = 23; /** * The feature id for the 'Namespace' containment reference. @@ -403,7 +403,43 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int NAMESPACED_ELEMENT__NAMESPACE = 0; + int INTERFACE_TYPE__NAMESPACE = 0; + + /** + * The feature id for the 'Name' attribute. + * + * + * @generated + * @ordered + */ + int INTERFACE_TYPE__NAME = 1; + + /** + * The feature id for the 'Qos' containment reference. + * + * + * @generated + * @ordered + */ + int INTERFACE_TYPE__QOS = 2; + + /** + * The number of structural features of the 'Interface Type' class. + * + * + * @generated + * @ordered + */ + int INTERFACE_TYPE_FEATURE_COUNT = 3; + + /** + * The number of operations of the 'Interface Type' class. + * + * + * @generated + * @ordered + */ + int INTERFACE_TYPE_OPERATION_COUNT = 0; /** * The meta object id for the '{@link ros.impl.ServiceServerImpl Service Server}' class. @@ -576,49 +612,31 @@ public interface RosPackage extends EPackage { int PRIVATE_NAMESPACE = 22; /** - * The feature id for the 'Name' attribute. - * - * - * @generated - * @ordered - */ - int NAMESPACED_ELEMENT__NAME = 1; - - /** - * The number of structural features of the 'Namespaced Element' class. - * - * - * @generated - * @ordered - */ - int NAMESPACED_ELEMENT_FEATURE_COUNT = 2; - - /** - * The number of operations of the 'Namespaced Element' class. + * The feature id for the 'Namespace' containment reference. * * * @generated * @ordered */ - int NAMESPACED_ELEMENT_OPERATION_COUNT = 0; + int SERVICE_SERVER__NAMESPACE = INTERFACE_TYPE__NAMESPACE; /** - * The feature id for the 'Namespace' containment reference. + * The feature id for the 'Name' attribute. * * * @generated * @ordered */ - int SERVICE_SERVER__NAMESPACE = NAMESPACED_ELEMENT__NAMESPACE; + int SERVICE_SERVER__NAME = INTERFACE_TYPE__NAME; /** - * The feature id for the 'Name' attribute. + * The feature id for the 'Qos' containment reference. * * * @generated * @ordered */ - int SERVICE_SERVER__NAME = NAMESPACED_ELEMENT__NAME; + int SERVICE_SERVER__QOS = INTERFACE_TYPE__QOS; /** * The feature id for the 'Service' reference. @@ -627,7 +645,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SERVICE_SERVER__SERVICE = NAMESPACED_ELEMENT_FEATURE_COUNT + 0; + int SERVICE_SERVER__SERVICE = INTERFACE_TYPE_FEATURE_COUNT + 0; /** * The number of structural features of the 'Service Server' class. @@ -636,7 +654,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SERVICE_SERVER_FEATURE_COUNT = NAMESPACED_ELEMENT_FEATURE_COUNT + 1; + int SERVICE_SERVER_FEATURE_COUNT = INTERFACE_TYPE_FEATURE_COUNT + 1; /** * The number of operations of the 'Service Server' class. @@ -645,7 +663,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SERVICE_SERVER_OPERATION_COUNT = NAMESPACED_ELEMENT_OPERATION_COUNT + 0; + int SERVICE_SERVER_OPERATION_COUNT = INTERFACE_TYPE_OPERATION_COUNT + 0; /** * The feature id for the 'Name' attribute. @@ -825,7 +843,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int PUBLISHER__NAMESPACE = NAMESPACED_ELEMENT__NAMESPACE; + int PUBLISHER__NAMESPACE = INTERFACE_TYPE__NAMESPACE; /** * The feature id for the 'Name' attribute. @@ -834,7 +852,16 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int PUBLISHER__NAME = NAMESPACED_ELEMENT__NAME; + int PUBLISHER__NAME = INTERFACE_TYPE__NAME; + + /** + * The feature id for the 'Qos' containment reference. + * + * + * @generated + * @ordered + */ + int PUBLISHER__QOS = INTERFACE_TYPE__QOS; /** * The feature id for the 'Message' reference. @@ -843,7 +870,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int PUBLISHER__MESSAGE = NAMESPACED_ELEMENT_FEATURE_COUNT + 0; + int PUBLISHER__MESSAGE = INTERFACE_TYPE_FEATURE_COUNT + 0; /** * The number of structural features of the 'Publisher' class. @@ -852,7 +879,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int PUBLISHER_FEATURE_COUNT = NAMESPACED_ELEMENT_FEATURE_COUNT + 1; + int PUBLISHER_FEATURE_COUNT = INTERFACE_TYPE_FEATURE_COUNT + 1; /** * The number of operations of the 'Publisher' class. @@ -861,7 +888,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int PUBLISHER_OPERATION_COUNT = NAMESPACED_ELEMENT_OPERATION_COUNT + 0; + int PUBLISHER_OPERATION_COUNT = INTERFACE_TYPE_OPERATION_COUNT + 0; /** * The feature id for the 'Name' attribute. @@ -906,7 +933,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SUBSCRIBER__NAMESPACE = NAMESPACED_ELEMENT__NAMESPACE; + int SUBSCRIBER__NAMESPACE = INTERFACE_TYPE__NAMESPACE; /** * The feature id for the 'Name' attribute. @@ -915,7 +942,16 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SUBSCRIBER__NAME = NAMESPACED_ELEMENT__NAME; + int SUBSCRIBER__NAME = INTERFACE_TYPE__NAME; + + /** + * The feature id for the 'Qos' containment reference. + * + * + * @generated + * @ordered + */ + int SUBSCRIBER__QOS = INTERFACE_TYPE__QOS; /** * The feature id for the 'Message' reference. @@ -924,7 +960,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SUBSCRIBER__MESSAGE = NAMESPACED_ELEMENT_FEATURE_COUNT + 0; + int SUBSCRIBER__MESSAGE = INTERFACE_TYPE_FEATURE_COUNT + 0; /** * The number of structural features of the 'Subscriber' class. @@ -933,7 +969,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SUBSCRIBER_FEATURE_COUNT = NAMESPACED_ELEMENT_FEATURE_COUNT + 1; + int SUBSCRIBER_FEATURE_COUNT = INTERFACE_TYPE_FEATURE_COUNT + 1; /** * The number of operations of the 'Subscriber' class. @@ -942,7 +978,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SUBSCRIBER_OPERATION_COUNT = NAMESPACED_ELEMENT_OPERATION_COUNT + 0; + int SUBSCRIBER_OPERATION_COUNT = INTERFACE_TYPE_OPERATION_COUNT + 0; /** * The feature id for the 'Namespace' containment reference. @@ -951,7 +987,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SERVICE_CLIENT__NAMESPACE = NAMESPACED_ELEMENT__NAMESPACE; + int SERVICE_CLIENT__NAMESPACE = INTERFACE_TYPE__NAMESPACE; /** * The feature id for the 'Name' attribute. @@ -960,7 +996,16 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SERVICE_CLIENT__NAME = NAMESPACED_ELEMENT__NAME; + int SERVICE_CLIENT__NAME = INTERFACE_TYPE__NAME; + + /** + * The feature id for the 'Qos' containment reference. + * + * + * @generated + * @ordered + */ + int SERVICE_CLIENT__QOS = INTERFACE_TYPE__QOS; /** * The feature id for the 'Service' reference. @@ -969,7 +1014,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SERVICE_CLIENT__SERVICE = NAMESPACED_ELEMENT_FEATURE_COUNT + 0; + int SERVICE_CLIENT__SERVICE = INTERFACE_TYPE_FEATURE_COUNT + 0; /** * The number of structural features of the 'Service Client' class. @@ -978,7 +1023,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SERVICE_CLIENT_FEATURE_COUNT = NAMESPACED_ELEMENT_FEATURE_COUNT + 1; + int SERVICE_CLIENT_FEATURE_COUNT = INTERFACE_TYPE_FEATURE_COUNT + 1; /** * The number of operations of the 'Service Client' class. @@ -987,7 +1032,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int SERVICE_CLIENT_OPERATION_COUNT = NAMESPACED_ELEMENT_OPERATION_COUNT + 0; + int SERVICE_CLIENT_OPERATION_COUNT = INTERFACE_TYPE_OPERATION_COUNT + 0; /** * The meta object id for the '{@link ros.impl.PackageSetImpl Package Set}' class. @@ -1105,7 +1150,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int ACTION_SERVER__NAMESPACE = NAMESPACED_ELEMENT__NAMESPACE; + int ACTION_SERVER__NAMESPACE = INTERFACE_TYPE__NAMESPACE; /** * The feature id for the 'Name' attribute. @@ -1114,7 +1159,16 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int ACTION_SERVER__NAME = NAMESPACED_ELEMENT__NAME; + int ACTION_SERVER__NAME = INTERFACE_TYPE__NAME; + + /** + * The feature id for the 'Qos' containment reference. + * + * + * @generated + * @ordered + */ + int ACTION_SERVER__QOS = INTERFACE_TYPE__QOS; /** * The feature id for the 'Action' reference. @@ -1123,7 +1177,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int ACTION_SERVER__ACTION = NAMESPACED_ELEMENT_FEATURE_COUNT + 0; + int ACTION_SERVER__ACTION = INTERFACE_TYPE_FEATURE_COUNT + 0; /** * The number of structural features of the 'Action Server' class. @@ -1132,7 +1186,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int ACTION_SERVER_FEATURE_COUNT = NAMESPACED_ELEMENT_FEATURE_COUNT + 1; + int ACTION_SERVER_FEATURE_COUNT = INTERFACE_TYPE_FEATURE_COUNT + 1; /** * The number of operations of the 'Action Server' class. @@ -1141,7 +1195,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int ACTION_SERVER_OPERATION_COUNT = NAMESPACED_ELEMENT_OPERATION_COUNT + 0; + int ACTION_SERVER_OPERATION_COUNT = INTERFACE_TYPE_OPERATION_COUNT + 0; /** * The feature id for the 'Namespace' containment reference. @@ -1150,7 +1204,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int ACTION_CLIENT__NAMESPACE = NAMESPACED_ELEMENT__NAMESPACE; + int ACTION_CLIENT__NAMESPACE = INTERFACE_TYPE__NAMESPACE; /** * The feature id for the 'Name' attribute. @@ -1159,7 +1213,16 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int ACTION_CLIENT__NAME = NAMESPACED_ELEMENT__NAME; + int ACTION_CLIENT__NAME = INTERFACE_TYPE__NAME; + + /** + * The feature id for the 'Qos' containment reference. + * + * + * @generated + * @ordered + */ + int ACTION_CLIENT__QOS = INTERFACE_TYPE__QOS; /** * The feature id for the 'Action' reference. @@ -1168,7 +1231,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int ACTION_CLIENT__ACTION = NAMESPACED_ELEMENT_FEATURE_COUNT + 0; + int ACTION_CLIENT__ACTION = INTERFACE_TYPE_FEATURE_COUNT + 0; /** * The number of structural features of the 'Action Client' class. @@ -1177,7 +1240,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int ACTION_CLIENT_FEATURE_COUNT = NAMESPACED_ELEMENT_FEATURE_COUNT + 1; + int ACTION_CLIENT_FEATURE_COUNT = INTERFACE_TYPE_FEATURE_COUNT + 1; /** * The number of operations of the 'Action Client' class. @@ -1186,7 +1249,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int ACTION_CLIENT_OPERATION_COUNT = NAMESPACED_ELEMENT_OPERATION_COUNT + 0; + int ACTION_CLIENT_OPERATION_COUNT = INTERFACE_TYPE_OPERATION_COUNT + 0; /** * The feature id for the 'Message Part' containment reference list. @@ -1562,7 +1625,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int PARAMETER__NAMESPACE = NAMESPACED_ELEMENT__NAMESPACE; + int PARAMETER__NAMESPACE = INTERFACE_TYPE__NAMESPACE; /** * The feature id for the 'Name' attribute. @@ -1571,7 +1634,16 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int PARAMETER__NAME = NAMESPACED_ELEMENT__NAME; + int PARAMETER__NAME = INTERFACE_TYPE__NAME; + + /** + * The feature id for the 'Qos' containment reference. + * + * + * @generated + * @ordered + */ + int PARAMETER__QOS = INTERFACE_TYPE__QOS; /** * The feature id for the 'Type' containment reference. @@ -1580,7 +1652,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int PARAMETER__TYPE = NAMESPACED_ELEMENT_FEATURE_COUNT + 0; + int PARAMETER__TYPE = INTERFACE_TYPE_FEATURE_COUNT + 0; /** * The feature id for the 'Value' containment reference. @@ -1589,7 +1661,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int PARAMETER__VALUE = NAMESPACED_ELEMENT_FEATURE_COUNT + 1; + int PARAMETER__VALUE = INTERFACE_TYPE_FEATURE_COUNT + 1; /** * The number of structural features of the 'Parameter' class. @@ -1598,7 +1670,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int PARAMETER_FEATURE_COUNT = NAMESPACED_ELEMENT_FEATURE_COUNT + 2; + int PARAMETER_FEATURE_COUNT = INTERFACE_TYPE_FEATURE_COUNT + 2; /** * The number of operations of the 'Parameter' class. @@ -1607,7 +1679,7 @@ public interface RosPackage extends EPackage { * @generated * @ordered */ - int PARAMETER_OPERATION_COUNT = NAMESPACED_ELEMENT_OPERATION_COUNT + 0; + int PARAMETER_OPERATION_COUNT = INTERFACE_TYPE_OPERATION_COUNT + 0; /** * The meta object id for the '{@link ros.impl.ParameterDateTypeImpl Parameter Date Type}' class. @@ -2338,6 +2410,79 @@ public interface RosPackage extends EPackage { */ int AMENT_PACKAGE_OPERATION_COUNT = PACKAGE_OPERATION_COUNT + 0; + /** + * The meta object id for the '{@link ros.impl.QualityOfServiceImpl Quality Of Service}' class. + * + * + * @see ros.impl.QualityOfServiceImpl + * @see ros.impl.RosPackageImpl#getQualityOfService() + * @generated + */ + int QUALITY_OF_SERVICE = 49; + + /** + * The feature id for the 'Qo SProfile' attribute. + * + * + * @generated + * @ordered + */ + int QUALITY_OF_SERVICE__QO_SPROFILE = 0; + + /** + * The feature id for the 'History' attribute. + * + * + * @generated + * @ordered + */ + int QUALITY_OF_SERVICE__HISTORY = 1; + + /** + * The feature id for the 'Depth' attribute. + * + * + * @generated + * @ordered + */ + int QUALITY_OF_SERVICE__DEPTH = 2; + + /** + * The feature id for the 'Reliability' attribute. + * + * + * @generated + * @ordered + */ + int QUALITY_OF_SERVICE__RELIABILITY = 3; + + /** + * The feature id for the 'Durability' attribute. + * + * + * @generated + * @ordered + */ + int QUALITY_OF_SERVICE__DURABILITY = 4; + + /** + * The number of structural features of the 'Quality Of Service' class. + * + * + * @generated + * @ordered + */ + int QUALITY_OF_SERVICE_FEATURE_COUNT = 5; + + /** + * The number of operations of the 'Quality Of Service' class. + * + * + * @generated + * @ordered + */ + int QUALITY_OF_SERVICE_OPERATION_COUNT = 0; + /** * The meta object id for the 'Graph Name' data type. * @@ -2346,7 +2491,7 @@ public interface RosPackage extends EPackage { * @see ros.impl.RosPackageImpl#getGraphName() * @generated */ - int GRAPH_NAME = 49; + int GRAPH_NAME = 50; /** @@ -2965,36 +3110,47 @@ public interface RosPackage extends EPackage { EClass getPrivateNamespace(); /** - * Returns the meta object for class '{@link ros.NamespacedElement Namespaced Element}'. + * Returns the meta object for class '{@link ros.InterfaceType Interface Type}'. * * - * @return the meta object for class 'Namespaced Element'. - * @see ros.NamespacedElement + * @return the meta object for class 'Interface Type'. + * @see ros.InterfaceType * @generated */ - EClass getNamespacedElement(); + EClass getInterfaceType(); /** - * Returns the meta object for the containment reference '{@link ros.NamespacedElement#getNamespace Namespace}'. + * Returns the meta object for the containment reference '{@link ros.InterfaceType#getNamespace Namespace}'. * * * @return the meta object for the containment reference 'Namespace'. - * @see ros.NamespacedElement#getNamespace() - * @see #getNamespacedElement() + * @see ros.InterfaceType#getNamespace() + * @see #getInterfaceType() * @generated */ - EReference getNamespacedElement_Namespace(); + EReference getInterfaceType_Namespace(); /** - * Returns the meta object for the attribute '{@link ros.NamespacedElement#getName Name}'. + * Returns the meta object for the attribute '{@link ros.InterfaceType#getName Name}'. * * * @return the meta object for the attribute 'Name'. - * @see ros.NamespacedElement#getName() - * @see #getNamespacedElement() + * @see ros.InterfaceType#getName() + * @see #getInterfaceType() + * @generated + */ + EAttribute getInterfaceType_Name(); + + /** + * Returns the meta object for the containment reference '{@link ros.InterfaceType#getQos Qos}'. + * + * + * @return the meta object for the containment reference 'Qos'. + * @see ros.InterfaceType#getQos() + * @see #getInterfaceType() * @generated */ - EAttribute getNamespacedElement_Name(); + EReference getInterfaceType_Qos(); /** * Returns the meta object for class '{@link ros.ParameterType Parameter Type}'. @@ -3554,6 +3710,71 @@ public interface RosPackage extends EPackage { */ EClass getAmentPackage(); + /** + * Returns the meta object for class '{@link ros.QualityOfService Quality Of Service}'. + * + * + * @return the meta object for class 'Quality Of Service'. + * @see ros.QualityOfService + * @generated + */ + EClass getQualityOfService(); + + /** + * Returns the meta object for the attribute '{@link ros.QualityOfService#getQoSProfile Qo SProfile}'. + * + * + * @return the meta object for the attribute 'Qo SProfile'. + * @see ros.QualityOfService#getQoSProfile() + * @see #getQualityOfService() + * @generated + */ + EAttribute getQualityOfService_QoSProfile(); + + /** + * Returns the meta object for the attribute '{@link ros.QualityOfService#getHistory History}'. + * + * + * @return the meta object for the attribute 'History'. + * @see ros.QualityOfService#getHistory() + * @see #getQualityOfService() + * @generated + */ + EAttribute getQualityOfService_History(); + + /** + * Returns the meta object for the attribute '{@link ros.QualityOfService#getDepth Depth}'. + * + * + * @return the meta object for the attribute 'Depth'. + * @see ros.QualityOfService#getDepth() + * @see #getQualityOfService() + * @generated + */ + EAttribute getQualityOfService_Depth(); + + /** + * Returns the meta object for the attribute '{@link ros.QualityOfService#getReliability Reliability}'. + * + * + * @return the meta object for the attribute 'Reliability'. + * @see ros.QualityOfService#getReliability() + * @see #getQualityOfService() + * @generated + */ + EAttribute getQualityOfService_Reliability(); + + /** + * Returns the meta object for the attribute '{@link ros.QualityOfService#getDurability Durability}'. + * + * + * @return the meta object for the attribute 'Durability'. + * @see ros.QualityOfService#getDurability() + * @see #getQualityOfService() + * @generated + */ + EAttribute getQualityOfService_Durability(); + /** * Returns the meta object for data type '{@link java.lang.String Graph Name}'. * @@ -4099,14 +4320,14 @@ interface Literals { EClass PRIVATE_NAMESPACE = eINSTANCE.getPrivateNamespace(); /** - * The meta object literal for the '{@link ros.impl.NamespacedElementImpl Namespaced Element}' class. + * The meta object literal for the '{@link ros.impl.InterfaceTypeImpl Interface Type}' class. * * - * @see ros.impl.NamespacedElementImpl - * @see ros.impl.RosPackageImpl#getNamespacedElement() + * @see ros.impl.InterfaceTypeImpl + * @see ros.impl.RosPackageImpl#getInterfaceType() * @generated */ - EClass NAMESPACED_ELEMENT = eINSTANCE.getNamespacedElement(); + EClass INTERFACE_TYPE = eINSTANCE.getInterfaceType(); /** * The meta object literal for the 'Namespace' containment reference feature. @@ -4114,7 +4335,7 @@ interface Literals { * * @generated */ - EReference NAMESPACED_ELEMENT__NAMESPACE = eINSTANCE.getNamespacedElement_Namespace(); + EReference INTERFACE_TYPE__NAMESPACE = eINSTANCE.getInterfaceType_Namespace(); /** * The meta object literal for the 'Name' attribute feature. @@ -4122,7 +4343,15 @@ interface Literals { * * @generated */ - EAttribute NAMESPACED_ELEMENT__NAME = eINSTANCE.getNamespacedElement_Name(); + EAttribute INTERFACE_TYPE__NAME = eINSTANCE.getInterfaceType_Name(); + + /** + * The meta object literal for the 'Qos' containment reference feature. + * + * + * @generated + */ + EReference INTERFACE_TYPE__QOS = eINSTANCE.getInterfaceType_Qos(); /** * The meta object literal for the '{@link ros.impl.ParameterTypeImpl Parameter Type}' class. @@ -4598,6 +4827,56 @@ interface Literals { */ EClass AMENT_PACKAGE = eINSTANCE.getAmentPackage(); + /** + * The meta object literal for the '{@link ros.impl.QualityOfServiceImpl Quality Of Service}' class. + * + * + * @see ros.impl.QualityOfServiceImpl + * @see ros.impl.RosPackageImpl#getQualityOfService() + * @generated + */ + EClass QUALITY_OF_SERVICE = eINSTANCE.getQualityOfService(); + + /** + * The meta object literal for the 'Qo SProfile' attribute feature. + * + * + * @generated + */ + EAttribute QUALITY_OF_SERVICE__QO_SPROFILE = eINSTANCE.getQualityOfService_QoSProfile(); + + /** + * The meta object literal for the 'History' attribute feature. + * + * + * @generated + */ + EAttribute QUALITY_OF_SERVICE__HISTORY = eINSTANCE.getQualityOfService_History(); + + /** + * The meta object literal for the 'Depth' attribute feature. + * + * + * @generated + */ + EAttribute QUALITY_OF_SERVICE__DEPTH = eINSTANCE.getQualityOfService_Depth(); + + /** + * The meta object literal for the 'Reliability' attribute feature. + * + * + * @generated + */ + EAttribute QUALITY_OF_SERVICE__RELIABILITY = eINSTANCE.getQualityOfService_Reliability(); + + /** + * The meta object literal for the 'Durability' attribute feature. + * + * + * @generated + */ + EAttribute QUALITY_OF_SERVICE__DURABILITY = eINSTANCE.getQualityOfService_Durability(); + /** * The meta object literal for the 'Graph Name' data type. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/ServiceClient.java b/plugins/de.fraunhofer.ipa.ros/src/ros/ServiceClient.java index c516ca8ad..fdbe6d80e 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/ServiceClient.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/ServiceClient.java @@ -19,7 +19,7 @@ * @model * @generated */ -public interface ServiceClient extends NamespacedElement { +public interface ServiceClient extends InterfaceType { /** * Returns the value of the 'Service' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/ServiceServer.java b/plugins/de.fraunhofer.ipa.ros/src/ros/ServiceServer.java index f6b787861..0a6c63acf 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/ServiceServer.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/ServiceServer.java @@ -19,7 +19,7 @@ * @model * @generated */ -public interface ServiceServer extends NamespacedElement { +public interface ServiceServer extends InterfaceType { /** * Returns the value of the 'Service' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/Subscriber.java b/plugins/de.fraunhofer.ipa.ros/src/ros/Subscriber.java index 0936d06e9..c89382e72 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/Subscriber.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/Subscriber.java @@ -19,7 +19,7 @@ * @model * @generated */ -public interface Subscriber extends NamespacedElement { +public interface Subscriber extends InterfaceType { /** * Returns the value of the 'Message' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ActionClientImpl.java b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ActionClientImpl.java index 82de59421..54284e29e 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ActionClientImpl.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ActionClientImpl.java @@ -26,7 +26,7 @@ * * @generated */ -public class ActionClientImpl extends NamespacedElementImpl implements ActionClient { +public class ActionClientImpl extends InterfaceTypeImpl implements ActionClient { /** * The cached value of the '{@link #getAction() Action}' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ActionServerImpl.java b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ActionServerImpl.java index 9c031132e..4feecfbd3 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ActionServerImpl.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ActionServerImpl.java @@ -26,7 +26,7 @@ * * @generated */ -public class ActionServerImpl extends NamespacedElementImpl implements ActionServer { +public class ActionServerImpl extends InterfaceTypeImpl implements ActionServer { /** * The cached value of the '{@link #getAction() Action}' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/NamespacedElementImpl.java b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/InterfaceTypeImpl.java similarity index 60% rename from plugins/de.fraunhofer.ipa.ros/src/ros/impl/NamespacedElementImpl.java rename to plugins/de.fraunhofer.ipa.ros/src/ros/impl/InterfaceTypeImpl.java index 6220fa366..bb78cca17 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/NamespacedElementImpl.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/InterfaceTypeImpl.java @@ -11,25 +11,27 @@ import org.eclipse.emf.ecore.impl.ENotificationImpl; import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; +import ros.InterfaceType; import ros.Namespace; -import ros.NamespacedElement; +import ros.QualityOfService; import ros.RosPackage; /** * - * An implementation of the model object 'Namespaced Element'. + * An implementation of the model object 'Interface Type'. * *

* The following features are implemented: *

*
    - *
  • {@link ros.impl.NamespacedElementImpl#getNamespace Namespace}
    • - *
  • {@link ros.impl.NamespacedElementImpl#getName Name}
    • + *
  • {@link ros.impl.InterfaceTypeImpl#getNamespace Namespace}
    • + *
  • {@link ros.impl.InterfaceTypeImpl#getName Name}
    • + *
  • {@link ros.impl.InterfaceTypeImpl#getQos Qos}
    • *
* * @generated */ -public class NamespacedElementImpl extends MinimalEObjectImpl.Container implements NamespacedElement { +public class InterfaceTypeImpl extends MinimalEObjectImpl.Container implements InterfaceType { /** * The cached value of the '{@link #getNamespace() Namespace}' containment reference. * @@ -60,12 +62,22 @@ public class NamespacedElementImpl extends MinimalEObjectImpl.Container implemen */ protected String name = NAME_EDEFAULT; + /** + * The cached value of the '{@link #getQos() Qos}' containment reference. + * + * + * @see #getQos() + * @generated + * @ordered + */ + protected QualityOfService qos; + /** * * * @generated */ - protected NamespacedElementImpl() { + protected InterfaceTypeImpl() { super(); } @@ -76,7 +88,7 @@ protected NamespacedElementImpl() { */ @Override protected EClass eStaticClass() { - return RosPackage.Literals.NAMESPACED_ELEMENT; + return RosPackage.Literals.INTERFACE_TYPE; } /** @@ -98,7 +110,7 @@ public NotificationChain basicSetNamespace(Namespace newNamespace, NotificationC Namespace oldNamespace = namespace; namespace = newNamespace; if (eNotificationRequired()) { - ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, RosPackage.NAMESPACED_ELEMENT__NAMESPACE, oldNamespace, newNamespace); + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, RosPackage.INTERFACE_TYPE__NAMESPACE, oldNamespace, newNamespace); if (msgs == null) msgs = notification; else msgs.add(notification); } return msgs; @@ -114,14 +126,14 @@ public void setNamespace(Namespace newNamespace) { if (newNamespace != namespace) { NotificationChain msgs = null; if (namespace != null) - msgs = ((InternalEObject)namespace).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - RosPackage.NAMESPACED_ELEMENT__NAMESPACE, null, msgs); + msgs = ((InternalEObject)namespace).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - RosPackage.INTERFACE_TYPE__NAMESPACE, null, msgs); if (newNamespace != null) - msgs = ((InternalEObject)newNamespace).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - RosPackage.NAMESPACED_ELEMENT__NAMESPACE, null, msgs); + msgs = ((InternalEObject)newNamespace).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - RosPackage.INTERFACE_TYPE__NAMESPACE, null, msgs); msgs = basicSetNamespace(newNamespace, msgs); if (msgs != null) msgs.dispatch(); } else if (eNotificationRequired()) - eNotify(new ENotificationImpl(this, Notification.SET, RosPackage.NAMESPACED_ELEMENT__NAMESPACE, newNamespace, newNamespace)); + eNotify(new ENotificationImpl(this, Notification.SET, RosPackage.INTERFACE_TYPE__NAMESPACE, newNamespace, newNamespace)); } /** @@ -144,7 +156,52 @@ public void setName(String newName) { String oldName = name; name = newName; if (eNotificationRequired()) - eNotify(new ENotificationImpl(this, Notification.SET, RosPackage.NAMESPACED_ELEMENT__NAME, oldName, name)); + eNotify(new ENotificationImpl(this, Notification.SET, RosPackage.INTERFACE_TYPE__NAME, oldName, name)); + } + + /** + * + * + * @generated + */ + @Override + public QualityOfService getQos() { + return qos; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetQos(QualityOfService newQos, NotificationChain msgs) { + QualityOfService oldQos = qos; + qos = newQos; + if (eNotificationRequired()) { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, RosPackage.INTERFACE_TYPE__QOS, oldQos, newQos); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setQos(QualityOfService newQos) { + if (newQos != qos) { + NotificationChain msgs = null; + if (qos != null) + msgs = ((InternalEObject)qos).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - RosPackage.INTERFACE_TYPE__QOS, null, msgs); + if (newQos != null) + msgs = ((InternalEObject)newQos).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - RosPackage.INTERFACE_TYPE__QOS, null, msgs); + msgs = basicSetQos(newQos, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, RosPackage.INTERFACE_TYPE__QOS, newQos, newQos)); } /** @@ -155,8 +212,10 @@ public void setName(String newName) { @Override public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) { switch (featureID) { - case RosPackage.NAMESPACED_ELEMENT__NAMESPACE: + case RosPackage.INTERFACE_TYPE__NAMESPACE: return basicSetNamespace(null, msgs); + case RosPackage.INTERFACE_TYPE__QOS: + return basicSetQos(null, msgs); } return super.eInverseRemove(otherEnd, featureID, msgs); } @@ -169,10 +228,12 @@ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, @Override public Object eGet(int featureID, boolean resolve, boolean coreType) { switch (featureID) { - case RosPackage.NAMESPACED_ELEMENT__NAMESPACE: + case RosPackage.INTERFACE_TYPE__NAMESPACE: return getNamespace(); - case RosPackage.NAMESPACED_ELEMENT__NAME: + case RosPackage.INTERFACE_TYPE__NAME: return getName(); + case RosPackage.INTERFACE_TYPE__QOS: + return getQos(); } return super.eGet(featureID, resolve, coreType); } @@ -185,12 +246,15 @@ public Object eGet(int featureID, boolean resolve, boolean coreType) { @Override public void eSet(int featureID, Object newValue) { switch (featureID) { - case RosPackage.NAMESPACED_ELEMENT__NAMESPACE: + case RosPackage.INTERFACE_TYPE__NAMESPACE: setNamespace((Namespace)newValue); return; - case RosPackage.NAMESPACED_ELEMENT__NAME: + case RosPackage.INTERFACE_TYPE__NAME: setName((String)newValue); return; + case RosPackage.INTERFACE_TYPE__QOS: + setQos((QualityOfService)newValue); + return; } super.eSet(featureID, newValue); } @@ -203,12 +267,15 @@ public void eSet(int featureID, Object newValue) { @Override public void eUnset(int featureID) { switch (featureID) { - case RosPackage.NAMESPACED_ELEMENT__NAMESPACE: + case RosPackage.INTERFACE_TYPE__NAMESPACE: setNamespace((Namespace)null); return; - case RosPackage.NAMESPACED_ELEMENT__NAME: + case RosPackage.INTERFACE_TYPE__NAME: setName(NAME_EDEFAULT); return; + case RosPackage.INTERFACE_TYPE__QOS: + setQos((QualityOfService)null); + return; } super.eUnset(featureID); } @@ -221,10 +288,12 @@ public void eUnset(int featureID) { @Override public boolean eIsSet(int featureID) { switch (featureID) { - case RosPackage.NAMESPACED_ELEMENT__NAMESPACE: + case RosPackage.INTERFACE_TYPE__NAMESPACE: return namespace != null; - case RosPackage.NAMESPACED_ELEMENT__NAME: + case RosPackage.INTERFACE_TYPE__NAME: return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); + case RosPackage.INTERFACE_TYPE__QOS: + return qos != null; } return super.eIsSet(featureID); } @@ -245,4 +314,4 @@ public String toString() { return result.toString(); } -} //NamespacedElementImpl +} //InterfaceTypeImpl diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ParameterImpl.java b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ParameterImpl.java index 31d781d17..d5ec8f4c2 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ParameterImpl.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ParameterImpl.java @@ -29,7 +29,7 @@ * * @generated */ -public class ParameterImpl extends NamespacedElementImpl implements Parameter { +public class ParameterImpl extends InterfaceTypeImpl implements Parameter { /** * The cached value of the '{@link #getType() Type}' containment reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/PublisherImpl.java b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/PublisherImpl.java index 99a977bb1..c91528e9e 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/PublisherImpl.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/PublisherImpl.java @@ -26,7 +26,7 @@ * * @generated */ -public class PublisherImpl extends NamespacedElementImpl implements Publisher { +public class PublisherImpl extends InterfaceTypeImpl implements Publisher { /** * The cached value of the '{@link #getMessage() Message}' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/QualityOfServiceImpl.java b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/QualityOfServiceImpl.java new file mode 100644 index 000000000..e66a2b77c --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/QualityOfServiceImpl.java @@ -0,0 +1,389 @@ +/** + */ +package ros.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import ros.QualityOfService; +import ros.RosPackage; + +/** + * + * An implementation of the model object 'Quality Of Service'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link ros.impl.QualityOfServiceImpl#getQoSProfile Qo SProfile}
    • + *
  • {@link ros.impl.QualityOfServiceImpl#getHistory History}
    • + *
  • {@link ros.impl.QualityOfServiceImpl#getDepth Depth}
    • + *
  • {@link ros.impl.QualityOfServiceImpl#getReliability Reliability}
    • + *
  • {@link ros.impl.QualityOfServiceImpl#getDurability Durability}
    • + *
+ * + * @generated + */ +public class QualityOfServiceImpl extends MinimalEObjectImpl.Container implements QualityOfService { + /** + * The default value of the '{@link #getQoSProfile() Qo SProfile}' attribute. + * + * + * @see #getQoSProfile() + * @generated + * @ordered + */ + protected static final String QO_SPROFILE_EDEFAULT = "default_qos"; + + /** + * The cached value of the '{@link #getQoSProfile() Qo SProfile}' attribute. + * + * + * @see #getQoSProfile() + * @generated + * @ordered + */ + protected String qoSProfile = QO_SPROFILE_EDEFAULT; + + /** + * The default value of the '{@link #getHistory() History}' attribute. + * + * + * @see #getHistory() + * @generated + * @ordered + */ + protected static final String HISTORY_EDEFAULT = "keep_all"; + + /** + * The cached value of the '{@link #getHistory() History}' attribute. + * + * + * @see #getHistory() + * @generated + * @ordered + */ + protected String history = HISTORY_EDEFAULT; + + /** + * The default value of the '{@link #getDepth() Depth}' attribute. + * + * + * @see #getDepth() + * @generated + * @ordered + */ + protected static final int DEPTH_EDEFAULT = 0; + + /** + * The cached value of the '{@link #getDepth() Depth}' attribute. + * + * + * @see #getDepth() + * @generated + * @ordered + */ + protected int depth = DEPTH_EDEFAULT; + + /** + * The default value of the '{@link #getReliability() Reliability}' attribute. + * + * + * @see #getReliability() + * @generated + * @ordered + */ + protected static final String RELIABILITY_EDEFAULT = "reliable"; + + /** + * The cached value of the '{@link #getReliability() Reliability}' attribute. + * + * + * @see #getReliability() + * @generated + * @ordered + */ + protected String reliability = RELIABILITY_EDEFAULT; + + /** + * The default value of the '{@link #getDurability() Durability}' attribute. + * + * + * @see #getDurability() + * @generated + * @ordered + */ + protected static final String DURABILITY_EDEFAULT = "transient_local"; + + /** + * The cached value of the '{@link #getDurability() Durability}' attribute. + * + * + * @see #getDurability() + * @generated + * @ordered + */ + protected String durability = DURABILITY_EDEFAULT; + + /** + * + * + * @generated + */ + protected QualityOfServiceImpl() { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() { + return RosPackage.Literals.QUALITY_OF_SERVICE; + } + + /** + * + * + * @generated + */ + @Override + public String getQoSProfile() { + return qoSProfile; + } + + /** + * + * + * @generated + */ + @Override + public void setQoSProfile(String newQoSProfile) { + String oldQoSProfile = qoSProfile; + qoSProfile = newQoSProfile; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, RosPackage.QUALITY_OF_SERVICE__QO_SPROFILE, oldQoSProfile, qoSProfile)); + } + + /** + * + * + * @generated + */ + @Override + public String getHistory() { + return history; + } + + /** + * + * + * @generated + */ + @Override + public void setHistory(String newHistory) { + String oldHistory = history; + history = newHistory; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, RosPackage.QUALITY_OF_SERVICE__HISTORY, oldHistory, history)); + } + + /** + * + * + * @generated + */ + @Override + public int getDepth() { + return depth; + } + + /** + * + * + * @generated + */ + @Override + public void setDepth(int newDepth) { + int oldDepth = depth; + depth = newDepth; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, RosPackage.QUALITY_OF_SERVICE__DEPTH, oldDepth, depth)); + } + + /** + * + * + * @generated + */ + @Override + public String getReliability() { + return reliability; + } + + /** + * + * + * @generated + */ + @Override + public void setReliability(String newReliability) { + String oldReliability = reliability; + reliability = newReliability; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, RosPackage.QUALITY_OF_SERVICE__RELIABILITY, oldReliability, reliability)); + } + + /** + * + * + * @generated + */ + @Override + public String getDurability() { + return durability; + } + + /** + * + * + * @generated + */ + @Override + public void setDurability(String newDurability) { + String oldDurability = durability; + durability = newDurability; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, RosPackage.QUALITY_OF_SERVICE__DURABILITY, oldDurability, durability)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) { + switch (featureID) { + case RosPackage.QUALITY_OF_SERVICE__QO_SPROFILE: + return getQoSProfile(); + case RosPackage.QUALITY_OF_SERVICE__HISTORY: + return getHistory(); + case RosPackage.QUALITY_OF_SERVICE__DEPTH: + return getDepth(); + case RosPackage.QUALITY_OF_SERVICE__RELIABILITY: + return getReliability(); + case RosPackage.QUALITY_OF_SERVICE__DURABILITY: + return getDurability(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) { + switch (featureID) { + case RosPackage.QUALITY_OF_SERVICE__QO_SPROFILE: + setQoSProfile((String)newValue); + return; + case RosPackage.QUALITY_OF_SERVICE__HISTORY: + setHistory((String)newValue); + return; + case RosPackage.QUALITY_OF_SERVICE__DEPTH: + setDepth((Integer)newValue); + return; + case RosPackage.QUALITY_OF_SERVICE__RELIABILITY: + setReliability((String)newValue); + return; + case RosPackage.QUALITY_OF_SERVICE__DURABILITY: + setDurability((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) { + switch (featureID) { + case RosPackage.QUALITY_OF_SERVICE__QO_SPROFILE: + setQoSProfile(QO_SPROFILE_EDEFAULT); + return; + case RosPackage.QUALITY_OF_SERVICE__HISTORY: + setHistory(HISTORY_EDEFAULT); + return; + case RosPackage.QUALITY_OF_SERVICE__DEPTH: + setDepth(DEPTH_EDEFAULT); + return; + case RosPackage.QUALITY_OF_SERVICE__RELIABILITY: + setReliability(RELIABILITY_EDEFAULT); + return; + case RosPackage.QUALITY_OF_SERVICE__DURABILITY: + setDurability(DURABILITY_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) { + switch (featureID) { + case RosPackage.QUALITY_OF_SERVICE__QO_SPROFILE: + return QO_SPROFILE_EDEFAULT == null ? qoSProfile != null : !QO_SPROFILE_EDEFAULT.equals(qoSProfile); + case RosPackage.QUALITY_OF_SERVICE__HISTORY: + return HISTORY_EDEFAULT == null ? history != null : !HISTORY_EDEFAULT.equals(history); + case RosPackage.QUALITY_OF_SERVICE__DEPTH: + return depth != DEPTH_EDEFAULT; + case RosPackage.QUALITY_OF_SERVICE__RELIABILITY: + return RELIABILITY_EDEFAULT == null ? reliability != null : !RELIABILITY_EDEFAULT.equals(reliability); + case RosPackage.QUALITY_OF_SERVICE__DURABILITY: + return DURABILITY_EDEFAULT == null ? durability != null : !DURABILITY_EDEFAULT.equals(durability); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (QoSProfile: "); + result.append(qoSProfile); + result.append(", History: "); + result.append(history); + result.append(", Depth: "); + result.append(depth); + result.append(", Reliability: "); + result.append(reliability); + result.append(", Durability: "); + result.append(durability); + result.append(')'); + return result.toString(); + } + +} //QualityOfServiceImpl diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/RosFactoryImpl.java b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/RosFactoryImpl.java index 56977a400..c1a7eb597 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/RosFactoryImpl.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/RosFactoryImpl.java @@ -19,8 +19,8 @@ import ros.CatkinPackage; import ros.ExternalDependency; import ros.GlobalNamespace; +import ros.InterfaceType; import ros.MessageDefinition; -import ros.NamespacedElement; import ros.Node; import ros.PackageDependency; import ros.PackageSet; @@ -48,6 +48,7 @@ import ros.ParameterStructTypeMember; import ros.PrivateNamespace; import ros.Publisher; +import ros.QualityOfService; import ros.RelativeNamespace; import ros.RosFactory; import ros.RosPackage; @@ -121,7 +122,7 @@ public EObject create(EClass eClass) { case RosPackage.GLOBAL_NAMESPACE: return createGlobalNamespace(); case RosPackage.RELATIVE_NAMESPACE: return createRelativeNamespace(); case RosPackage.PRIVATE_NAMESPACE: return createPrivateNamespace(); - case RosPackage.NAMESPACED_ELEMENT: return createNamespacedElement(); + case RosPackage.INTERFACE_TYPE: return createInterfaceType(); case RosPackage.PARAMETER_LIST_TYPE: return createParameterListType(); case RosPackage.PARAMETER_STRUCT_TYPE: return createParameterStructType(); case RosPackage.PARAMETER_INTEGER_TYPE: return createParameterIntegerType(); @@ -145,6 +146,7 @@ public EObject create(EClass eClass) { case RosPackage.PARAMETER_STRUCT_MEMBER: return createParameterStructMember(); case RosPackage.PARAMETER_DATE: return createParameterDate(); case RosPackage.AMENT_PACKAGE: return createAmentPackage(); + case RosPackage.QUALITY_OF_SERVICE: return createQualityOfService(); default: throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); } @@ -406,9 +408,9 @@ public PrivateNamespace createPrivateNamespace() { * @generated */ @Override - public NamespacedElement createNamespacedElement() { - NamespacedElementImpl namespacedElement = new NamespacedElementImpl(); - return namespacedElement; + public InterfaceType createInterfaceType() { + InterfaceTypeImpl interfaceType = new InterfaceTypeImpl(); + return interfaceType; } /** @@ -664,6 +666,17 @@ public AmentPackage createAmentPackage() { return amentPackage; } + /** + * + * + * @generated + */ + @Override + public QualityOfService createQualityOfService() { + QualityOfServiceImpl qualityOfService = new QualityOfServiceImpl(); + return qualityOfService; + } + /** * * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/RosPackageImpl.java b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/RosPackageImpl.java index 15186a9c6..5748281d1 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/RosPackageImpl.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/RosPackageImpl.java @@ -23,9 +23,9 @@ import ros.Dependency; import ros.ExternalDependency; import ros.GlobalNamespace; +import ros.InterfaceType; import ros.MessageDefinition; import ros.Namespace; -import ros.NamespacedElement; import ros.Node; import ros.PackageDependency; import ros.PackageSet; @@ -55,6 +55,7 @@ import ros.ParameterValue; import ros.PrivateNamespace; import ros.Publisher; +import ros.QualityOfService; import ros.RelativeNamespace; import ros.RosFactory; import ros.RosPackage; @@ -238,7 +239,7 @@ public class RosPackageImpl extends EPackageImpl implements RosPackage { * * @generated */ - private EClass namespacedElementEClass = null; + private EClass interfaceTypeEClass = null; /** * @@ -415,6 +416,13 @@ public class RosPackageImpl extends EPackageImpl implements RosPackage { */ private EClass amentPackageEClass = null; + /** + * + * + * @generated + */ + private EClass qualityOfServiceEClass = null; + /** * * @@ -1078,8 +1086,18 @@ public EClass getPrivateNamespace() { * @generated */ @Override - public EClass getNamespacedElement() { - return namespacedElementEClass; + public EClass getInterfaceType() { + return interfaceTypeEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getInterfaceType_Namespace() { + return (EReference)interfaceTypeEClass.getEStructuralFeatures().get(0); } /** @@ -1088,8 +1106,8 @@ public EClass getNamespacedElement() { * @generated */ @Override - public EReference getNamespacedElement_Namespace() { - return (EReference)namespacedElementEClass.getEStructuralFeatures().get(0); + public EAttribute getInterfaceType_Name() { + return (EAttribute)interfaceTypeEClass.getEStructuralFeatures().get(1); } /** @@ -1098,8 +1116,8 @@ public EReference getNamespacedElement_Namespace() { * @generated */ @Override - public EAttribute getNamespacedElement_Name() { - return (EAttribute)namespacedElementEClass.getEStructuralFeatures().get(1); + public EReference getInterfaceType_Qos() { + return (EReference)interfaceTypeEClass.getEStructuralFeatures().get(2); } /** @@ -1632,6 +1650,66 @@ public EClass getAmentPackage() { return amentPackageEClass; } + /** + * + * + * @generated + */ + @Override + public EClass getQualityOfService() { + return qualityOfServiceEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getQualityOfService_QoSProfile() { + return (EAttribute)qualityOfServiceEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getQualityOfService_History() { + return (EAttribute)qualityOfServiceEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getQualityOfService_Depth() { + return (EAttribute)qualityOfServiceEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getQualityOfService_Reliability() { + return (EAttribute)qualityOfServiceEClass.getEStructuralFeatures().get(3); + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getQualityOfService_Durability() { + return (EAttribute)qualityOfServiceEClass.getEStructuralFeatures().get(4); + } + /** * * @@ -1752,9 +1830,10 @@ public void createPackageContents() { privateNamespaceEClass = createEClass(PRIVATE_NAMESPACE); - namespacedElementEClass = createEClass(NAMESPACED_ELEMENT); - createEReference(namespacedElementEClass, NAMESPACED_ELEMENT__NAMESPACE); - createEAttribute(namespacedElementEClass, NAMESPACED_ELEMENT__NAME); + interfaceTypeEClass = createEClass(INTERFACE_TYPE); + createEReference(interfaceTypeEClass, INTERFACE_TYPE__NAMESPACE); + createEAttribute(interfaceTypeEClass, INTERFACE_TYPE__NAME); + createEReference(interfaceTypeEClass, INTERFACE_TYPE__QOS); parameterTypeEClass = createEClass(PARAMETER_TYPE); @@ -1834,6 +1913,13 @@ public void createPackageContents() { amentPackageEClass = createEClass(AMENT_PACKAGE); + qualityOfServiceEClass = createEClass(QUALITY_OF_SERVICE); + createEAttribute(qualityOfServiceEClass, QUALITY_OF_SERVICE__QO_SPROFILE); + createEAttribute(qualityOfServiceEClass, QUALITY_OF_SERVICE__HISTORY); + createEAttribute(qualityOfServiceEClass, QUALITY_OF_SERVICE__DEPTH); + createEAttribute(qualityOfServiceEClass, QUALITY_OF_SERVICE__RELIABILITY); + createEAttribute(qualityOfServiceEClass, QUALITY_OF_SERVICE__DURABILITY); + // Create data types graphNameEDataType = createEDataType(GRAPH_NAME); } @@ -1871,17 +1957,17 @@ public void initializePackageContents() { // Add supertypes to classes serviceSpecEClass.getESuperTypes().add(this.getSpecBase()); - serviceServerEClass.getESuperTypes().add(this.getNamespacedElement()); + serviceServerEClass.getESuperTypes().add(this.getInterfaceType()); topicSpecEClass.getESuperTypes().add(this.getSpecBase()); packageDependencyEClass.getESuperTypes().add(this.getDependency()); externalDependencyEClass.getESuperTypes().add(this.getDependency()); catkinPackageEClass.getESuperTypes().add(this.getPackage()); - publisherEClass.getESuperTypes().add(this.getNamespacedElement()); - subscriberEClass.getESuperTypes().add(this.getNamespacedElement()); - serviceClientEClass.getESuperTypes().add(this.getNamespacedElement()); + publisherEClass.getESuperTypes().add(this.getInterfaceType()); + subscriberEClass.getESuperTypes().add(this.getInterfaceType()); + serviceClientEClass.getESuperTypes().add(this.getInterfaceType()); actionSpecEClass.getESuperTypes().add(this.getSpecBase()); - actionServerEClass.getESuperTypes().add(this.getNamespacedElement()); - actionClientEClass.getESuperTypes().add(this.getNamespacedElement()); + actionServerEClass.getESuperTypes().add(this.getInterfaceType()); + actionClientEClass.getESuperTypes().add(this.getInterfaceType()); globalNamespaceEClass.getESuperTypes().add(this.getNamespace()); relativeNamespaceEClass.getESuperTypes().add(this.getNamespace()); privateNamespaceEClass.getESuperTypes().add(this.getRelativeNamespace()); @@ -1890,7 +1976,7 @@ public void initializePackageContents() { parameterIntegerTypeEClass.getESuperTypes().add(this.getParameterType()); parameterStringTypeEClass.getESuperTypes().add(this.getParameterType()); parameterDoubleTypeEClass.getESuperTypes().add(this.getParameterType()); - parameterEClass.getESuperTypes().add(this.getNamespacedElement()); + parameterEClass.getESuperTypes().add(this.getInterfaceType()); parameterDateTypeEClass.getESuperTypes().add(this.getParameterType()); parameterBooleanTypeEClass.getESuperTypes().add(this.getParameterType()); parameterBase64TypeEClass.getESuperTypes().add(this.getParameterType()); @@ -1989,9 +2075,10 @@ public void initializePackageContents() { initEClass(privateNamespaceEClass, PrivateNamespace.class, "PrivateNamespace", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); - initEClass(namespacedElementEClass, NamespacedElement.class, "NamespacedElement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); - initEReference(getNamespacedElement_Namespace(), this.getNamespace(), null, "namespace", null, 0, 1, NamespacedElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); - initEAttribute(getNamespacedElement_Name(), this.getGraphName(), "name", null, 1, 1, NamespacedElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEClass(interfaceTypeEClass, InterfaceType.class, "InterfaceType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getInterfaceType_Namespace(), this.getNamespace(), null, "namespace", null, 0, 1, InterfaceType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEAttribute(getInterfaceType_Name(), this.getGraphName(), "name", null, 1, 1, InterfaceType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getInterfaceType_Qos(), this.getQualityOfService(), null, "qos", null, 0, 1, InterfaceType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); initEClass(parameterTypeEClass, ParameterType.class, "ParameterType", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); @@ -2071,6 +2158,13 @@ public void initializePackageContents() { initEClass(amentPackageEClass, AmentPackage.class, "AmentPackage", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEClass(qualityOfServiceEClass, QualityOfService.class, "QualityOfService", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getQualityOfService_QoSProfile(), ecorePackage.getEString(), "QoSProfile", "default_qos", 0, 1, QualityOfService.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEAttribute(getQualityOfService_History(), ecorePackage.getEString(), "History", "keep_all", 0, 1, QualityOfService.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEAttribute(getQualityOfService_Depth(), theXMLTypePackage.getInt(), "Depth", null, 0, 1, QualityOfService.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEAttribute(getQualityOfService_Reliability(), ecorePackage.getEString(), "Reliability", "reliable", 0, 1, QualityOfService.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEAttribute(getQualityOfService_Durability(), ecorePackage.getEString(), "Durability", "transient_local", 0, 1, QualityOfService.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + // Initialize data types initEDataType(graphNameEDataType, String.class, "GraphName", IS_SERIALIZABLE, !IS_GENERATED_INSTANCE_CLASS); diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ServiceClientImpl.java b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ServiceClientImpl.java index 81ab5c30d..6f7c3cc81 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ServiceClientImpl.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ServiceClientImpl.java @@ -26,7 +26,7 @@ * * @generated */ -public class ServiceClientImpl extends NamespacedElementImpl implements ServiceClient { +public class ServiceClientImpl extends InterfaceTypeImpl implements ServiceClient { /** * The cached value of the '{@link #getService() Service}' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ServiceServerImpl.java b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ServiceServerImpl.java index 167f0fab8..eef50843d 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ServiceServerImpl.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/ServiceServerImpl.java @@ -26,7 +26,7 @@ * * @generated */ -public class ServiceServerImpl extends NamespacedElementImpl implements ServiceServer { +public class ServiceServerImpl extends InterfaceTypeImpl implements ServiceServer { /** * The cached value of the '{@link #getService() Service}' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/SubscriberImpl.java b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/SubscriberImpl.java index 92ddac04d..86e445244 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/impl/SubscriberImpl.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/impl/SubscriberImpl.java @@ -26,7 +26,7 @@ * * @generated */ -public class SubscriberImpl extends NamespacedElementImpl implements Subscriber { +public class SubscriberImpl extends InterfaceTypeImpl implements Subscriber { /** * The cached value of the '{@link #getMessage() Message}' reference. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/util/RosAdapterFactory.java b/plugins/de.fraunhofer.ipa.ros/src/ros/util/RosAdapterFactory.java index ea43dcb00..7cf9e6718 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/util/RosAdapterFactory.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/util/RosAdapterFactory.java @@ -17,9 +17,9 @@ import ros.Dependency; import ros.ExternalDependency; import ros.GlobalNamespace; +import ros.InterfaceType; import ros.MessageDefinition; import ros.Namespace; -import ros.NamespacedElement; import ros.Node; import ros.PackageDependency; import ros.PackageSet; @@ -49,6 +49,7 @@ import ros.ParameterValue; import ros.PrivateNamespace; import ros.Publisher; +import ros.QualityOfService; import ros.RelativeNamespace; import ros.RosPackage; import ros.ServiceClient; @@ -207,8 +208,8 @@ public Adapter casePrivateNamespace(PrivateNamespace object) { return createPrivateNamespaceAdapter(); } @Override - public Adapter caseNamespacedElement(NamespacedElement object) { - return createNamespacedElementAdapter(); + public Adapter caseInterfaceType(InterfaceType object) { + return createInterfaceTypeAdapter(); } @Override public Adapter caseParameterType(ParameterType object) { @@ -311,6 +312,10 @@ public Adapter caseAmentPackage(AmentPackage object) { return createAmentPackageAdapter(); } @Override + public Adapter caseQualityOfService(QualityOfService object) { + return createQualityOfServiceAdapter(); + } + @Override public Adapter defaultCase(EObject object) { return createEObjectAdapter(); } @@ -653,16 +658,16 @@ public Adapter createPrivateNamespaceAdapter() { } /** - * Creates a new adapter for an object of class '{@link ros.NamespacedElement Namespaced Element}'. + * Creates a new adapter for an object of class '{@link ros.InterfaceType Interface Type}'. * * This default implementation returns null so that we can easily ignore cases; * it's useful to ignore a case when inheritance will catch all the cases anyway. * * @return the new adapter. - * @see ros.NamespacedElement + * @see ros.InterfaceType * @generated */ - public Adapter createNamespacedElementAdapter() { + public Adapter createInterfaceTypeAdapter() { return null; } @@ -1016,6 +1021,20 @@ public Adapter createAmentPackageAdapter() { return null; } + /** + * Creates a new adapter for an object of class '{@link ros.QualityOfService Quality Of Service}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see ros.QualityOfService + * @generated + */ + public Adapter createQualityOfServiceAdapter() { + return null; + } + /** * Creates a new adapter for the default case. * diff --git a/plugins/de.fraunhofer.ipa.ros/src/ros/util/RosSwitch.java b/plugins/de.fraunhofer.ipa.ros/src/ros/util/RosSwitch.java index dfb2d591b..51adfa96e 100644 --- a/plugins/de.fraunhofer.ipa.ros/src/ros/util/RosSwitch.java +++ b/plugins/de.fraunhofer.ipa.ros/src/ros/util/RosSwitch.java @@ -15,9 +15,9 @@ import ros.Dependency; import ros.ExternalDependency; import ros.GlobalNamespace; +import ros.InterfaceType; import ros.MessageDefinition; import ros.Namespace; -import ros.NamespacedElement; import ros.Node; import ros.PackageDependency; import ros.PackageSet; @@ -47,6 +47,7 @@ import ros.ParameterValue; import ros.PrivateNamespace; import ros.Publisher; +import ros.QualityOfService; import ros.RelativeNamespace; import ros.RosPackage; import ros.ServiceClient; @@ -141,7 +142,7 @@ protected T doSwitch(int classifierID, EObject theEObject) { case RosPackage.SERVICE_SERVER: { ServiceServer serviceServer = (ServiceServer)theEObject; T result = caseServiceServer(serviceServer); - if (result == null) result = caseNamespacedElement(serviceServer); + if (result == null) result = caseInterfaceType(serviceServer); if (result == null) result = defaultCase(theEObject); return result; } @@ -176,7 +177,7 @@ protected T doSwitch(int classifierID, EObject theEObject) { case RosPackage.PUBLISHER: { Publisher publisher = (Publisher)theEObject; T result = casePublisher(publisher); - if (result == null) result = caseNamespacedElement(publisher); + if (result == null) result = caseInterfaceType(publisher); if (result == null) result = defaultCase(theEObject); return result; } @@ -195,14 +196,14 @@ protected T doSwitch(int classifierID, EObject theEObject) { case RosPackage.SUBSCRIBER: { Subscriber subscriber = (Subscriber)theEObject; T result = caseSubscriber(subscriber); - if (result == null) result = caseNamespacedElement(subscriber); + if (result == null) result = caseInterfaceType(subscriber); if (result == null) result = defaultCase(theEObject); return result; } case RosPackage.SERVICE_CLIENT: { ServiceClient serviceClient = (ServiceClient)theEObject; T result = caseServiceClient(serviceClient); - if (result == null) result = caseNamespacedElement(serviceClient); + if (result == null) result = caseInterfaceType(serviceClient); if (result == null) result = defaultCase(theEObject); return result; } @@ -222,14 +223,14 @@ protected T doSwitch(int classifierID, EObject theEObject) { case RosPackage.ACTION_SERVER: { ActionServer actionServer = (ActionServer)theEObject; T result = caseActionServer(actionServer); - if (result == null) result = caseNamespacedElement(actionServer); + if (result == null) result = caseInterfaceType(actionServer); if (result == null) result = defaultCase(theEObject); return result; } case RosPackage.ACTION_CLIENT: { ActionClient actionClient = (ActionClient)theEObject; T result = caseActionClient(actionClient); - if (result == null) result = caseNamespacedElement(actionClient); + if (result == null) result = caseInterfaceType(actionClient); if (result == null) result = defaultCase(theEObject); return result; } @@ -267,9 +268,9 @@ protected T doSwitch(int classifierID, EObject theEObject) { if (result == null) result = defaultCase(theEObject); return result; } - case RosPackage.NAMESPACED_ELEMENT: { - NamespacedElement namespacedElement = (NamespacedElement)theEObject; - T result = caseNamespacedElement(namespacedElement); + case RosPackage.INTERFACE_TYPE: { + InterfaceType interfaceType = (InterfaceType)theEObject; + T result = caseInterfaceType(interfaceType); if (result == null) result = defaultCase(theEObject); return result; } @@ -317,7 +318,7 @@ protected T doSwitch(int classifierID, EObject theEObject) { case RosPackage.PARAMETER: { Parameter parameter = (Parameter)theEObject; T result = caseParameter(parameter); - if (result == null) result = caseNamespacedElement(parameter); + if (result == null) result = caseInterfaceType(parameter); if (result == null) result = defaultCase(theEObject); return result; } @@ -444,6 +445,12 @@ protected T doSwitch(int classifierID, EObject theEObject) { if (result == null) result = defaultCase(theEObject); return result; } + case RosPackage.QUALITY_OF_SERVICE: { + QualityOfService qualityOfService = (QualityOfService)theEObject; + T result = caseQualityOfService(qualityOfService); + if (result == null) result = defaultCase(theEObject); + return result; + } default: return defaultCase(theEObject); } } @@ -794,17 +801,17 @@ public T casePrivateNamespace(PrivateNamespace object) { } /** - * Returns the result of interpreting the object as an instance of 'Namespaced Element'. + * Returns the result of interpreting the object as an instance of 'Interface Type'. * * This implementation returns null; * returning a non-null result will terminate the switch. * * @param object the target of the switch. - * @return the result of interpreting the object as an instance of 'Namespaced Element'. + * @return the result of interpreting the object as an instance of 'Interface Type'. * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) * @generated */ - public T caseNamespacedElement(NamespacedElement object) { + public T caseInterfaceType(InterfaceType object) { return null; } @@ -1183,6 +1190,21 @@ public T caseAmentPackage(AmentPackage object) { return null; } + /** + * Returns the result of interpreting the object as an instance of 'Quality Of Service'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Quality Of Service'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseQualityOfService(QualityOfService object) { + return null; + } + /** * Returns the result of interpreting the object as an instance of 'EObject'. * 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..37d02d4c0 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/META-INF/MANIFEST.MF @@ -0,0 +1,19 @@ +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: Fraunhofer IPA +Bundle-Version: 2.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)", + de.fraunhofer.ipa.ros.xtext, + de.fraunhofer.ipa.ros.xtext.ui +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/pom.xml b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/pom.xml new file mode 100644 index 000000000..7af1f8c7a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/pom.xml @@ -0,0 +1,33 @@ + + 4.0.0 + + de.fraunhofer.ipa.ros + de.fraunhofer.ipa.ros.parent + 2.0.0-SNAPSHOT + ../de.fraunhofer.ipa.ros.parent/pom.xml + + de.fraunhofer.ipa.ros1.xtext.ide + eclipse-plugin + + + + + org.eclipse.xtend + xtend-maven-plugin + + + org.apache.maven.plugins + maven-clean-plugin + + + xtend-gen-clean + clean + + + + + + + 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..3db76d788 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/Ros1Parser.java @@ -0,0 +1,311 @@ +/* + * 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.getEStringAccess().getAlternatives(), "rule__EString__Alternatives"); + builder.put(grammarAccess.getRosNamesAccess().getAlternatives(), "rule__RosNames__Alternatives"); + builder.put(grammarAccess.getNodeAccess().getAlternatives_3(), "rule__Node__Alternatives_3"); + builder.put(grammarAccess.getSpecBaseAccess().getAlternatives(), "rule__SpecBase__Alternatives"); + builder.put(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0(), "rule__TopicSpec__NameAlternatives_2_0"); + builder.put(grammarAccess.getDependencyAccess().getAlternatives(), "rule__Dependency__Alternatives"); + builder.put(grammarAccess.getNamespaceAccess().getAlternatives(), "rule__Namespace__Alternatives"); + builder.put(grammarAccess.getRosParamNamesAccess().getAlternatives(), "rule__RosParamNames__Alternatives"); + builder.put(grammarAccess.getParameterTypeAccess().getAlternatives(), "rule__ParameterType__Alternatives"); + builder.put(grammarAccess.getParameterValueAccess().getAlternatives(), "rule__ParameterValue__Alternatives"); + builder.put(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0(), "rule__MessagePart__DataAlternatives_1_0"); + builder.put(grammarAccess.getAbstractTypeAccess().getAlternatives(), "rule__AbstractType__Alternatives"); + builder.put(grammarAccess.getKEYWORDAccess().getAlternatives(), "rule__KEYWORD__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.getPackageSetAccess().getGroup(), "rule__PackageSet__Group__0"); + builder.put(grammarAccess.getPackage_ImplAccess().getGroup(), "rule__Package_Impl__Group__0"); + builder.put(grammarAccess.getPackage_ImplAccess().getGroup_4(), "rule__Package_Impl__Group_4__0"); + builder.put(grammarAccess.getPackage_ImplAccess().getGroup_5(), "rule__Package_Impl__Group_5__0"); + builder.put(grammarAccess.getPackage_ImplAccess().getGroup_6(), "rule__Package_Impl__Group_6__0"); + builder.put(grammarAccess.getPackage_ImplAccess().getGroup_6_3(), "rule__Package_Impl__Group_6_3__0"); + builder.put(grammarAccess.getAmentPackageAccess().getGroup(), "rule__AmentPackage__Group__0"); + builder.put(grammarAccess.getAmentPackageAccess().getGroup_5(), "rule__AmentPackage__Group_5__0"); + builder.put(grammarAccess.getAmentPackageAccess().getGroup_6(), "rule__AmentPackage__Group_6__0"); + builder.put(grammarAccess.getAmentPackageAccess().getGroup_7(), "rule__AmentPackage__Group_7__0"); + builder.put(grammarAccess.getAmentPackageAccess().getGroup_7_3(), "rule__AmentPackage__Group_7_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_0(), "rule__Node__Group_3_0__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_1(), "rule__Node__Group_3_1__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_2(), "rule__Node__Group_3_2__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_3(), "rule__Node__Group_3_3__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_4(), "rule__Node__Group_3_4__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_5(), "rule__Node__Group_3_5__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_6(), "rule__Node__Group_3_6__0"); + builder.put(grammarAccess.getTopicSpecAccess().getGroup(), "rule__TopicSpec__Group__0"); + builder.put(grammarAccess.getTopicSpecAccess().getGroup_5(), "rule__TopicSpec__Group_5__0"); + builder.put(grammarAccess.getServiceSpecAccess().getGroup(), "rule__ServiceSpec__Group__0"); + builder.put(grammarAccess.getServiceSpecAccess().getGroup_5(), "rule__ServiceSpec__Group_5__0"); + builder.put(grammarAccess.getServiceSpecAccess().getGroup_7(), "rule__ServiceSpec__Group_7__0"); + builder.put(grammarAccess.getActionSpecAccess().getGroup(), "rule__ActionSpec__Group__0"); + builder.put(grammarAccess.getActionSpecAccess().getGroup_5(), "rule__ActionSpec__Group_5__0"); + builder.put(grammarAccess.getActionSpecAccess().getGroup_7(), "rule__ActionSpec__Group_7__0"); + builder.put(grammarAccess.getActionSpecAccess().getGroup_9(), "rule__ActionSpec__Group_9__0"); + builder.put(grammarAccess.getMessageDefinitionAccess().getGroup(), "rule__MessageDefinition__Group__0"); + builder.put(grammarAccess.getPublisherAccess().getGroup(), "rule__Publisher__Group__0"); + builder.put(grammarAccess.getPublisherAccess().getGroup_6(), "rule__Publisher__Group_6__0"); + builder.put(grammarAccess.getSubscriberAccess().getGroup(), "rule__Subscriber__Group__0"); + builder.put(grammarAccess.getSubscriberAccess().getGroup_6(), "rule__Subscriber__Group_6__0"); + builder.put(grammarAccess.getServiceServerAccess().getGroup(), "rule__ServiceServer__Group__0"); + builder.put(grammarAccess.getServiceServerAccess().getGroup_6(), "rule__ServiceServer__Group_6__0"); + builder.put(grammarAccess.getServiceClientAccess().getGroup(), "rule__ServiceClient__Group__0"); + builder.put(grammarAccess.getServiceClientAccess().getGroup_6(), "rule__ServiceClient__Group_6__0"); + builder.put(grammarAccess.getActionServerAccess().getGroup(), "rule__ActionServer__Group__0"); + builder.put(grammarAccess.getActionServerAccess().getGroup_6(), "rule__ActionServer__Group_6__0"); + builder.put(grammarAccess.getActionClientAccess().getGroup(), "rule__ActionClient__Group__0"); + builder.put(grammarAccess.getActionClientAccess().getGroup_6(), "rule__ActionClient__Group_6__0"); + builder.put(grammarAccess.getExternalDependencyAccess().getGroup(), "rule__ExternalDependency__Group__0"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getGroup(), "rule__GlobalNamespace__Group__0"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getGroup_2(), "rule__GlobalNamespace__Group_2__0"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2(), "rule__GlobalNamespace__Group_2_2__0"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getGroup(), "rule__RelativeNamespace_Impl__Group__0"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2(), "rule__RelativeNamespace_Impl__Group_2__0"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2(), "rule__RelativeNamespace_Impl__Group_2_2__0"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getGroup(), "rule__PrivateNamespace__Group__0"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getGroup_2(), "rule__PrivateNamespace__Group_2__0"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2(), "rule__PrivateNamespace__Group_2_2__0"); + builder.put(grammarAccess.getParameterAccess().getGroup(), "rule__Parameter__Group__0"); + builder.put(grammarAccess.getParameterAccess().getGroup_6(), "rule__Parameter__Group_6__0"); + builder.put(grammarAccess.getParameterListTypeAccess().getGroup(), "rule__ParameterListType__Group__0"); + builder.put(grammarAccess.getParameterListTypeAccess().getGroup_4(), "rule__ParameterListType__Group_4__0"); + builder.put(grammarAccess.getParameterStructTypeAccess().getGroup(), "rule__ParameterStructType__Group__0"); + builder.put(grammarAccess.getParameterStructTypeAccess().getGroup_4(), "rule__ParameterStructType__Group_4__0"); + builder.put(grammarAccess.getParameterIntegerTypeAccess().getGroup(), "rule__ParameterIntegerType__Group__0"); + builder.put(grammarAccess.getParameterIntegerTypeAccess().getGroup_2(), "rule__ParameterIntegerType__Group_2__0"); + builder.put(grammarAccess.getParameterStringTypeAccess().getGroup(), "rule__ParameterStringType__Group__0"); + builder.put(grammarAccess.getParameterStringTypeAccess().getGroup_2(), "rule__ParameterStringType__Group_2__0"); + builder.put(grammarAccess.getParameterDoubleTypeAccess().getGroup(), "rule__ParameterDoubleType__Group__0"); + builder.put(grammarAccess.getParameterDoubleTypeAccess().getGroup_2(), "rule__ParameterDoubleType__Group_2__0"); + builder.put(grammarAccess.getParameterDateTypeAccess().getGroup(), "rule__ParameterDateType__Group__0"); + builder.put(grammarAccess.getParameterDateTypeAccess().getGroup_2(), "rule__ParameterDateType__Group_2__0"); + builder.put(grammarAccess.getParameterBooleanTypeAccess().getGroup(), "rule__ParameterBooleanType__Group__0"); + builder.put(grammarAccess.getParameterBooleanTypeAccess().getGroup_2(), "rule__ParameterBooleanType__Group_2__0"); + builder.put(grammarAccess.getParameterBase64TypeAccess().getGroup(), "rule__ParameterBase64Type__Group__0"); + builder.put(grammarAccess.getParameterBase64TypeAccess().getGroup_2(), "rule__ParameterBase64Type__Group_2__0"); + builder.put(grammarAccess.getParameterAnyTypeAccess().getGroup(), "rule__ParameterAnyType__Group__0"); + builder.put(grammarAccess.getParameterAnyTypeAccess().getGroup_2(), "rule__ParameterAnyType__Group_2__0"); + builder.put(grammarAccess.getParameterArrayTypeAccess().getGroup(), "rule__ParameterArrayType__Group__0"); + builder.put(grammarAccess.getParameterArrayTypeAccess().getGroup_4(), "rule__ParameterArrayType__Group_4__0"); + builder.put(grammarAccess.getParameterListAccess().getGroup(), "rule__ParameterList__Group__0"); + builder.put(grammarAccess.getParameterListAccess().getGroup_3(), "rule__ParameterList__Group_3__0"); + builder.put(grammarAccess.getParameterAnyAccess().getGroup(), "rule__ParameterAny__Group__0"); + builder.put(grammarAccess.getParameterAnyAccess().getGroup_2(), "rule__ParameterAny__Group_2__0"); + builder.put(grammarAccess.getParameterStructAccess().getGroup(), "rule__ParameterStruct__Group__0"); + builder.put(grammarAccess.getParameterStructAccess().getGroup_1(), "rule__ParameterStruct__Group_1__0"); + builder.put(grammarAccess.getParameterStructAccess().getGroup_1_2(), "rule__ParameterStruct__Group_1_2__0"); + builder.put(grammarAccess.getParameterStructMemberAccess().getGroup(), "rule__ParameterStructMember__Group__0"); + builder.put(grammarAccess.getParameterStructTypeMemberAccess().getGroup(), "rule__ParameterStructTypeMember__Group__0"); + builder.put(grammarAccess.getMessagePartAccess().getGroup(), "rule__MessagePart__Group__0"); + builder.put(grammarAccess.getBoolAccess().getGroup(), "rule__Bool__Group__0"); + builder.put(grammarAccess.getInt8Access().getGroup(), "rule__Int8__Group__0"); + builder.put(grammarAccess.getUint8Access().getGroup(), "rule__Uint8__Group__0"); + builder.put(grammarAccess.getInt16Access().getGroup(), "rule__Int16__Group__0"); + builder.put(grammarAccess.getUint16Access().getGroup(), "rule__Uint16__Group__0"); + builder.put(grammarAccess.getInt32Access().getGroup(), "rule__Int32__Group__0"); + builder.put(grammarAccess.getUint32Access().getGroup(), "rule__Uint32__Group__0"); + builder.put(grammarAccess.getInt64Access().getGroup(), "rule__Int64__Group__0"); + builder.put(grammarAccess.getUint64Access().getGroup(), "rule__Uint64__Group__0"); + builder.put(grammarAccess.getFloat32Access().getGroup(), "rule__Float32__Group__0"); + builder.put(grammarAccess.getFloat64Access().getGroup(), "rule__Float64__Group__0"); + builder.put(grammarAccess.getString0Access().getGroup(), "rule__String0__Group__0"); + builder.put(grammarAccess.getByteAccess().getGroup(), "rule__Byte__Group__0"); + builder.put(grammarAccess.getTimeAccess().getGroup(), "rule__Time__Group__0"); + builder.put(grammarAccess.getDurationAccess().getGroup(), "rule__Duration__Group__0"); + builder.put(grammarAccess.getBoolArrayAccess().getGroup(), "rule__BoolArray__Group__0"); + builder.put(grammarAccess.getInt8ArrayAccess().getGroup(), "rule__Int8Array__Group__0"); + builder.put(grammarAccess.getUint8ArrayAccess().getGroup(), "rule__Uint8Array__Group__0"); + builder.put(grammarAccess.getInt16ArrayAccess().getGroup(), "rule__Int16Array__Group__0"); + builder.put(grammarAccess.getUint16ArrayAccess().getGroup(), "rule__Uint16Array__Group__0"); + builder.put(grammarAccess.getInt32ArrayAccess().getGroup(), "rule__Int32Array__Group__0"); + builder.put(grammarAccess.getUint32ArrayAccess().getGroup(), "rule__Uint32Array__Group__0"); + builder.put(grammarAccess.getInt64ArrayAccess().getGroup(), "rule__Int64Array__Group__0"); + builder.put(grammarAccess.getUint64ArrayAccess().getGroup(), "rule__Uint64Array__Group__0"); + builder.put(grammarAccess.getFloat32ArrayAccess().getGroup(), "rule__Float32Array__Group__0"); + builder.put(grammarAccess.getFloat64ArrayAccess().getGroup(), "rule__Float64Array__Group__0"); + builder.put(grammarAccess.getString0ArrayAccess().getGroup(), "rule__String0Array__Group__0"); + builder.put(grammarAccess.getByteArrayAccess().getGroup(), "rule__ByteArray__Group__0"); + builder.put(grammarAccess.getHeaderAccess().getGroup(), "rule__Header__Group__0"); + builder.put(grammarAccess.getArrayTopicSpecRefAccess().getGroup(), "rule__ArrayTopicSpecRef__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.getPackageSetAccess().getPackageAssignment_1(), "rule__PackageSet__PackageAssignment_1"); + builder.put(grammarAccess.getPackage_ImplAccess().getNameAssignment_1(), "rule__Package_Impl__NameAssignment_1"); + builder.put(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1(), "rule__Package_Impl__FromGitRepoAssignment_4_1"); + builder.put(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2(), "rule__Package_Impl__SpecAssignment_5_2"); + builder.put(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2(), "rule__Package_Impl__DependencyAssignment_6_2"); + builder.put(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1(), "rule__Package_Impl__DependencyAssignment_6_3_1"); + builder.put(grammarAccess.getAmentPackageAccess().getNameAssignment_2(), "rule__AmentPackage__NameAssignment_2"); + builder.put(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_5_1(), "rule__AmentPackage__FromGitRepoAssignment_5_1"); + builder.put(grammarAccess.getAmentPackageAccess().getArtifactAssignment_6_2(), "rule__AmentPackage__ArtifactAssignment_6_2"); + builder.put(grammarAccess.getAmentPackageAccess().getDependencyAssignment_7_2(), "rule__AmentPackage__DependencyAssignment_7_2"); + builder.put(grammarAccess.getAmentPackageAccess().getDependencyAssignment_7_3_1(), "rule__AmentPackage__DependencyAssignment_7_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_0_2(), "rule__Node__PublisherAssignment_3_0_2"); + builder.put(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2(), "rule__Node__SubscriberAssignment_3_1_2"); + builder.put(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2(), "rule__Node__ServiceserverAssignment_3_2_2"); + builder.put(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2(), "rule__Node__ServiceclientAssignment_3_3_2"); + builder.put(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2(), "rule__Node__ActionserverAssignment_3_4_2"); + builder.put(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2(), "rule__Node__ActionclientAssignment_3_5_2"); + builder.put(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2(), "rule__Node__ParameterAssignment_3_6_2"); + builder.put(grammarAccess.getTopicSpecAccess().getNameAssignment_2(), "rule__TopicSpec__NameAssignment_2"); + builder.put(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1(), "rule__TopicSpec__MessageAssignment_5_1"); + builder.put(grammarAccess.getServiceSpecAccess().getNameAssignment_2(), "rule__ServiceSpec__NameAssignment_2"); + builder.put(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1(), "rule__ServiceSpec__RequestAssignment_5_1"); + builder.put(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1(), "rule__ServiceSpec__ResponseAssignment_7_1"); + builder.put(grammarAccess.getActionSpecAccess().getNameAssignment_2(), "rule__ActionSpec__NameAssignment_2"); + builder.put(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1(), "rule__ActionSpec__GoalAssignment_5_1"); + builder.put(grammarAccess.getActionSpecAccess().getResultAssignment_7_1(), "rule__ActionSpec__ResultAssignment_7_1"); + builder.put(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1(), "rule__ActionSpec__FeedbackAssignment_9_1"); + builder.put(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1(), "rule__MessageDefinition__MessagePartAssignment_1"); + builder.put(grammarAccess.getPublisherAccess().getNameAssignment_1(), "rule__Publisher__NameAssignment_1"); + builder.put(grammarAccess.getPublisherAccess().getMessageAssignment_5(), "rule__Publisher__MessageAssignment_5"); + builder.put(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1(), "rule__Publisher__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getSubscriberAccess().getNameAssignment_1(), "rule__Subscriber__NameAssignment_1"); + builder.put(grammarAccess.getSubscriberAccess().getMessageAssignment_5(), "rule__Subscriber__MessageAssignment_5"); + builder.put(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1(), "rule__Subscriber__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getServiceServerAccess().getNameAssignment_1(), "rule__ServiceServer__NameAssignment_1"); + builder.put(grammarAccess.getServiceServerAccess().getServiceAssignment_5(), "rule__ServiceServer__ServiceAssignment_5"); + builder.put(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1(), "rule__ServiceServer__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getServiceClientAccess().getNameAssignment_1(), "rule__ServiceClient__NameAssignment_1"); + builder.put(grammarAccess.getServiceClientAccess().getServiceAssignment_5(), "rule__ServiceClient__ServiceAssignment_5"); + builder.put(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1(), "rule__ServiceClient__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getActionServerAccess().getNameAssignment_1(), "rule__ActionServer__NameAssignment_1"); + builder.put(grammarAccess.getActionServerAccess().getActionAssignment_5(), "rule__ActionServer__ActionAssignment_5"); + builder.put(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1(), "rule__ActionServer__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getActionClientAccess().getNameAssignment_1(), "rule__ActionClient__NameAssignment_1"); + builder.put(grammarAccess.getActionClientAccess().getActionAssignment_5(), "rule__ActionClient__ActionAssignment_5"); + builder.put(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1(), "rule__ActionClient__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getPackageDependencyAccess().getPackageAssignment(), "rule__PackageDependency__PackageAssignment"); + builder.put(grammarAccess.getExternalDependencyAccess().getNameAssignment_2(), "rule__ExternalDependency__NameAssignment_2"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1(), "rule__GlobalNamespace__PartsAssignment_2_1"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1(), "rule__GlobalNamespace__PartsAssignment_2_2_1"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1(), "rule__RelativeNamespace_Impl__PartsAssignment_2_1"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1(), "rule__RelativeNamespace_Impl__PartsAssignment_2_2_1"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1(), "rule__PrivateNamespace__PartsAssignment_2_1"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1(), "rule__PrivateNamespace__PartsAssignment_2_2_1"); + builder.put(grammarAccess.getParameterAccess().getNameAssignment_1(), "rule__Parameter__NameAssignment_1"); + builder.put(grammarAccess.getParameterAccess().getTypeAssignment_5(), "rule__Parameter__TypeAssignment_5"); + builder.put(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1(), "rule__Parameter__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3(), "rule__ParameterListType__SequenceAssignment_3"); + builder.put(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1(), "rule__ParameterListType__SequenceAssignment_4_1"); + builder.put(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3(), "rule__ParameterStructType__ParameterstructypetmemberAssignment_3"); + builder.put(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1(), "rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1"); + builder.put(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterIntegerType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterStringType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterDoubleType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterDateTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterDateType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterBooleanType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1(), "rule__ParameterBase64Type__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterAnyTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterAnyType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3(), "rule__ParameterArrayType__TypeAssignment_3"); + builder.put(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1(), "rule__ParameterArrayType__DefaultAssignment_4_1"); + builder.put(grammarAccess.getParameterListAccess().getValueAssignment_2(), "rule__ParameterList__ValueAssignment_2"); + builder.put(grammarAccess.getParameterListAccess().getValueAssignment_3_1(), "rule__ParameterList__ValueAssignment_3_1"); + builder.put(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1(), "rule__ParameterAny__ValueAssignment_2_1"); + builder.put(grammarAccess.getParameterStringAccess().getValueAssignment(), "rule__ParameterString__ValueAssignment"); + builder.put(grammarAccess.getParameterBase64Access().getValueAssignment(), "rule__ParameterBase64__ValueAssignment"); + builder.put(grammarAccess.getParameterIntegerAccess().getValueAssignment(), "rule__ParameterInteger__ValueAssignment"); + builder.put(grammarAccess.getParameterDoubleAccess().getValueAssignment(), "rule__ParameterDouble__ValueAssignment"); + builder.put(grammarAccess.getParameterBooleanAccess().getValueAssignment(), "rule__ParameterBoolean__ValueAssignment"); + builder.put(grammarAccess.getParameterStructAccess().getValueAssignment_1_1(), "rule__ParameterStruct__ValueAssignment_1_1"); + builder.put(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2(), "rule__ParameterStruct__ValueAssignment_1_2_2"); + builder.put(grammarAccess.getParameterDateAccess().getValueAssignment(), "rule__ParameterDate__ValueAssignment"); + builder.put(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1(), "rule__ParameterStructMember__NameAssignment_1"); + builder.put(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4(), "rule__ParameterStructMember__ValueAssignment_4"); + builder.put(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0(), "rule__ParameterStructTypeMember__NameAssignment_0"); + builder.put(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1(), "rule__ParameterStructTypeMember__TypeAssignment_1"); + builder.put(grammarAccess.getMessagePartAccess().getTypeAssignment_0(), "rule__MessagePart__TypeAssignment_0"); + builder.put(grammarAccess.getMessagePartAccess().getDataAssignment_1(), "rule__MessagePart__DataAssignment_1"); + builder.put(grammarAccess.getTopicSpecRefAccess().getTopicSpecAssignment(), "rule__TopicSpecRef__TopicSpecAssignment"); + builder.put(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0(), "rule__ArrayTopicSpecRef__TopicSpecAssignment_0"); + } + } + + @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..439997f21 --- /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,14281 @@ +/* + * 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("LeftSquareBracketRightSquareBracket", "'[]'"); + tokenNameToValue.put("Any", "'Any'"); + tokenNameToValue.put("Ns", "'ns:'"); + tokenNameToValue.put("Date", "'Date'"); + tokenNameToValue.put("List", "'List'"); + tokenNameToValue.put("Bool", "'bool'"); + tokenNameToValue.put("Byte", "'byte'"); + tokenNameToValue.put("Goal", "'goal'"); + tokenNameToValue.put("Int8", "'int8'"); + tokenNameToValue.put("Msg", "'msg:'"); + tokenNameToValue.put("Name", "'name'"); + tokenNameToValue.put("Node", "'node'"); + tokenNameToValue.put("Srv", "'srv:'"); + tokenNameToValue.put("Time", "'time'"); + tokenNameToValue.put("Type", "'type'"); + tokenNameToValue.put("Goal_1", "'goal:'"); + tokenNameToValue.put("Int16", "'int16'"); + tokenNameToValue.put("Int32", "'int32'"); + tokenNameToValue.put("Int64", "'int64'"); + tokenNameToValue.put("Node_1", "'node:'"); + tokenNameToValue.put("Type_1", "'type:'"); + tokenNameToValue.put("Uint8", "'uint8'"); + tokenNameToValue.put("Value", "'value'"); + tokenNameToValue.put("Array", "'Array:'"); + tokenNameToValue.put("Base64", "'Base64'"); + tokenNameToValue.put("Double", "'Double'"); + tokenNameToValue.put("Header", "'Header'"); + tokenNameToValue.put("String", "'String'"); + tokenNameToValue.put("Struct", "'Struct'"); + tokenNameToValue.put("Action", "'action'"); + tokenNameToValue.put("Bool_1", "'bool[]'"); + tokenNameToValue.put("Byte_1", "'byte[]'"); + tokenNameToValue.put("Int8_1", "'int8[]'"); + tokenNameToValue.put("Result", "'result'"); + tokenNameToValue.put("Specs", "'specs:'"); + tokenNameToValue.put("String_1", "'string'"); + tokenNameToValue.put("Uint16", "'uint16'"); + tokenNameToValue.put("Uint32", "'uint32'"); + tokenNameToValue.put("Uint64", "'uint64'"); + tokenNameToValue.put("Boolean", "'Boolean'"); + tokenNameToValue.put("Integer", "'Integer'"); + tokenNameToValue.put("Action_1", "'action:'"); + tokenNameToValue.put("Default", "'default'"); + tokenNameToValue.put("Float32", "'float32'"); + tokenNameToValue.put("Float64", "'float64'"); + tokenNameToValue.put("Int16_1", "'int16[]'"); + tokenNameToValue.put("Int32_1", "'int32[]'"); + tokenNameToValue.put("Int64_1", "'int64[]'"); + tokenNameToValue.put("Message", "'message'"); + tokenNameToValue.put("Result_1", "'result:'"); + tokenNameToValue.put("Service", "'service'"); + tokenNameToValue.put("Uint8_1", "'uint8[]'"); + tokenNameToValue.put("Duration", "'duration'"); + tokenNameToValue.put("Feedback", "'feedback'"); + tokenNameToValue.put("Message_1", "'message:'"); + tokenNameToValue.put("Request", "'request:'"); + tokenNameToValue.put("String_2", "'string[]'"); + tokenNameToValue.put("Uint16_1", "'uint16[]'"); + tokenNameToValue.put("Uint32_1", "'uint32[]'"); + tokenNameToValue.put("Uint64_1", "'uint64[]'"); + tokenNameToValue.put("GraphName", "'GraphName'"); + tokenNameToValue.put("Feedback_1", "'feedback:'"); + tokenNameToValue.put("Float32_1", "'float32[]'"); + tokenNameToValue.put("Float64_1", "'float64[]'"); + tokenNameToValue.put("Response", "'response:'"); + tokenNameToValue.put("Artifacts", "'artifacts:'"); + tokenNameToValue.put("Parameters", "'parameters:'"); + tokenNameToValue.put("Publishers", "'publishers:'"); + tokenNameToValue.put("AmentPackage", "'AmentPackage'"); + tokenNameToValue.put("ParameterAny", "'ParameterAny'"); + tokenNameToValue.put("FromGitRepo", "'fromGitRepo:'"); + tokenNameToValue.put("Subscribers", "'subscribers:'"); + tokenNameToValue.put("Actionclient", "'actionclient:'"); + tokenNameToValue.put("Actionserver", "'actionserver:'"); + tokenNameToValue.put("Dependencies", "'dependencies:'"); + tokenNameToValue.put("Serviceclient", "'serviceclient:'"); + tokenNameToValue.put("Serviceserver", "'serviceserver:'"); + tokenNameToValue.put("GlobalNamespace", "'GlobalNamespace'"); + tokenNameToValue.put("PrivateNamespace", "'PrivateNamespace'"); + tokenNameToValue.put("RelativeNamespace", "'RelativeNamespace'"); + tokenNameToValue.put("ExternalDependency", "'ExternalDependency'"); + tokenNameToValue.put("ParameterStructMember", "'ParameterStructMember'"); + } + + 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 entryRulePackage +entryRulePackage +: +{ before(grammarAccess.getPackageRule()); } + rulePackage +{ after(grammarAccess.getPackageRule()); } + EOF +; + +// Rule Package +rulePackage + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall()); } + ruleCatkinPackage + { after(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// 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 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); +} + +// 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 entryRulePackage_Impl +entryRulePackage_Impl +: +{ before(grammarAccess.getPackage_ImplRule()); } + rulePackage_Impl +{ after(grammarAccess.getPackage_ImplRule()); } + EOF +; + +// Rule Package_Impl +rulePackage_Impl + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getPackage_ImplAccess().getGroup()); } + (rule__Package_Impl__Group__0) + { after(grammarAccess.getPackage_ImplAccess().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 entryRuleSpecBase +entryRuleSpecBase +: +{ before(grammarAccess.getSpecBaseRule()); } + ruleSpecBase +{ after(grammarAccess.getSpecBaseRule()); } + EOF +; + +// Rule SpecBase +ruleSpecBase + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getSpecBaseAccess().getAlternatives()); } + (rule__SpecBase__Alternatives) + { after(grammarAccess.getSpecBaseAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleTopicSpec +entryRuleTopicSpec +: +{ before(grammarAccess.getTopicSpecRule()); } + ruleTopicSpec +{ after(grammarAccess.getTopicSpecRule()); } + EOF +; + +// Rule TopicSpec +ruleTopicSpec + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getTopicSpecAccess().getGroup()); } + (rule__TopicSpec__Group__0) + { after(grammarAccess.getTopicSpecAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleServiceSpec +entryRuleServiceSpec +: +{ before(grammarAccess.getServiceSpecRule()); } + ruleServiceSpec +{ after(grammarAccess.getServiceSpecRule()); } + EOF +; + +// Rule ServiceSpec +ruleServiceSpec + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getServiceSpecAccess().getGroup()); } + (rule__ServiceSpec__Group__0) + { after(grammarAccess.getServiceSpecAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleActionSpec +entryRuleActionSpec +: +{ before(grammarAccess.getActionSpecRule()); } + ruleActionSpec +{ after(grammarAccess.getActionSpecRule()); } + EOF +; + +// Rule ActionSpec +ruleActionSpec + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getActionSpecAccess().getGroup()); } + (rule__ActionSpec__Group__0) + { after(grammarAccess.getActionSpecAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleMessageDefinition +entryRuleMessageDefinition +: +{ before(grammarAccess.getMessageDefinitionRule()); } + ruleMessageDefinition +{ after(grammarAccess.getMessageDefinitionRule()); } + EOF +; + +// Rule MessageDefinition +ruleMessageDefinition + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getMessageDefinitionAccess().getGroup()); } + (rule__MessageDefinition__Group__0) + { after(grammarAccess.getMessageDefinitionAccess().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 entryRuleServiceServer +entryRuleServiceServer +: +{ before(grammarAccess.getServiceServerRule()); } + ruleServiceServer +{ after(grammarAccess.getServiceServerRule()); } + EOF +; + +// Rule ServiceServer +ruleServiceServer + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getServiceServerAccess().getGroup()); } + (rule__ServiceServer__Group__0) + { after(grammarAccess.getServiceServerAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleServiceClient +entryRuleServiceClient +: +{ before(grammarAccess.getServiceClientRule()); } + ruleServiceClient +{ after(grammarAccess.getServiceClientRule()); } + EOF +; + +// Rule ServiceClient +ruleServiceClient + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getServiceClientAccess().getGroup()); } + (rule__ServiceClient__Group__0) + { after(grammarAccess.getServiceClientAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleActionServer +entryRuleActionServer +: +{ before(grammarAccess.getActionServerRule()); } + ruleActionServer +{ after(grammarAccess.getActionServerRule()); } + EOF +; + +// Rule ActionServer +ruleActionServer + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getActionServerAccess().getGroup()); } + (rule__ActionServer__Group__0) + { after(grammarAccess.getActionServerAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleActionClient +entryRuleActionClient +: +{ before(grammarAccess.getActionClientRule()); } + ruleActionClient +{ after(grammarAccess.getActionClientRule()); } + EOF +; + +// Rule ActionClient +ruleActionClient + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getActionClientAccess().getGroup()); } + (rule__ActionClient__Group__0) + { after(grammarAccess.getActionClientAccess().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 entryRuleNamespace +entryRuleNamespace +: +{ before(grammarAccess.getNamespaceRule()); } + ruleNamespace +{ after(grammarAccess.getNamespaceRule()); } + EOF +; + +// Rule Namespace +ruleNamespace + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getNamespaceAccess().getAlternatives()); } + (rule__Namespace__Alternatives) + { after(grammarAccess.getNamespaceAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleGraphName +entryRuleGraphName +: +{ before(grammarAccess.getGraphNameRule()); } + ruleGraphName +{ after(grammarAccess.getGraphNameRule()); } + EOF +; + +// Rule GraphName +ruleGraphName + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); } + GraphName + { after(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleGlobalNamespace +entryRuleGlobalNamespace +: +{ before(grammarAccess.getGlobalNamespaceRule()); } + ruleGlobalNamespace +{ after(grammarAccess.getGlobalNamespaceRule()); } + EOF +; + +// Rule GlobalNamespace +ruleGlobalNamespace + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getGlobalNamespaceAccess().getGroup()); } + (rule__GlobalNamespace__Group__0) + { after(grammarAccess.getGlobalNamespaceAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleRelativeNamespace_Impl +entryRuleRelativeNamespace_Impl +: +{ before(grammarAccess.getRelativeNamespace_ImplRule()); } + ruleRelativeNamespace_Impl +{ after(grammarAccess.getRelativeNamespace_ImplRule()); } + EOF +; + +// Rule RelativeNamespace_Impl +ruleRelativeNamespace_Impl + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup()); } + (rule__RelativeNamespace_Impl__Group__0) + { after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulePrivateNamespace +entryRulePrivateNamespace +: +{ before(grammarAccess.getPrivateNamespaceRule()); } + rulePrivateNamespace +{ after(grammarAccess.getPrivateNamespaceRule()); } + EOF +; + +// Rule PrivateNamespace +rulePrivateNamespace + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getPrivateNamespaceAccess().getGroup()); } + (rule__PrivateNamespace__Group__0) + { after(grammarAccess.getPrivateNamespaceAccess().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 entryRuleParameterType +entryRuleParameterType +: +{ before(grammarAccess.getParameterTypeRule()); } + ruleParameterType +{ after(grammarAccess.getParameterTypeRule()); } + EOF +; + +// Rule ParameterType +ruleParameterType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterTypeAccess().getAlternatives()); } + (rule__ParameterType__Alternatives) + { after(grammarAccess.getParameterTypeAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterValue +entryRuleParameterValue +: +{ before(grammarAccess.getParameterValueRule()); } + ruleParameterValue +{ after(grammarAccess.getParameterValueRule()); } + EOF +; + +// Rule ParameterValue +ruleParameterValue + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterValueAccess().getAlternatives()); } + (rule__ParameterValue__Alternatives) + { after(grammarAccess.getParameterValueAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterListType +entryRuleParameterListType +: +{ before(grammarAccess.getParameterListTypeRule()); } + ruleParameterListType +{ after(grammarAccess.getParameterListTypeRule()); } + EOF +; + +// Rule ParameterListType +ruleParameterListType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterListTypeAccess().getGroup()); } + (rule__ParameterListType__Group__0) + { after(grammarAccess.getParameterListTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterStructType +entryRuleParameterStructType +: +{ before(grammarAccess.getParameterStructTypeRule()); } + ruleParameterStructType +{ after(grammarAccess.getParameterStructTypeRule()); } + EOF +; + +// Rule ParameterStructType +ruleParameterStructType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStructTypeAccess().getGroup()); } + (rule__ParameterStructType__Group__0) + { after(grammarAccess.getParameterStructTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterIntegerType +entryRuleParameterIntegerType +: +{ before(grammarAccess.getParameterIntegerTypeRule()); } + ruleParameterIntegerType +{ after(grammarAccess.getParameterIntegerTypeRule()); } + EOF +; + +// Rule ParameterIntegerType +ruleParameterIntegerType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterIntegerTypeAccess().getGroup()); } + (rule__ParameterIntegerType__Group__0) + { after(grammarAccess.getParameterIntegerTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterStringType +entryRuleParameterStringType +: +{ before(grammarAccess.getParameterStringTypeRule()); } + ruleParameterStringType +{ after(grammarAccess.getParameterStringTypeRule()); } + EOF +; + +// Rule ParameterStringType +ruleParameterStringType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStringTypeAccess().getGroup()); } + (rule__ParameterStringType__Group__0) + { after(grammarAccess.getParameterStringTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterDoubleType +entryRuleParameterDoubleType +: +{ before(grammarAccess.getParameterDoubleTypeRule()); } + ruleParameterDoubleType +{ after(grammarAccess.getParameterDoubleTypeRule()); } + EOF +; + +// Rule ParameterDoubleType +ruleParameterDoubleType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterDoubleTypeAccess().getGroup()); } + (rule__ParameterDoubleType__Group__0) + { after(grammarAccess.getParameterDoubleTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterBooleanType +entryRuleParameterBooleanType +: +{ before(grammarAccess.getParameterBooleanTypeRule()); } + ruleParameterBooleanType +{ after(grammarAccess.getParameterBooleanTypeRule()); } + EOF +; + +// Rule ParameterBooleanType +ruleParameterBooleanType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterBooleanTypeAccess().getGroup()); } + (rule__ParameterBooleanType__Group__0) + { after(grammarAccess.getParameterBooleanTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterBase64Type +entryRuleParameterBase64Type +: +{ before(grammarAccess.getParameterBase64TypeRule()); } + ruleParameterBase64Type +{ after(grammarAccess.getParameterBase64TypeRule()); } + EOF +; + +// Rule ParameterBase64Type +ruleParameterBase64Type + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterBase64TypeAccess().getGroup()); } + (rule__ParameterBase64Type__Group__0) + { after(grammarAccess.getParameterBase64TypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterArrayType +entryRuleParameterArrayType +: +{ before(grammarAccess.getParameterArrayTypeRule()); } + ruleParameterArrayType +{ after(grammarAccess.getParameterArrayTypeRule()); } + EOF +; + +// Rule ParameterArrayType +ruleParameterArrayType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterArrayTypeAccess().getGroup()); } + (rule__ParameterArrayType__Group__0) + { after(grammarAccess.getParameterArrayTypeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterList +entryRuleParameterList +: +{ before(grammarAccess.getParameterListRule()); } + ruleParameterList +{ after(grammarAccess.getParameterListRule()); } + EOF +; + +// Rule ParameterList +ruleParameterList + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterListAccess().getGroup()); } + (rule__ParameterList__Group__0) + { after(grammarAccess.getParameterListAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterAny +entryRuleParameterAny +: +{ before(grammarAccess.getParameterAnyRule()); } + ruleParameterAny +{ after(grammarAccess.getParameterAnyRule()); } + EOF +; + +// Rule ParameterAny +ruleParameterAny + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterAnyAccess().getGroup()); } + (rule__ParameterAny__Group__0) + { after(grammarAccess.getParameterAnyAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterString +entryRuleParameterString +: +{ before(grammarAccess.getParameterStringRule()); } + ruleParameterString +{ after(grammarAccess.getParameterStringRule()); } + EOF +; + +// Rule ParameterString +ruleParameterString + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStringAccess().getValueAssignment()); } + (rule__ParameterString__ValueAssignment) + { after(grammarAccess.getParameterStringAccess().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterBase64 +entryRuleParameterBase64 +: +{ before(grammarAccess.getParameterBase64Rule()); } + ruleParameterBase64 +{ after(grammarAccess.getParameterBase64Rule()); } + EOF +; + +// Rule ParameterBase64 +ruleParameterBase64 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterBase64Access().getValueAssignment()); } + (rule__ParameterBase64__ValueAssignment) + { after(grammarAccess.getParameterBase64Access().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterInteger +entryRuleParameterInteger +: +{ before(grammarAccess.getParameterIntegerRule()); } + ruleParameterInteger +{ after(grammarAccess.getParameterIntegerRule()); } + EOF +; + +// Rule ParameterInteger +ruleParameterInteger + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterIntegerAccess().getValueAssignment()); } + (rule__ParameterInteger__ValueAssignment) + { after(grammarAccess.getParameterIntegerAccess().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterDouble +entryRuleParameterDouble +: +{ before(grammarAccess.getParameterDoubleRule()); } + ruleParameterDouble +{ after(grammarAccess.getParameterDoubleRule()); } + EOF +; + +// Rule ParameterDouble +ruleParameterDouble + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterDoubleAccess().getValueAssignment()); } + (rule__ParameterDouble__ValueAssignment) + { after(grammarAccess.getParameterDoubleAccess().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterBoolean +entryRuleParameterBoolean +: +{ before(grammarAccess.getParameterBooleanRule()); } + ruleParameterBoolean +{ after(grammarAccess.getParameterBooleanRule()); } + EOF +; + +// Rule ParameterBoolean +ruleParameterBoolean + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterBooleanAccess().getValueAssignment()); } + (rule__ParameterBoolean__ValueAssignment) + { after(grammarAccess.getParameterBooleanAccess().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterStruct +entryRuleParameterStruct +: +{ before(grammarAccess.getParameterStructRule()); } + ruleParameterStruct +{ after(grammarAccess.getParameterStructRule()); } + EOF +; + +// Rule ParameterStruct +ruleParameterStruct + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStructAccess().getGroup()); } + (rule__ParameterStruct__Group__0) + { after(grammarAccess.getParameterStructAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterDate +entryRuleParameterDate +: +{ before(grammarAccess.getParameterDateRule()); } + ruleParameterDate +{ after(grammarAccess.getParameterDateRule()); } + EOF +; + +// Rule ParameterDate +ruleParameterDate + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterDateAccess().getValueAssignment()); } + (rule__ParameterDate__ValueAssignment) + { after(grammarAccess.getParameterDateAccess().getValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterStructMember +entryRuleParameterStructMember +: +{ before(grammarAccess.getParameterStructMemberRule()); } + ruleParameterStructMember +{ after(grammarAccess.getParameterStructMemberRule()); } + EOF +; + +// Rule ParameterStructMember +ruleParameterStructMember + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStructMemberAccess().getGroup()); } + (rule__ParameterStructMember__Group__0) + { after(grammarAccess.getParameterStructMemberAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameterStructTypeMember +entryRuleParameterStructTypeMember +: +{ before(grammarAccess.getParameterStructTypeMemberRule()); } + ruleParameterStructTypeMember +{ after(grammarAccess.getParameterStructTypeMemberRule()); } + EOF +; + +// Rule ParameterStructTypeMember +ruleParameterStructTypeMember + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterStructTypeMemberAccess().getGroup()); } + (rule__ParameterStructTypeMember__Group__0) + { after(grammarAccess.getParameterStructTypeMemberAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleBase64Binary +entryRuleBase64Binary +: +{ before(grammarAccess.getBase64BinaryRule()); } + ruleBase64Binary +{ after(grammarAccess.getBase64BinaryRule()); } + EOF +; + +// Rule Base64Binary +ruleBase64Binary + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); } + RULE_BINARY + { after(grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleboolean0 +entryRuleboolean0 +: +{ before(grammarAccess.getBoolean0Rule()); } + ruleboolean0 +{ after(grammarAccess.getBoolean0Rule()); } + EOF +; + +// Rule boolean0 +ruleboolean0 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); } + RULE_BOOLEAN + { after(grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleDouble0 +entryRuleDouble0 +: +{ before(grammarAccess.getDouble0Rule()); } + ruleDouble0 +{ after(grammarAccess.getDouble0Rule()); } + EOF +; + +// Rule Double0 +ruleDouble0 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); } + RULE_DOUBLE + { after(grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleInteger0 +entryRuleInteger0 +: +{ before(grammarAccess.getInteger0Rule()); } + ruleInteger0 +{ after(grammarAccess.getInteger0Rule()); } + EOF +; + +// Rule Integer0 +ruleInteger0 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); } + RULE_DECINT + { after(grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleDateTime0 +entryRuleDateTime0 +: +{ before(grammarAccess.getDateTime0Rule()); } + ruleDateTime0 +{ after(grammarAccess.getDateTime0Rule()); } + EOF +; + +// Rule DateTime0 +ruleDateTime0 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); } + RULE_DATE_TIME + { after(grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleMessagePart +entryRuleMessagePart +: +{ before(grammarAccess.getMessagePartRule()); } + ruleMessagePart +{ after(grammarAccess.getMessagePartRule()); } + EOF +; + +// Rule MessagePart +ruleMessagePart + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getMessagePartAccess().getGroup()); } + (rule__MessagePart__Group__0) + { after(grammarAccess.getMessagePartAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleAbstractType +entryRuleAbstractType +: +{ before(grammarAccess.getAbstractTypeRule()); } + ruleAbstractType +{ after(grammarAccess.getAbstractTypeRule()); } + EOF +; + +// Rule AbstractType +ruleAbstractType + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getAbstractTypeAccess().getAlternatives()); } + (rule__AbstractType__Alternatives) + { after(grammarAccess.getAbstractTypeAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulebool +entryRulebool +: +{ before(grammarAccess.getBoolRule()); } + rulebool +{ after(grammarAccess.getBoolRule()); } + EOF +; + +// Rule bool +rulebool + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getBoolAccess().getGroup()); } + (rule__Bool__Group__0) + { after(grammarAccess.getBoolAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint8 +entryRuleint8 +: +{ before(grammarAccess.getInt8Rule()); } + ruleint8 +{ after(grammarAccess.getInt8Rule()); } + EOF +; + +// Rule int8 +ruleint8 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt8Access().getGroup()); } + (rule__Int8__Group__0) + { after(grammarAccess.getInt8Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint8 +entryRuleuint8 +: +{ before(grammarAccess.getUint8Rule()); } + ruleuint8 +{ after(grammarAccess.getUint8Rule()); } + EOF +; + +// Rule uint8 +ruleuint8 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint8Access().getGroup()); } + (rule__Uint8__Group__0) + { after(grammarAccess.getUint8Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint16 +entryRuleint16 +: +{ before(grammarAccess.getInt16Rule()); } + ruleint16 +{ after(grammarAccess.getInt16Rule()); } + EOF +; + +// Rule int16 +ruleint16 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt16Access().getGroup()); } + (rule__Int16__Group__0) + { after(grammarAccess.getInt16Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint16 +entryRuleuint16 +: +{ before(grammarAccess.getUint16Rule()); } + ruleuint16 +{ after(grammarAccess.getUint16Rule()); } + EOF +; + +// Rule uint16 +ruleuint16 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint16Access().getGroup()); } + (rule__Uint16__Group__0) + { after(grammarAccess.getUint16Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint32 +entryRuleint32 +: +{ before(grammarAccess.getInt32Rule()); } + ruleint32 +{ after(grammarAccess.getInt32Rule()); } + EOF +; + +// Rule int32 +ruleint32 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt32Access().getGroup()); } + (rule__Int32__Group__0) + { after(grammarAccess.getInt32Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint32 +entryRuleuint32 +: +{ before(grammarAccess.getUint32Rule()); } + ruleuint32 +{ after(grammarAccess.getUint32Rule()); } + EOF +; + +// Rule uint32 +ruleuint32 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint32Access().getGroup()); } + (rule__Uint32__Group__0) + { after(grammarAccess.getUint32Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint64 +entryRuleint64 +: +{ before(grammarAccess.getInt64Rule()); } + ruleint64 +{ after(grammarAccess.getInt64Rule()); } + EOF +; + +// Rule int64 +ruleint64 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt64Access().getGroup()); } + (rule__Int64__Group__0) + { after(grammarAccess.getInt64Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint64 +entryRuleuint64 +: +{ before(grammarAccess.getUint64Rule()); } + ruleuint64 +{ after(grammarAccess.getUint64Rule()); } + EOF +; + +// Rule uint64 +ruleuint64 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint64Access().getGroup()); } + (rule__Uint64__Group__0) + { after(grammarAccess.getUint64Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulefloat32 +entryRulefloat32 +: +{ before(grammarAccess.getFloat32Rule()); } + rulefloat32 +{ after(grammarAccess.getFloat32Rule()); } + EOF +; + +// Rule float32 +rulefloat32 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFloat32Access().getGroup()); } + (rule__Float32__Group__0) + { after(grammarAccess.getFloat32Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulefloat64 +entryRulefloat64 +: +{ before(grammarAccess.getFloat64Rule()); } + rulefloat64 +{ after(grammarAccess.getFloat64Rule()); } + EOF +; + +// Rule float64 +rulefloat64 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFloat64Access().getGroup()); } + (rule__Float64__Group__0) + { after(grammarAccess.getFloat64Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulestring0 +entryRulestring0 +: +{ before(grammarAccess.getString0Rule()); } + rulestring0 +{ after(grammarAccess.getString0Rule()); } + EOF +; + +// Rule string0 +rulestring0 + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getString0Access().getGroup()); } + (rule__String0__Group__0) + { after(grammarAccess.getString0Access().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulebyte +entryRulebyte +: +{ before(grammarAccess.getByteRule()); } + rulebyte +{ after(grammarAccess.getByteRule()); } + EOF +; + +// Rule byte +rulebyte + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getByteAccess().getGroup()); } + (rule__Byte__Group__0) + { after(grammarAccess.getByteAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuletime +entryRuletime +: +{ before(grammarAccess.getTimeRule()); } + ruletime +{ after(grammarAccess.getTimeRule()); } + EOF +; + +// Rule time +ruletime + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getTimeAccess().getGroup()); } + (rule__Time__Group__0) + { after(grammarAccess.getTimeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleduration +entryRuleduration +: +{ before(grammarAccess.getDurationRule()); } + ruleduration +{ after(grammarAccess.getDurationRule()); } + EOF +; + +// Rule duration +ruleduration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getDurationAccess().getGroup()); } + (rule__Duration__Group__0) + { after(grammarAccess.getDurationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleboolArray +entryRuleboolArray +: +{ before(grammarAccess.getBoolArrayRule()); } + ruleboolArray +{ after(grammarAccess.getBoolArrayRule()); } + EOF +; + +// Rule boolArray +ruleboolArray + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getBoolArrayAccess().getGroup()); } + (rule__BoolArray__Group__0) + { after(grammarAccess.getBoolArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint8Array +entryRuleint8Array +: +{ before(grammarAccess.getInt8ArrayRule()); } + ruleint8Array +{ after(grammarAccess.getInt8ArrayRule()); } + EOF +; + +// Rule int8Array +ruleint8Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt8ArrayAccess().getGroup()); } + (rule__Int8Array__Group__0) + { after(grammarAccess.getInt8ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint8Array +entryRuleuint8Array +: +{ before(grammarAccess.getUint8ArrayRule()); } + ruleuint8Array +{ after(grammarAccess.getUint8ArrayRule()); } + EOF +; + +// Rule uint8Array +ruleuint8Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint8ArrayAccess().getGroup()); } + (rule__Uint8Array__Group__0) + { after(grammarAccess.getUint8ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint16Array +entryRuleint16Array +: +{ before(grammarAccess.getInt16ArrayRule()); } + ruleint16Array +{ after(grammarAccess.getInt16ArrayRule()); } + EOF +; + +// Rule int16Array +ruleint16Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt16ArrayAccess().getGroup()); } + (rule__Int16Array__Group__0) + { after(grammarAccess.getInt16ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint16Array +entryRuleuint16Array +: +{ before(grammarAccess.getUint16ArrayRule()); } + ruleuint16Array +{ after(grammarAccess.getUint16ArrayRule()); } + EOF +; + +// Rule uint16Array +ruleuint16Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint16ArrayAccess().getGroup()); } + (rule__Uint16Array__Group__0) + { after(grammarAccess.getUint16ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint32Array +entryRuleint32Array +: +{ before(grammarAccess.getInt32ArrayRule()); } + ruleint32Array +{ after(grammarAccess.getInt32ArrayRule()); } + EOF +; + +// Rule int32Array +ruleint32Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt32ArrayAccess().getGroup()); } + (rule__Int32Array__Group__0) + { after(grammarAccess.getInt32ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint32Array +entryRuleuint32Array +: +{ before(grammarAccess.getUint32ArrayRule()); } + ruleuint32Array +{ after(grammarAccess.getUint32ArrayRule()); } + EOF +; + +// Rule uint32Array +ruleuint32Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint32ArrayAccess().getGroup()); } + (rule__Uint32Array__Group__0) + { after(grammarAccess.getUint32ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleint64Array +entryRuleint64Array +: +{ before(grammarAccess.getInt64ArrayRule()); } + ruleint64Array +{ after(grammarAccess.getInt64ArrayRule()); } + EOF +; + +// Rule int64Array +ruleint64Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getInt64ArrayAccess().getGroup()); } + (rule__Int64Array__Group__0) + { after(grammarAccess.getInt64ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleuint64Array +entryRuleuint64Array +: +{ before(grammarAccess.getUint64ArrayRule()); } + ruleuint64Array +{ after(grammarAccess.getUint64ArrayRule()); } + EOF +; + +// Rule uint64Array +ruleuint64Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUint64ArrayAccess().getGroup()); } + (rule__Uint64Array__Group__0) + { after(grammarAccess.getUint64ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulefloat32Array +entryRulefloat32Array +: +{ before(grammarAccess.getFloat32ArrayRule()); } + rulefloat32Array +{ after(grammarAccess.getFloat32ArrayRule()); } + EOF +; + +// Rule float32Array +rulefloat32Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFloat32ArrayAccess().getGroup()); } + (rule__Float32Array__Group__0) + { after(grammarAccess.getFloat32ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulefloat64Array +entryRulefloat64Array +: +{ before(grammarAccess.getFloat64ArrayRule()); } + rulefloat64Array +{ after(grammarAccess.getFloat64ArrayRule()); } + EOF +; + +// Rule float64Array +rulefloat64Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFloat64ArrayAccess().getGroup()); } + (rule__Float64Array__Group__0) + { after(grammarAccess.getFloat64ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulestring0Array +entryRulestring0Array +: +{ before(grammarAccess.getString0ArrayRule()); } + rulestring0Array +{ after(grammarAccess.getString0ArrayRule()); } + EOF +; + +// Rule string0Array +rulestring0Array + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getString0ArrayAccess().getGroup()); } + (rule__String0Array__Group__0) + { after(grammarAccess.getString0ArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulebyteArray +entryRulebyteArray +: +{ before(grammarAccess.getByteArrayRule()); } + rulebyteArray +{ after(grammarAccess.getByteArrayRule()); } + EOF +; + +// Rule byteArray +rulebyteArray + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getByteArrayAccess().getGroup()); } + (rule__ByteArray__Group__0) + { after(grammarAccess.getByteArrayAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleHeader +entryRuleHeader +: +{ before(grammarAccess.getHeaderRule()); } + ruleHeader +{ after(grammarAccess.getHeaderRule()); } + EOF +; + +// Rule Header +ruleHeader + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getHeaderAccess().getGroup()); } + (rule__Header__Group__0) + { after(grammarAccess.getHeaderAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleTopicSpecRef +entryRuleTopicSpecRef +: +{ before(grammarAccess.getTopicSpecRefRule()); } + ruleTopicSpecRef +{ after(grammarAccess.getTopicSpecRefRule()); } + EOF +; + +// Rule TopicSpecRef +ruleTopicSpecRef + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getTopicSpecRefAccess().getTopicSpecAssignment()); } + (rule__TopicSpecRef__TopicSpecAssignment) + { after(grammarAccess.getTopicSpecRefAccess().getTopicSpecAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleArrayTopicSpecRef +entryRuleArrayTopicSpecRef +: +{ before(grammarAccess.getArrayTopicSpecRefRule()); } + ruleArrayTopicSpecRef +{ after(grammarAccess.getArrayTopicSpecRefRule()); } + EOF +; + +// Rule ArrayTopicSpecRef +ruleArrayTopicSpecRef + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getArrayTopicSpecRefAccess().getGroup()); } + (rule__ArrayTopicSpecRef__Group__0) + { after(grammarAccess.getArrayTopicSpecRefAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleKEYWORD +entryRuleKEYWORD +: +{ before(grammarAccess.getKEYWORDRule()); } + ruleKEYWORD +{ after(grammarAccess.getKEYWORDRule()); } + EOF +; + +// Rule KEYWORD +ruleKEYWORD + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getKEYWORDAccess().getAlternatives()); } + (rule__KEYWORD__Alternatives) + { after(grammarAccess.getKEYWORDAccess().getAlternatives()); } + ) +; +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__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__Node__Alternatives_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getGroup_3_0()); } + (rule__Node__Group_3_0__0) + { after(grammarAccess.getNodeAccess().getGroup_3_0()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_1()); } + (rule__Node__Group_3_1__0) + { after(grammarAccess.getNodeAccess().getGroup_3_1()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_2()); } + (rule__Node__Group_3_2__0) + { after(grammarAccess.getNodeAccess().getGroup_3_2()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_3()); } + (rule__Node__Group_3_3__0) + { after(grammarAccess.getNodeAccess().getGroup_3_3()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_4()); } + (rule__Node__Group_3_4__0) + { after(grammarAccess.getNodeAccess().getGroup_3_4()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_5()); } + (rule__Node__Group_3_5__0) + { after(grammarAccess.getNodeAccess().getGroup_3_5()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_6()); } + (rule__Node__Group_3_6__0) + { after(grammarAccess.getNodeAccess().getGroup_3_6()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__SpecBase__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); } + ruleTopicSpec + { after(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); } + ruleServiceSpec + { after(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); } + ruleActionSpec + { after(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__NameAlternatives_2_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); } + ruleEString + { after(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); } + ) + | + ( + { before(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); } + Header + { after(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); } + ) + | + ( + { before(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); } + String + { after(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); } + ) +; +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__Namespace__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); } + ruleGlobalNamespace + { after(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); } + ruleRelativeNamespace_Impl + { after(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); } + rulePrivateNamespace + { after(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterType__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); } + ruleParameterListType + { after(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); } + ruleParameterStructType + { after(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); } + ruleParameterIntegerType + { after(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); } + ruleParameterStringType + { after(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); } + ruleParameterDoubleType + { after(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); } + ruleParameterBooleanType + { after(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); } + ruleParameterBase64Type + { after(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); } + ) + | + ( + { before(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); } + ruleParameterArrayType + { after(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterValue__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); } + ruleParameterString + { after(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); } + ruleParameterBase64 + { after(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); } + ruleParameterInteger + { after(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); } + ruleParameterDouble + { after(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); } + ruleParameterBoolean + { after(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); } + ruleParameterList + { after(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); } + ruleParameterStruct + { after(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__DataAlternatives_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); } + ruleKEYWORD + { after(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); } + ) + | + ( + { before(grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); } + RULE_MESSAGE_ASIGMENT + { after(grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); } + ) + | + ( + { before(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); } + ruleEString + { after(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__AbstractType__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); } + rulebool + { after(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); } + ruleint8 + { after(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); } + ruleuint8 + { after(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); } + ruleint16 + { after(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); } + ruleuint16 + { after(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); } + ruleint32 + { after(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); } + ruleuint32 + { after(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); } + ruleint64 + { after(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); } + ruleuint64 + { after(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); } + rulefloat32 + { after(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); } + rulefloat64 + { after(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); } + rulestring0 + { after(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); } + rulebyte + { after(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); } + ruletime + { after(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); } + ruleduration + { after(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); } + ruleHeader + { after(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); } + ruleboolArray + { after(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); } + ruleint8Array + { after(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); } + ruleuint8Array + { after(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); } + ruleint16Array + { after(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); } + ruleuint16Array + { after(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); } + ruleint32Array + { after(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); } + ruleuint32Array + { after(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); } + ruleint64Array + { after(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); } + ruleuint64Array + { after(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); } + rulefloat32Array + { after(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); } + rulefloat64Array + { after(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); } + rulestring0Array + { after(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); } + rulebyteArray + { after(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); } + ruleTopicSpecRef + { after(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); } + ruleArrayTopicSpecRef + { after(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__KEYWORD__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); } + Goal + { after(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); } + Message + { after(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); } + Result + { after(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); } + Feedback + { after(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); } + Name + { after(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); } + Value + { after(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); } + Service + { after(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); } + Type + { after(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); } + Action + { after(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); } + Duration + { after(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); } + Time + { after(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); } + ) +; +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__Package_Impl__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__0__Impl + rule__Package_Impl__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); } + () + { after(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__1__Impl + rule__Package_Impl__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); } + (rule__Package_Impl__NameAssignment_1) + { after(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__2__Impl + rule__Package_Impl__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__3__Impl + rule__Package_Impl__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__4__Impl + rule__Package_Impl__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getGroup_4()); } + (rule__Package_Impl__Group_4__0)? + { after(grammarAccess.getPackage_ImplAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__5__Impl + rule__Package_Impl__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getGroup_5()); } + (rule__Package_Impl__Group_5__0)? + { after(grammarAccess.getPackage_ImplAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__6__Impl + rule__Package_Impl__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getGroup_6()); } + (rule__Package_Impl__Group_6__0)? + { after(grammarAccess.getPackage_ImplAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Package_Impl__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_4__0__Impl + rule__Package_Impl__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); } + FromGitRepo + { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); } + (rule__Package_Impl__FromGitRepoAssignment_4_1) + { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Package_Impl__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_5__0__Impl + rule__Package_Impl__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); } + Specs + { after(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_5__1__Impl + rule__Package_Impl__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); } + RULE_BEGIN + { after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_5__2__Impl + rule__Package_Impl__Group_5__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); } + (rule__Package_Impl__SpecAssignment_5_2)* + { after(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_5__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_5__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); } + RULE_END + { after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Package_Impl__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6__0__Impl + rule__Package_Impl__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); } + Dependencies + { after(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6__1__Impl + rule__Package_Impl__Group_6__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); } + LeftSquareBracket + { after(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6__2__Impl + rule__Package_Impl__Group_6__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); } + (rule__Package_Impl__DependencyAssignment_6_2) + { after(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6__3__Impl + rule__Package_Impl__Group_6__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); } + (rule__Package_Impl__Group_6_3__0)* + { after(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); } + RightSquareBracket + { after(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Package_Impl__Group_6_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6_3__0__Impl + rule__Package_Impl__Group_6_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); } + Comma + { after(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Package_Impl__Group_6_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__Group_6_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1()); } + (rule__Package_Impl__DependencyAssignment_6_3_1) + { after(grammarAccess.getPackage_ImplAccess().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().getAlternatives_3()); } + (rule__Node__Alternatives_3)* + { after(grammarAccess.getNodeAccess().getAlternatives_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_0__0__Impl + rule__Node__Group_3_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); } + Publishers + { after(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_0__1__Impl + rule__Node__Group_3_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_0__2__Impl + rule__Node__Group_3_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); } + (rule__Node__PublisherAssignment_3_0_2)* + { after(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_0__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_1__0__Impl + rule__Node__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); } + Subscribers + { after(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_1__1__Impl + rule__Node__Group_3_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_1__2__Impl + rule__Node__Group_3_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); } + (rule__Node__SubscriberAssignment_3_1_2)* + { after(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_1__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_2__0__Impl + rule__Node__Group_3_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); } + Serviceserver + { after(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_2__1__Impl + rule__Node__Group_3_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_2__2__Impl + rule__Node__Group_3_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); } + (rule__Node__ServiceserverAssignment_3_2_2)* + { after(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_2__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_3__0__Impl + rule__Node__Group_3_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); } + Serviceclient + { after(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_3__1__Impl + rule__Node__Group_3_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_3__2__Impl + rule__Node__Group_3_3__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); } + (rule__Node__ServiceclientAssignment_3_3_2)* + { after(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_3__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_3__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_4__0__Impl + rule__Node__Group_3_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); } + Actionserver + { after(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_4__1__Impl + rule__Node__Group_3_4__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_4__2__Impl + rule__Node__Group_3_4__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); } + (rule__Node__ActionserverAssignment_3_4_2)* + { after(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_4__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_4__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_5__0__Impl + rule__Node__Group_3_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); } + Actionclient + { after(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_5__1__Impl + rule__Node__Group_3_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_5__2__Impl + rule__Node__Group_3_5__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); } + (rule__Node__ActionclientAssignment_3_5_2)* + { after(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_5__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_5__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_6__0__Impl + rule__Node__Group_3_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); } + Parameters + { after(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_6__1__Impl + rule__Node__Group_3_6__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_6__2__Impl + rule__Node__Group_3_6__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); } + (rule__Node__ParameterAssignment_3_6_2)* + { after(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3_6__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3_6__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__TopicSpec__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__0__Impl + rule__TopicSpec__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); } + () + { after(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__1__Impl + rule__TopicSpec__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); } + Msg + { after(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__2__Impl + rule__TopicSpec__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); } + (rule__TopicSpec__NameAssignment_2) + { after(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__3__Impl + rule__TopicSpec__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__4__Impl + rule__TopicSpec__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); } + Message_1 + { after(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__5__Impl + rule__TopicSpec__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getGroup_5()); } + (rule__TopicSpec__Group_5__0)? + { after(grammarAccess.getTopicSpecAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); } + RULE_END + { after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__TopicSpec__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group_5__0__Impl + rule__TopicSpec__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); } + RULE_BEGIN + { after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group_5__1__Impl + rule__TopicSpec__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); } + (rule__TopicSpec__MessageAssignment_5_1) + { after(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__TopicSpec__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); } + RULE_END + { after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceSpec__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__0__Impl + rule__ServiceSpec__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); } + () + { after(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__1__Impl + rule__ServiceSpec__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); } + Srv + { after(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__2__Impl + rule__ServiceSpec__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); } + (rule__ServiceSpec__NameAssignment_2) + { after(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__3__Impl + rule__ServiceSpec__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__4__Impl + rule__ServiceSpec__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); } + Request + { after(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__5__Impl + rule__ServiceSpec__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getGroup_5()); } + (rule__ServiceSpec__Group_5__0)? + { after(grammarAccess.getServiceSpecAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__6__Impl + rule__ServiceSpec__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); } + Response + { after(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__7__Impl + rule__ServiceSpec__Group__8 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getGroup_7()); } + (rule__ServiceSpec__Group_7__0)? + { after(grammarAccess.getServiceSpecAccess().getGroup_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__8 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group__8__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group__8__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); } + RULE_END + { after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceSpec__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_5__0__Impl + rule__ServiceSpec__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); } + RULE_BEGIN + { after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_5__1__Impl + rule__ServiceSpec__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); } + (rule__ServiceSpec__RequestAssignment_5_1) + { after(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); } + RULE_END + { after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceSpec__Group_7__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_7__0__Impl + rule__ServiceSpec__Group_7__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_7__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); } + RULE_BEGIN + { after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_7__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_7__1__Impl + rule__ServiceSpec__Group_7__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_7__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); } + (rule__ServiceSpec__ResponseAssignment_7_1) + { after(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_7__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceSpec__Group_7__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__Group_7__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); } + RULE_END + { after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionSpec__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__0__Impl + rule__ActionSpec__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); } + () + { after(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__1__Impl + rule__ActionSpec__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getActionKeyword_1()); } + Action_1 + { after(grammarAccess.getActionSpecAccess().getActionKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__2__Impl + rule__ActionSpec__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getNameAssignment_2()); } + (rule__ActionSpec__NameAssignment_2) + { after(grammarAccess.getActionSpecAccess().getNameAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__3__Impl + rule__ActionSpec__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__4__Impl + rule__ActionSpec__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); } + Goal_1 + { after(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__5__Impl + rule__ActionSpec__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getGroup_5()); } + (rule__ActionSpec__Group_5__0)? + { after(grammarAccess.getActionSpecAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__6__Impl + rule__ActionSpec__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getResultKeyword_6()); } + Result_1 + { after(grammarAccess.getActionSpecAccess().getResultKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__7__Impl + rule__ActionSpec__Group__8 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getGroup_7()); } + (rule__ActionSpec__Group_7__0)? + { after(grammarAccess.getActionSpecAccess().getGroup_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__8 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__8__Impl + rule__ActionSpec__Group__9 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__8__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); } + Feedback_1 + { after(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__9 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__9__Impl + rule__ActionSpec__Group__10 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__9__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getGroup_9()); } + (rule__ActionSpec__Group_9__0)? + { after(grammarAccess.getActionSpecAccess().getGroup_9()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__10 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group__10__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group__10__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionSpec__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_5__0__Impl + rule__ActionSpec__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_5__1__Impl + rule__ActionSpec__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); } + (rule__ActionSpec__GoalAssignment_5_1) + { after(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionSpec__Group_7__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_7__0__Impl + rule__ActionSpec__Group_7__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_7__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_7__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_7__1__Impl + rule__ActionSpec__Group_7__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_7__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); } + (rule__ActionSpec__ResultAssignment_7_1) + { after(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_7__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_7__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_7__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionSpec__Group_9__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_9__0__Impl + rule__ActionSpec__Group_9__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_9__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_9__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_9__1__Impl + rule__ActionSpec__Group_9__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_9__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); } + (rule__ActionSpec__FeedbackAssignment_9_1) + { after(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_9__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionSpec__Group_9__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__Group_9__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__MessageDefinition__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__MessageDefinition__Group__0__Impl + rule__MessageDefinition__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__MessageDefinition__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); } + () + { after(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessageDefinition__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__MessageDefinition__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__MessageDefinition__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); } + (rule__MessageDefinition__MessagePartAssignment_1)* + { after(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); } +) +; +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_1 + { 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 + rule__Publisher__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getGroup_6()); } + (rule__Publisher__Group_6__0)? + { after(grammarAccess.getPublisherAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Publisher__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group_6__0__Impl + rule__Publisher__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); } + (rule__Publisher__NamespaceAssignment_6_1) + { after(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); } +) +; +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_1 + { 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 + rule__Subscriber__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getGroup_6()); } + (rule__Subscriber__Group_6__0)? + { after(grammarAccess.getSubscriberAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Subscriber__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group_6__0__Impl + rule__Subscriber__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); } + (rule__Subscriber__NamespaceAssignment_6_1) + { after(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceServer__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__0__Impl + rule__ServiceServer__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); } + () + { after(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__1__Impl + rule__ServiceServer__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getNameAssignment_1()); } + (rule__ServiceServer__NameAssignment_1) + { after(grammarAccess.getServiceServerAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__2__Impl + rule__ServiceServer__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getServiceServerAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__3__Impl + rule__ServiceServer__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__4__Impl + rule__ServiceServer__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__5__Impl + rule__ServiceServer__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); } + (rule__ServiceServer__ServiceAssignment_5) + { after(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__6__Impl + rule__ServiceServer__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getGroup_6()); } + (rule__ServiceServer__Group_6__0)? + { after(grammarAccess.getServiceServerAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceServer__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group_6__0__Impl + rule__ServiceServer__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceServer__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); } + (rule__ServiceServer__NamespaceAssignment_6_1) + { after(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceClient__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__0__Impl + rule__ServiceClient__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); } + () + { after(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__1__Impl + rule__ServiceClient__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getNameAssignment_1()); } + (rule__ServiceClient__NameAssignment_1) + { after(grammarAccess.getServiceClientAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__2__Impl + rule__ServiceClient__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getServiceClientAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__3__Impl + rule__ServiceClient__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__4__Impl + rule__ServiceClient__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__5__Impl + rule__ServiceClient__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); } + (rule__ServiceClient__ServiceAssignment_5) + { after(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__6__Impl + rule__ServiceClient__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getGroup_6()); } + (rule__ServiceClient__Group_6__0)? + { after(grammarAccess.getServiceClientAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ServiceClient__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group_6__0__Impl + rule__ServiceClient__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ServiceClient__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); } + (rule__ServiceClient__NamespaceAssignment_6_1) + { after(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionServer__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__0__Impl + rule__ActionServer__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getActionServerAction_0()); } + () + { after(grammarAccess.getActionServerAccess().getActionServerAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__1__Impl + rule__ActionServer__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getNameAssignment_1()); } + (rule__ActionServer__NameAssignment_1) + { after(grammarAccess.getActionServerAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__2__Impl + rule__ActionServer__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getActionServerAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__3__Impl + rule__ActionServer__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__4__Impl + rule__ActionServer__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getActionServerAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__5__Impl + rule__ActionServer__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getActionAssignment_5()); } + (rule__ActionServer__ActionAssignment_5) + { after(grammarAccess.getActionServerAccess().getActionAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__6__Impl + rule__ActionServer__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getGroup_6()); } + (rule__ActionServer__Group_6__0)? + { after(grammarAccess.getActionServerAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionServer__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group_6__0__Impl + rule__ActionServer__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionServer__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); } + (rule__ActionServer__NamespaceAssignment_6_1) + { after(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionClient__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__0__Impl + rule__ActionClient__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getActionClientAction_0()); } + () + { after(grammarAccess.getActionClientAccess().getActionClientAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__1__Impl + rule__ActionClient__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getNameAssignment_1()); } + (rule__ActionClient__NameAssignment_1) + { after(grammarAccess.getActionClientAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__2__Impl + rule__ActionClient__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getActionClientAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__3__Impl + rule__ActionClient__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__4__Impl + rule__ActionClient__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getActionClientAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__5__Impl + rule__ActionClient__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getActionAssignment_5()); } + (rule__ActionClient__ActionAssignment_5) + { after(grammarAccess.getActionClientAccess().getActionAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__6__Impl + rule__ActionClient__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getGroup_6()); } + (rule__ActionClient__Group_6__0)? + { after(grammarAccess.getActionClientAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ActionClient__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group_6__0__Impl + rule__ActionClient__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ActionClient__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); } + (rule__ActionClient__NamespaceAssignment_6_1) + { after(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); } +) +; +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__GlobalNamespace__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group__0__Impl + rule__GlobalNamespace__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); } + () + { after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group__1__Impl + rule__GlobalNamespace__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); } + GlobalNamespace + { after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); } + (rule__GlobalNamespace__Group_2__0)? + { after(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalNamespace__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2__0__Impl + rule__GlobalNamespace__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } + LeftSquareBracket + { after(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2__1__Impl + rule__GlobalNamespace__Group_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); } + (rule__GlobalNamespace__PartsAssignment_2_1) + { after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2__2__Impl + rule__GlobalNamespace__Group_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); } + (rule__GlobalNamespace__Group_2_2__0)* + { after(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); } + RightSquareBracket + { after(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalNamespace__Group_2_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2_2__0__Impl + rule__GlobalNamespace__Group_2_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); } + Comma + { after(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalNamespace__Group_2_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__Group_2_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); } + (rule__GlobalNamespace__PartsAssignment_2_2_1) + { after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelativeNamespace_Impl__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group__0__Impl + rule__RelativeNamespace_Impl__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); } + () + { after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group__1__Impl + rule__RelativeNamespace_Impl__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); } + RelativeNamespace + { after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); } + (rule__RelativeNamespace_Impl__Group_2__0)? + { after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelativeNamespace_Impl__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2__0__Impl + rule__RelativeNamespace_Impl__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); } + LeftSquareBracket + { after(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2__1__Impl + rule__RelativeNamespace_Impl__Group_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); } + (rule__RelativeNamespace_Impl__PartsAssignment_2_1) + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2__2__Impl + rule__RelativeNamespace_Impl__Group_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); } + (rule__RelativeNamespace_Impl__Group_2_2__0)* + { after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); } + RightSquareBracket + { after(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelativeNamespace_Impl__Group_2_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2_2__0__Impl + rule__RelativeNamespace_Impl__Group_2_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); } + Comma + { after(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelativeNamespace_Impl__Group_2_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__Group_2_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); } + (rule__RelativeNamespace_Impl__PartsAssignment_2_2_1) + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PrivateNamespace__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group__0__Impl + rule__PrivateNamespace__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); } + () + { after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group__1__Impl + rule__PrivateNamespace__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); } + PrivateNamespace + { after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); } + (rule__PrivateNamespace__Group_2__0)? + { after(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PrivateNamespace__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2__0__Impl + rule__PrivateNamespace__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } + LeftSquareBracket + { after(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2__1__Impl + rule__PrivateNamespace__Group_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); } + (rule__PrivateNamespace__PartsAssignment_2_1) + { after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2__2__Impl + rule__PrivateNamespace__Group_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); } + (rule__PrivateNamespace__Group_2_2__0)* + { after(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); } + RightSquareBracket + { after(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PrivateNamespace__Group_2_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2_2__0__Impl + rule__PrivateNamespace__Group_2_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); } + Comma + { after(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PrivateNamespace__Group_2_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__Group_2_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); } + (rule__PrivateNamespace__PartsAssignment_2_2_1) + { after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); } +) +; +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().getTypeKeyword_4()); } + Type + { after(grammarAccess.getParameterAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__5__Impl + rule__Parameter__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getTypeAssignment_5()); } + (rule__Parameter__TypeAssignment_5) + { after(grammarAccess.getParameterAccess().getTypeAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__6__Impl + rule__Parameter__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getGroup_6()); } + (rule__Parameter__Group_6__0)? + { after(grammarAccess.getParameterAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__7__Impl + rule__Parameter__Group__8 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__8 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__8__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__8__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); } + RightCurlyBracket + { after(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Parameter__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group_6__0__Impl + rule__Parameter__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getParameterAccess().getNsKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); } + (rule__Parameter__NamespaceAssignment_6_1) + { after(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterListType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__0__Impl + rule__ParameterListType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); } + () + { after(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__1__Impl + rule__ParameterListType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); } + List + { after(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__2__Impl + rule__ParameterListType__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); } + LeftSquareBracket + { after(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__3__Impl + rule__ParameterListType__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); } + (rule__ParameterListType__SequenceAssignment_3) + { after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__4__Impl + rule__ParameterListType__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getGroup_4()); } + (rule__ParameterListType__Group_4__0)* + { after(grammarAccess.getParameterListTypeAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); } + RightSquareBracket + { after(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterListType__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group_4__0__Impl + rule__ParameterListType__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); } + Comma + { after(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterListType__Group_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); } + (rule__ParameterListType__SequenceAssignment_4_1) + { after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStructType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__0__Impl + rule__ParameterStructType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); } + () + { after(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__1__Impl + rule__ParameterStructType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); } + Struct + { after(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__2__Impl + rule__ParameterStructType__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); } + LeftSquareBracket + { after(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__3__Impl + rule__ParameterStructType__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); } + (rule__ParameterStructType__ParameterstructypetmemberAssignment_3) + { after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__4__Impl + rule__ParameterStructType__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getGroup_4()); } + (rule__ParameterStructType__Group_4__0)* + { after(grammarAccess.getParameterStructTypeAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); } + RightSquareBracket + { after(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStructType__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group_4__0__Impl + rule__ParameterStructType__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); } + Comma + { after(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructType__Group_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); } + (rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1) + { after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterIntegerType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterIntegerType__Group__0__Impl + rule__ParameterIntegerType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); } + () + { after(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterIntegerType__Group__1__Impl + rule__ParameterIntegerType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); } + Integer + { after(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterIntegerType__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); } + (rule__ParameterIntegerType__Group_2__0)? + { after(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterIntegerType__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterIntegerType__Group_2__0__Impl + rule__ParameterIntegerType__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); } + Default + { after(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterIntegerType__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); } + (rule__ParameterIntegerType__DefaultAssignment_2_1) + { after(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStringType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStringType__Group__0__Impl + rule__ParameterStringType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); } + () + { after(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStringType__Group__1__Impl + rule__ParameterStringType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); } + String + { after(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStringType__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStringTypeAccess().getGroup_2()); } + (rule__ParameterStringType__Group_2__0)? + { after(grammarAccess.getParameterStringTypeAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStringType__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStringType__Group_2__0__Impl + rule__ParameterStringType__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); } + Default + { after(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStringType__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); } + (rule__ParameterStringType__DefaultAssignment_2_1) + { after(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterDoubleType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterDoubleType__Group__0__Impl + rule__ParameterDoubleType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); } + () + { after(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterDoubleType__Group__1__Impl + rule__ParameterDoubleType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); } + Double + { after(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterDoubleType__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); } + (rule__ParameterDoubleType__Group_2__0)? + { after(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterDoubleType__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterDoubleType__Group_2__0__Impl + rule__ParameterDoubleType__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); } + Default + { after(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterDoubleType__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); } + (rule__ParameterDoubleType__DefaultAssignment_2_1) + { after(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterBooleanType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBooleanType__Group__0__Impl + rule__ParameterBooleanType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); } + () + { after(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBooleanType__Group__1__Impl + rule__ParameterBooleanType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); } + Boolean + { after(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBooleanType__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); } + (rule__ParameterBooleanType__Group_2__0)? + { after(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterBooleanType__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBooleanType__Group_2__0__Impl + rule__ParameterBooleanType__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); } + Default + { after(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBooleanType__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); } + (rule__ParameterBooleanType__DefaultAssignment_2_1) + { after(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterBase64Type__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBase64Type__Group__0__Impl + rule__ParameterBase64Type__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); } + () + { after(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBase64Type__Group__1__Impl + rule__ParameterBase64Type__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); } + Base64 + { after(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBase64Type__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); } + (rule__ParameterBase64Type__Group_2__0)? + { after(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterBase64Type__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBase64Type__Group_2__0__Impl + rule__ParameterBase64Type__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); } + Default + { after(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterBase64Type__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); } + (rule__ParameterBase64Type__DefaultAssignment_2_1) + { after(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterArrayType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__0__Impl + rule__ParameterArrayType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); } + Array + { after(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__1__Impl + rule__ParameterArrayType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); } + RULE_BEGIN + { after(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__2__Impl + rule__ParameterArrayType__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); } + Type + { after(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__3__Impl + rule__ParameterArrayType__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); } + (rule__ParameterArrayType__TypeAssignment_3) + { after(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__4__Impl + rule__ParameterArrayType__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); } + (rule__ParameterArrayType__Group_4__0)? + { after(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); } + RULE_END + { after(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterArrayType__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group_4__0__Impl + rule__ParameterArrayType__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); } + Default + { after(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterArrayType__Group_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); } + (rule__ParameterArrayType__DefaultAssignment_4_1) + { after(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterList__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group__0__Impl + rule__ParameterList__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); } + () + { after(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group__1__Impl + rule__ParameterList__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); } + LeftSquareBracket + { after(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group__2__Impl + rule__ParameterList__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getValueAssignment_2()); } + (rule__ParameterList__ValueAssignment_2) + { after(grammarAccess.getParameterListAccess().getValueAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group__3__Impl + rule__ParameterList__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getGroup_3()); } + (rule__ParameterList__Group_3__0)* + { after(grammarAccess.getParameterListAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); } + RightSquareBracket + { after(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterList__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group_3__0__Impl + rule__ParameterList__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); } + Comma + { after(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterList__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); } + (rule__ParameterList__ValueAssignment_3_1) + { after(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterAny__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterAny__Group__0__Impl + rule__ParameterAny__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); } + () + { after(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterAny__Group__1__Impl + rule__ParameterAny__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); } + ParameterAny + { after(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterAny__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAnyAccess().getGroup_2()); } + (rule__ParameterAny__Group_2__0)? + { after(grammarAccess.getParameterAnyAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterAny__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterAny__Group_2__0__Impl + rule__ParameterAny__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); } + Value + { after(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterAny__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); } + (rule__ParameterAny__ValueAssignment_2_1) + { after(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStruct__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group__0__Impl + rule__ParameterStruct__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); } + () + { after(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getGroup_1()); } + (rule__ParameterStruct__Group_1__0)? + { after(grammarAccess.getParameterStructAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStruct__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1__0__Impl + rule__ParameterStruct__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); } + LeftSquareBracket + { after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1__1__Impl + rule__ParameterStruct__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); } + (rule__ParameterStruct__ValueAssignment_1_1) + { after(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1__2__Impl + rule__ParameterStruct__Group_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getGroup_1_2()); } + (rule__ParameterStruct__Group_1_2__0)* + { after(grammarAccess.getParameterStructAccess().getGroup_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); } + RightSquareBracket + { after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStruct__Group_1_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1_2__0__Impl + rule__ParameterStruct__Group_1_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); } + Comma + { after(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1_2__1__Impl + rule__ParameterStruct__Group_1_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); } + LeftSquareBracket + { after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1_2__2__Impl + rule__ParameterStruct__Group_1_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); } + (rule__ParameterStruct__ValueAssignment_1_2_2) + { after(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStruct__Group_1_2__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__Group_1_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); } + RightSquareBracket + { after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStructMember__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__0__Impl + rule__ParameterStructMember__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); } + ParameterStructMember + { after(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__1__Impl + rule__ParameterStructMember__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); } + (rule__ParameterStructMember__NameAssignment_1) + { after(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__2__Impl + rule__ParameterStructMember__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__3__Impl + rule__ParameterStructMember__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__4__Impl + rule__ParameterStructMember__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); } + (rule__ParameterStructMember__ValueAssignment_4) + { after(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructMember__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); } + RULE_END + { after(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParameterStructTypeMember__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructTypeMember__Group__0__Impl + rule__ParameterStructTypeMember__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructTypeMember__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); } + (rule__ParameterStructTypeMember__NameAssignment_0) + { after(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructTypeMember__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParameterStructTypeMember__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructTypeMember__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); } + (rule__ParameterStructTypeMember__TypeAssignment_1) + { after(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__MessagePart__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__MessagePart__Group__0__Impl + rule__MessagePart__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); } + (rule__MessagePart__TypeAssignment_0) + { after(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__MessagePart__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMessagePartAccess().getDataAssignment_1()); } + (rule__MessagePart__DataAssignment_1) + { after(grammarAccess.getMessagePartAccess().getDataAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Bool__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Bool__Group__0__Impl + rule__Bool__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Bool__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getBoolAccess().getBoolAction_0()); } + () + { after(grammarAccess.getBoolAccess().getBoolAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Bool__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Bool__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Bool__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getBoolAccess().getBoolKeyword_1()); } + Bool + { after(grammarAccess.getBoolAccess().getBoolKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int8__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int8__Group__0__Impl + rule__Int8__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt8Access().getInt8Action_0()); } + () + { after(grammarAccess.getInt8Access().getInt8Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int8__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt8Access().getInt8Keyword_1()); } + Int8 + { after(grammarAccess.getInt8Access().getInt8Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint8__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint8__Group__0__Impl + rule__Uint8__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint8Access().getUint8Action_0()); } + () + { after(grammarAccess.getUint8Access().getUint8Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint8__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint8Access().getUint8Keyword_1()); } + Uint8 + { after(grammarAccess.getUint8Access().getUint8Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int16__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int16__Group__0__Impl + rule__Int16__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt16Access().getInt16Action_0()); } + () + { after(grammarAccess.getInt16Access().getInt16Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int16__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt16Access().getInt16Keyword_1()); } + Int16 + { after(grammarAccess.getInt16Access().getInt16Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint16__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint16__Group__0__Impl + rule__Uint16__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint16Access().getUint16Action_0()); } + () + { after(grammarAccess.getUint16Access().getUint16Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint16__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint16Access().getUint16Keyword_1()); } + Uint16 + { after(grammarAccess.getUint16Access().getUint16Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int32__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int32__Group__0__Impl + rule__Int32__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt32Access().getInt32Action_0()); } + () + { after(grammarAccess.getInt32Access().getInt32Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int32__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt32Access().getInt32Keyword_1()); } + Int32 + { after(grammarAccess.getInt32Access().getInt32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint32__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint32__Group__0__Impl + rule__Uint32__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint32Access().getUint32Action_0()); } + () + { after(grammarAccess.getUint32Access().getUint32Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint32__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint32Access().getUint32Keyword_1()); } + Uint32 + { after(grammarAccess.getUint32Access().getUint32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int64__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int64__Group__0__Impl + rule__Int64__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt64Access().getInt64Action_0()); } + () + { after(grammarAccess.getInt64Access().getInt64Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int64__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt64Access().getInt64Keyword_1()); } + Int64 + { after(grammarAccess.getInt64Access().getInt64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint64__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint64__Group__0__Impl + rule__Uint64__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint64Access().getUint64Action_0()); } + () + { after(grammarAccess.getUint64Access().getUint64Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint64__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint64Access().getUint64Keyword_1()); } + Uint64 + { after(grammarAccess.getUint64Access().getUint64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Float32__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float32__Group__0__Impl + rule__Float32__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat32Access().getFloat32Action_0()); } + () + { after(grammarAccess.getFloat32Access().getFloat32Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float32__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat32Access().getFloat32Keyword_1()); } + Float32 + { after(grammarAccess.getFloat32Access().getFloat32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Float64__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float64__Group__0__Impl + rule__Float64__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat64Access().getFloat64Action_0()); } + () + { after(grammarAccess.getFloat64Access().getFloat64Action_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float64__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat64Access().getFloat64Keyword_1()); } + Float64 + { after(grammarAccess.getFloat64Access().getFloat64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__String0__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__String0__Group__0__Impl + rule__String0__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__String0__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getString0Access().getStringAction_0()); } + () + { after(grammarAccess.getString0Access().getStringAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__String0__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__String0__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__String0__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getString0Access().getStringKeyword_1()); } + String_1 + { after(grammarAccess.getString0Access().getStringKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Byte__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Byte__Group__0__Impl + rule__Byte__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Byte__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getByteAccess().getByteAction_0()); } + () + { after(grammarAccess.getByteAccess().getByteAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Byte__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Byte__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Byte__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getByteAccess().getByteKeyword_1()); } + Byte + { after(grammarAccess.getByteAccess().getByteKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Time__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Time__Group__0__Impl + rule__Time__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Time__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTimeAccess().getTimeAction_0()); } + () + { after(grammarAccess.getTimeAccess().getTimeAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Time__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Time__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Time__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTimeAccess().getTimeKeyword_1()); } + Time + { after(grammarAccess.getTimeAccess().getTimeKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Duration__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Duration__Group__0__Impl + rule__Duration__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Duration__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getDurationAccess().getDurationAction_0()); } + () + { after(grammarAccess.getDurationAccess().getDurationAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Duration__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Duration__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Duration__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getDurationAccess().getDurationKeyword_1()); } + Duration + { after(grammarAccess.getDurationAccess().getDurationKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__BoolArray__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__BoolArray__Group__0__Impl + rule__BoolArray__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__BoolArray__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); } + () + { after(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__BoolArray__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__BoolArray__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__BoolArray__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); } + Bool_1 + { after(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int8Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int8Array__Group__0__Impl + rule__Int8Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); } + () + { after(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int8Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int8Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); } + Int8_1 + { after(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint8Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint8Array__Group__0__Impl + rule__Uint8Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); } + () + { after(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint8Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint8Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); } + Uint8_1 + { after(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int16Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int16Array__Group__0__Impl + rule__Int16Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); } + () + { after(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int16Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int16Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); } + Int16_1 + { after(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint16Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint16Array__Group__0__Impl + rule__Uint16Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); } + () + { after(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint16Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint16Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); } + Uint16_1 + { after(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int32Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int32Array__Group__0__Impl + rule__Int32Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); } + () + { after(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int32Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int32Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); } + Int32_1 + { after(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint32Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint32Array__Group__0__Impl + rule__Uint32Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); } + () + { after(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint32Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint32Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); } + Uint32_1 + { after(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Int64Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int64Array__Group__0__Impl + rule__Int64Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); } + () + { after(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Int64Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Int64Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); } + Int64_1 + { after(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Uint64Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint64Array__Group__0__Impl + rule__Uint64Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); } + () + { after(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Uint64Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Uint64Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); } + Uint64_1 + { after(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Float32Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float32Array__Group__0__Impl + rule__Float32Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); } + () + { after(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float32Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Float32Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); } + Float32_1 + { after(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Float64Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float64Array__Group__0__Impl + rule__Float64Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); } + () + { after(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Float64Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Float64Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); } + Float64_1 + { after(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__String0Array__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__String0Array__Group__0__Impl + rule__String0Array__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__String0Array__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); } + () + { after(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__String0Array__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__String0Array__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__String0Array__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); } + String_2 + { after(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ByteArray__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ByteArray__Group__0__Impl + rule__ByteArray__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ByteArray__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); } + () + { after(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ByteArray__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ByteArray__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ByteArray__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getByteArrayAccess().getByteKeyword_1()); } + Byte_1 + { after(grammarAccess.getByteArrayAccess().getByteKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Header__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Header__Group__0__Impl + rule__Header__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Header__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getHeaderAccess().getHeaderAction_0()); } + () + { after(grammarAccess.getHeaderAccess().getHeaderAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Header__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Header__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Header__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); } + Header + { after(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ArrayTopicSpecRef__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ArrayTopicSpecRef__Group__0__Impl + rule__ArrayTopicSpecRef__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ArrayTopicSpecRef__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); } + (rule__ArrayTopicSpecRef__TopicSpecAssignment_0) + { after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ArrayTopicSpecRef__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ArrayTopicSpecRef__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ArrayTopicSpecRef__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); } + LeftSquareBracketRightSquareBracket + { after(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); } +) +; +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__Package_Impl__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); } + ruleRosNames + { after(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__FromGitRepoAssignment_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } + ruleEString + { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__SpecAssignment_5_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); } + ruleSpecBase + { after(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__DependencyAssignment_6_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); } + ruleDependency + { after(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Package_Impl__DependencyAssignment_6_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); } + ruleDependency + { after(grammarAccess.getPackage_ImplAccess().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_0_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); } + rulePublisher + { after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__SubscriberAssignment_3_1_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); } + ruleSubscriber + { after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__ServiceserverAssignment_3_2_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); } + ruleServiceServer + { after(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__ServiceclientAssignment_3_3_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); } + ruleServiceClient + { after(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__ActionserverAssignment_3_4_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); } + ruleActionServer + { after(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__ActionclientAssignment_3_5_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); } + ruleActionClient + { after(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__ParameterAssignment_3_6_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); } + ruleParameter + { after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__NameAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); } + (rule__TopicSpec__NameAlternatives_2_0) + { after(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpec__MessageAssignment_5_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__NameAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); } + ruleEString + { after(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__RequestAssignment_5_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceSpec__ResponseAssignment_7_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__NameAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); } + ruleEString + { after(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__GoalAssignment_5_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__ResultAssignment_7_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionSpec__FeedbackAssignment_9_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessageDefinition__MessagePartAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); } + ruleMessagePart + { after(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_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__Publisher__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_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__Subscriber__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__ServiceAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceServer__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__ServiceAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ServiceClient__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__ActionAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionServer__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__ActionAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ActionClient__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_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); +} + +rule__GlobalNamespace__PartsAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ruleGraphName + { after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalNamespace__PartsAssignment_2_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } + ruleGraphName + { after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__PartsAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ruleGraphName + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } + ruleGraphName + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__PartsAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ruleGraphName + { after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrivateNamespace__PartsAssignment_2_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } + ruleGraphName + { after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_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__Parameter__TypeAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); } + ruleParameterType + { after(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__NamespaceAssignment_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__SequenceAssignment_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); } + ruleParameterType + { after(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterListType__SequenceAssignment_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); } + ruleParameterType + { after(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__ParameterstructypetmemberAssignment_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); } + ruleParameterStructTypeMember + { after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); } + ruleParameterStructTypeMember + { after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterIntegerType__DefaultAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); } + ruleParameterInteger + { after(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStringType__DefaultAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); } + ruleParameterString + { after(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDoubleType__DefaultAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); } + ruleParameterDouble + { after(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBooleanType__DefaultAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); } + ruleParameterBoolean + { after(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64Type__DefaultAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); } + ruleParameterBase64 + { after(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__TypeAssignment_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); } + ruleParameterType + { after(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterArrayType__DefaultAssignment_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); } + ruleParameterList + { after(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__ValueAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); } + ruleParameterValue + { after(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterList__ValueAssignment_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); } + ruleParameterValue + { after(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterAny__ValueAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); } + ruleEString + { after(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterString__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); } + ruleEString + { after(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBase64__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); } + ruleBase64Binary + { after(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterInteger__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); } + ruleInteger0 + { after(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDouble__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); } + ruleDouble0 + { after(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterBoolean__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); } + ruleboolean0 + { after(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__ValueAssignment_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); } + ruleParameterStructMember + { after(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStruct__ValueAssignment_1_2_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); } + ruleParameterStructMember + { after(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterDate__ValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); } + ruleDateTime0 + { after(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructMember__ValueAssignment_4 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); } + ruleParameterValue + { after(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructTypeMember__NameAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); } + ruleEString + { after(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParameterStructTypeMember__TypeAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); } + ruleParameterType + { after(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__TypeAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); } + ruleAbstractType + { after(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__MessagePart__DataAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0()); } + (rule__MessagePart__DataAlternatives_1_0) + { after(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TopicSpecRef__TopicSpecAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); } + ( + { before(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_1()); } + ruleEString + { after(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_1()); } + ) + { after(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ArrayTopicSpecRef__TopicSpecAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); } + ( + { before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_0_1()); } + ruleEString + { after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_0_1()); } + ) + { after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_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..3754556cc --- /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,42176 @@ +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[] { + "", "", "", "", "ParameterStructMember", "ExternalDependency", "RelativeNamespace", "PrivateNamespace", "GlobalNamespace", "Serviceclient", "Serviceserver", "Actionclient", "Actionserver", "Dependencies", "AmentPackage", "ParameterAny", "FromGitRepo", "Subscribers", "Parameters", "Publishers", "Artifacts", "GraphName", "Feedback_1", "Float32_1", "Float64_1", "Response", "Duration", "Feedback", "Message_1", "Request", "String_2", "Uint16_1", "Uint32_1", "Uint64_1", "Boolean", "Integer", "Action_1", "Default", "Float32", "Float64", "Int16_1", "Int32_1", "Int64_1", "Message", "Result_1", "Service", "Uint8_1", "Array", "Base64", "Double", "Header", "String", "Struct", "Action", "Bool_1", "Byte_1", "Int8_1", "Result", "Specs", "String_1", "Uint16", "Uint32", "Uint64", "Goal_1", "Int16", "Int32", "Int64", "Node_1", "Type_1", "Uint8", "Value", "Date", "List", "Bool", "Byte", "Goal", "Int8", "Msg", "Name", "Node", "Srv", "Time", "Type", "Any", "Ns", "LeftSquareBracketRightSquareBracket", "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_DIGIT", "RULE_BINARY", "RULE_BOOLEAN", "RULE_DECINT", "RULE_DOUBLE", "RULE_DAY", "RULE_MONTH", "RULE_YEAR", "RULE_HOUR", "RULE_MIN_SEC", "RULE_DATE_TIME", "RULE_INT", "RULE_MESSAGE_ASIGMENT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER" + }; + public static final int Float32_1=23; + public static final int Node=79; + public static final int RULE_DATE_TIME=108; + public static final int Uint64_1=33; + public static final int String=51; + public static final int Int16=64; + public static final int Float32=38; + public static final int Goal=75; + public static final int Bool=73; + public static final int Uint16=60; + public static final int Boolean=34; + public static final int ExternalDependency=5; + public static final int Uint8=69; + public static final int Parameters=18; + public static final int RULE_ID=94; + public static final int AmentPackage=14; + public static final int Actionclient=11; + public static final int RULE_DIGIT=98; + public static final int GlobalNamespace=8; + public static final int Artifacts=20; + public static final int Node_1=67; + public static final int Int16_1=40; + public static final int Header=50; + public static final int RULE_INT=109; + public static final int Byte=74; + public static final int RULE_ML_COMMENT=111; + public static final int LeftSquareBracket=88; + public static final int Specs=58; + public static final int Base64=48; + public static final int Message_1=28; + public static final int Comma=86; + public static final int RULE_MESSAGE_ASIGMENT=110; + public static final int Goal_1=63; + public static final int LeftSquareBracketRightSquareBracket=85; + public static final int Int32=65; + public static final int Publishers=19; + public static final int Serviceserver=10; + public static final int RightCurlyBracket=90; + public static final int RULE_DECINT=101; + public static final int Uint32=61; + public static final int FromGitRepo=16; + public static final int Msg=77; + public static final int RULE_HOUR=106; + public static final int Int8=76; + public static final int Default=37; + public static final int Actionserver=12; + public static final int Int8_1=56; + public static final int Uint16_1=31; + public static final int Type=82; + public static final int Float64=39; + public static final int Int32_1=41; + public static final int Result_1=44; + public static final int RULE_BINARY=99; + public static final int String_1=59; + public static final int Subscribers=17; + public static final int String_2=30; + public static final int RULE_BEGIN=91; + public static final int RULE_DAY=103; + public static final int RULE_BOOLEAN=100; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=105; + public static final int Feedback_1=22; + public static final int Result=57; + public static final int Name=78; + public static final int RULE_MIN_SEC=107; + public static final int ParameterAny=15; + public static final int List=72; + public static final int Dependencies=13; + public static final int RightSquareBracket=89; + public static final int PrivateNamespace=7; + public static final int GraphName=21; + public static final int Byte_1=55; + public static final int Float64_1=24; + public static final int Duration=26; + public static final int Uint32_1=32; + public static final int Action_1=36; + public static final int Double=49; + public static final int Type_1=68; + public static final int Value=70; + public static final int Uint64=62; + public static final int Action=53; + public static final int RULE_END=92; + public static final int Message=43; + public static final int Time=81; + public static final int RULE_STRING=96; + public static final int Bool_1=54; + public static final int Any=83; + public static final int Struct=52; + public static final int RULE_SL_COMMENT=93; + public static final int Uint8_1=46; + public static final int RULE_DOUBLE=102; + public static final int Feedback=27; + public static final int ParameterStructMember=4; + public static final int Srv=80; + public static final int RULE_ROS_CONVENTION_A=95; + public static final int RULE_ROS_CONVENTION_PARAM=97; + public static final int Colon=87; + public static final int EOF=-1; + public static final int Ns=84; + public static final int RULE_WS=112; + public static final int Request=29; + public static final int Int64_1=42; + public static final int Service=45; + public static final int RULE_ANY_OTHER=113; + public static final int Date=71; + public static final int Response=25; + public static final int Integer=35; + public static final int Array=47; + public static final int Serviceclient=9; + public static final int Int64=66; + public static final int RULE_MONTH=104; + + // 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("LeftSquareBracketRightSquareBracket", "'[]'"); + tokenNameToValue.put("Any", "'Any'"); + tokenNameToValue.put("Ns", "'ns:'"); + tokenNameToValue.put("Date", "'Date'"); + tokenNameToValue.put("List", "'List'"); + tokenNameToValue.put("Bool", "'bool'"); + tokenNameToValue.put("Byte", "'byte'"); + tokenNameToValue.put("Goal", "'goal'"); + tokenNameToValue.put("Int8", "'int8'"); + tokenNameToValue.put("Msg", "'msg:'"); + tokenNameToValue.put("Name", "'name'"); + tokenNameToValue.put("Node", "'node'"); + tokenNameToValue.put("Srv", "'srv:'"); + tokenNameToValue.put("Time", "'time'"); + tokenNameToValue.put("Type", "'type'"); + tokenNameToValue.put("Goal_1", "'goal:'"); + tokenNameToValue.put("Int16", "'int16'"); + tokenNameToValue.put("Int32", "'int32'"); + tokenNameToValue.put("Int64", "'int64'"); + tokenNameToValue.put("Node_1", "'node:'"); + tokenNameToValue.put("Type_1", "'type:'"); + tokenNameToValue.put("Uint8", "'uint8'"); + tokenNameToValue.put("Value", "'value'"); + tokenNameToValue.put("Array", "'Array:'"); + tokenNameToValue.put("Base64", "'Base64'"); + tokenNameToValue.put("Double", "'Double'"); + tokenNameToValue.put("Header", "'Header'"); + tokenNameToValue.put("String", "'String'"); + tokenNameToValue.put("Struct", "'Struct'"); + tokenNameToValue.put("Action", "'action'"); + tokenNameToValue.put("Bool_1", "'bool[]'"); + tokenNameToValue.put("Byte_1", "'byte[]'"); + tokenNameToValue.put("Int8_1", "'int8[]'"); + tokenNameToValue.put("Result", "'result'"); + tokenNameToValue.put("Specs", "'specs:'"); + tokenNameToValue.put("String_1", "'string'"); + tokenNameToValue.put("Uint16", "'uint16'"); + tokenNameToValue.put("Uint32", "'uint32'"); + tokenNameToValue.put("Uint64", "'uint64'"); + tokenNameToValue.put("Boolean", "'Boolean'"); + tokenNameToValue.put("Integer", "'Integer'"); + tokenNameToValue.put("Action_1", "'action:'"); + tokenNameToValue.put("Default", "'default'"); + tokenNameToValue.put("Float32", "'float32'"); + tokenNameToValue.put("Float64", "'float64'"); + tokenNameToValue.put("Int16_1", "'int16[]'"); + tokenNameToValue.put("Int32_1", "'int32[]'"); + tokenNameToValue.put("Int64_1", "'int64[]'"); + tokenNameToValue.put("Message", "'message'"); + tokenNameToValue.put("Result_1", "'result:'"); + tokenNameToValue.put("Service", "'service'"); + tokenNameToValue.put("Uint8_1", "'uint8[]'"); + tokenNameToValue.put("Duration", "'duration'"); + tokenNameToValue.put("Feedback", "'feedback'"); + tokenNameToValue.put("Message_1", "'message:'"); + tokenNameToValue.put("Request", "'request:'"); + tokenNameToValue.put("String_2", "'string[]'"); + tokenNameToValue.put("Uint16_1", "'uint16[]'"); + tokenNameToValue.put("Uint32_1", "'uint32[]'"); + tokenNameToValue.put("Uint64_1", "'uint64[]'"); + tokenNameToValue.put("GraphName", "'GraphName'"); + tokenNameToValue.put("Feedback_1", "'feedback:'"); + tokenNameToValue.put("Float32_1", "'float32[]'"); + tokenNameToValue.put("Float64_1", "'float64[]'"); + tokenNameToValue.put("Response", "'response:'"); + tokenNameToValue.put("Artifacts", "'artifacts:'"); + tokenNameToValue.put("Parameters", "'parameters:'"); + tokenNameToValue.put("Publishers", "'publishers:'"); + tokenNameToValue.put("AmentPackage", "'AmentPackage'"); + tokenNameToValue.put("ParameterAny", "'ParameterAny'"); + tokenNameToValue.put("FromGitRepo", "'fromGitRepo:'"); + tokenNameToValue.put("Subscribers", "'subscribers:'"); + tokenNameToValue.put("Actionclient", "'actionclient:'"); + tokenNameToValue.put("Actionserver", "'actionserver:'"); + tokenNameToValue.put("Dependencies", "'dependencies:'"); + tokenNameToValue.put("Serviceclient", "'serviceclient:'"); + tokenNameToValue.put("Serviceserver", "'serviceserver:'"); + tokenNameToValue.put("GlobalNamespace", "'GlobalNamespace'"); + tokenNameToValue.put("PrivateNamespace", "'PrivateNamespace'"); + tokenNameToValue.put("RelativeNamespace", "'RelativeNamespace'"); + tokenNameToValue.put("ExternalDependency", "'ExternalDependency'"); + tokenNameToValue.put("ParameterStructMember", "'ParameterStructMember'"); + } + + 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 "entryRulePackage" + // InternalRos1Parser.g:142:1: entryRulePackage : rulePackage EOF ; + public final void entryRulePackage() throws RecognitionException { + try { + // InternalRos1Parser.g:143:1: ( rulePackage EOF ) + // InternalRos1Parser.g:144:1: rulePackage EOF + { + before(grammarAccess.getPackageRule()); + pushFollow(FOLLOW_1); + rulePackage(); + + state._fsp--; + + after(grammarAccess.getPackageRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulePackage" + + + // $ANTLR start "rulePackage" + // InternalRos1Parser.g:151:1: rulePackage : ( ruleCatkinPackage ) ; + public final void rulePackage() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:155:2: ( ( ruleCatkinPackage ) ) + // InternalRos1Parser.g:156:2: ( ruleCatkinPackage ) + { + // InternalRos1Parser.g:156:2: ( ruleCatkinPackage ) + // InternalRos1Parser.g:157:3: ruleCatkinPackage + { + before(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall()); + pushFollow(FOLLOW_2); + ruleCatkinPackage(); + + state._fsp--; + + after(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulePackage" + + + // $ANTLR start "entryRuleCatkinPackage" + // InternalRos1Parser.g:167:1: entryRuleCatkinPackage : ruleCatkinPackage EOF ; + public final void entryRuleCatkinPackage() throws RecognitionException { + try { + // InternalRos1Parser.g:168:1: ( ruleCatkinPackage EOF ) + // InternalRos1Parser.g:169: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:176:1: ruleCatkinPackage : ( ( rule__CatkinPackage__Group__0 ) ) ; + public final void ruleCatkinPackage() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:180:2: ( ( ( rule__CatkinPackage__Group__0 ) ) ) + // InternalRos1Parser.g:181:2: ( ( rule__CatkinPackage__Group__0 ) ) + { + // InternalRos1Parser.g:181:2: ( ( rule__CatkinPackage__Group__0 ) ) + // InternalRos1Parser.g:182:3: ( rule__CatkinPackage__Group__0 ) + { + before(grammarAccess.getCatkinPackageAccess().getGroup()); + // InternalRos1Parser.g:183:3: ( rule__CatkinPackage__Group__0 ) + // InternalRos1Parser.g:183: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 "entryRuleEString" + // InternalRos1Parser.g:192:1: entryRuleEString : ruleEString EOF ; + public final void entryRuleEString() throws RecognitionException { + try { + // InternalRos1Parser.g:193:1: ( ruleEString EOF ) + // InternalRos1Parser.g:194: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:201:1: ruleEString : ( ( rule__EString__Alternatives ) ) ; + public final void ruleEString() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:205:2: ( ( ( rule__EString__Alternatives ) ) ) + // InternalRos1Parser.g:206:2: ( ( rule__EString__Alternatives ) ) + { + // InternalRos1Parser.g:206:2: ( ( rule__EString__Alternatives ) ) + // InternalRos1Parser.g:207:3: ( rule__EString__Alternatives ) + { + before(grammarAccess.getEStringAccess().getAlternatives()); + // InternalRos1Parser.g:208:3: ( rule__EString__Alternatives ) + // InternalRos1Parser.g:208: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 "entryRuleRosNames" + // InternalRos1Parser.g:217:1: entryRuleRosNames : ruleRosNames EOF ; + public final void entryRuleRosNames() throws RecognitionException { + try { + // InternalRos1Parser.g:218:1: ( ruleRosNames EOF ) + // InternalRos1Parser.g:219: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:226:1: ruleRosNames : ( ( rule__RosNames__Alternatives ) ) ; + public final void ruleRosNames() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:230:2: ( ( ( rule__RosNames__Alternatives ) ) ) + // InternalRos1Parser.g:231:2: ( ( rule__RosNames__Alternatives ) ) + { + // InternalRos1Parser.g:231:2: ( ( rule__RosNames__Alternatives ) ) + // InternalRos1Parser.g:232:3: ( rule__RosNames__Alternatives ) + { + before(grammarAccess.getRosNamesAccess().getAlternatives()); + // InternalRos1Parser.g:233:3: ( rule__RosNames__Alternatives ) + // InternalRos1Parser.g:233: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 "entryRulePackage_Impl" + // InternalRos1Parser.g:242:1: entryRulePackage_Impl : rulePackage_Impl EOF ; + public final void entryRulePackage_Impl() throws RecognitionException { + try { + // InternalRos1Parser.g:243:1: ( rulePackage_Impl EOF ) + // InternalRos1Parser.g:244:1: rulePackage_Impl EOF + { + before(grammarAccess.getPackage_ImplRule()); + pushFollow(FOLLOW_1); + rulePackage_Impl(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulePackage_Impl" + + + // $ANTLR start "rulePackage_Impl" + // InternalRos1Parser.g:251:1: rulePackage_Impl : ( ( rule__Package_Impl__Group__0 ) ) ; + public final void rulePackage_Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:255:2: ( ( ( rule__Package_Impl__Group__0 ) ) ) + // InternalRos1Parser.g:256:2: ( ( rule__Package_Impl__Group__0 ) ) + { + // InternalRos1Parser.g:256:2: ( ( rule__Package_Impl__Group__0 ) ) + // InternalRos1Parser.g:257:3: ( rule__Package_Impl__Group__0 ) + { + before(grammarAccess.getPackage_ImplAccess().getGroup()); + // InternalRos1Parser.g:258:3: ( rule__Package_Impl__Group__0 ) + // InternalRos1Parser.g:258:4: rule__Package_Impl__Group__0 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulePackage_Impl" + + + // $ANTLR start "entryRuleArtifact" + // InternalRos1Parser.g:267:1: entryRuleArtifact : ruleArtifact EOF ; + public final void entryRuleArtifact() throws RecognitionException { + try { + // InternalRos1Parser.g:268:1: ( ruleArtifact EOF ) + // InternalRos1Parser.g:269: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:276:1: ruleArtifact : ( ( rule__Artifact__Group__0 ) ) ; + public final void ruleArtifact() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:280:2: ( ( ( rule__Artifact__Group__0 ) ) ) + // InternalRos1Parser.g:281:2: ( ( rule__Artifact__Group__0 ) ) + { + // InternalRos1Parser.g:281:2: ( ( rule__Artifact__Group__0 ) ) + // InternalRos1Parser.g:282:3: ( rule__Artifact__Group__0 ) + { + before(grammarAccess.getArtifactAccess().getGroup()); + // InternalRos1Parser.g:283:3: ( rule__Artifact__Group__0 ) + // InternalRos1Parser.g:283: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:292:1: entryRuleNode : ruleNode EOF ; + public final void entryRuleNode() throws RecognitionException { + try { + // InternalRos1Parser.g:293:1: ( ruleNode EOF ) + // InternalRos1Parser.g:294: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:301:1: ruleNode : ( ( rule__Node__Group__0 ) ) ; + public final void ruleNode() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:305:2: ( ( ( rule__Node__Group__0 ) ) ) + // InternalRos1Parser.g:306:2: ( ( rule__Node__Group__0 ) ) + { + // InternalRos1Parser.g:306:2: ( ( rule__Node__Group__0 ) ) + // InternalRos1Parser.g:307:3: ( rule__Node__Group__0 ) + { + before(grammarAccess.getNodeAccess().getGroup()); + // InternalRos1Parser.g:308:3: ( rule__Node__Group__0 ) + // InternalRos1Parser.g:308: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 "entryRuleSpecBase" + // InternalRos1Parser.g:317:1: entryRuleSpecBase : ruleSpecBase EOF ; + public final void entryRuleSpecBase() throws RecognitionException { + try { + // InternalRos1Parser.g:318:1: ( ruleSpecBase EOF ) + // InternalRos1Parser.g:319:1: ruleSpecBase EOF + { + before(grammarAccess.getSpecBaseRule()); + pushFollow(FOLLOW_1); + ruleSpecBase(); + + state._fsp--; + + after(grammarAccess.getSpecBaseRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleSpecBase" + + + // $ANTLR start "ruleSpecBase" + // InternalRos1Parser.g:326:1: ruleSpecBase : ( ( rule__SpecBase__Alternatives ) ) ; + public final void ruleSpecBase() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:330:2: ( ( ( rule__SpecBase__Alternatives ) ) ) + // InternalRos1Parser.g:331:2: ( ( rule__SpecBase__Alternatives ) ) + { + // InternalRos1Parser.g:331:2: ( ( rule__SpecBase__Alternatives ) ) + // InternalRos1Parser.g:332:3: ( rule__SpecBase__Alternatives ) + { + before(grammarAccess.getSpecBaseAccess().getAlternatives()); + // InternalRos1Parser.g:333:3: ( rule__SpecBase__Alternatives ) + // InternalRos1Parser.g:333:4: rule__SpecBase__Alternatives + { + pushFollow(FOLLOW_2); + rule__SpecBase__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getSpecBaseAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleSpecBase" + + + // $ANTLR start "entryRuleTopicSpec" + // InternalRos1Parser.g:342:1: entryRuleTopicSpec : ruleTopicSpec EOF ; + public final void entryRuleTopicSpec() throws RecognitionException { + try { + // InternalRos1Parser.g:343:1: ( ruleTopicSpec EOF ) + // InternalRos1Parser.g:344:1: ruleTopicSpec EOF + { + before(grammarAccess.getTopicSpecRule()); + pushFollow(FOLLOW_1); + ruleTopicSpec(); + + state._fsp--; + + after(grammarAccess.getTopicSpecRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleTopicSpec" + + + // $ANTLR start "ruleTopicSpec" + // InternalRos1Parser.g:351:1: ruleTopicSpec : ( ( rule__TopicSpec__Group__0 ) ) ; + public final void ruleTopicSpec() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:355:2: ( ( ( rule__TopicSpec__Group__0 ) ) ) + // InternalRos1Parser.g:356:2: ( ( rule__TopicSpec__Group__0 ) ) + { + // InternalRos1Parser.g:356:2: ( ( rule__TopicSpec__Group__0 ) ) + // InternalRos1Parser.g:357:3: ( rule__TopicSpec__Group__0 ) + { + before(grammarAccess.getTopicSpecAccess().getGroup()); + // InternalRos1Parser.g:358:3: ( rule__TopicSpec__Group__0 ) + // InternalRos1Parser.g:358:4: rule__TopicSpec__Group__0 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getTopicSpecAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleTopicSpec" + + + // $ANTLR start "entryRuleServiceSpec" + // InternalRos1Parser.g:367:1: entryRuleServiceSpec : ruleServiceSpec EOF ; + public final void entryRuleServiceSpec() throws RecognitionException { + try { + // InternalRos1Parser.g:368:1: ( ruleServiceSpec EOF ) + // InternalRos1Parser.g:369:1: ruleServiceSpec EOF + { + before(grammarAccess.getServiceSpecRule()); + pushFollow(FOLLOW_1); + ruleServiceSpec(); + + state._fsp--; + + after(grammarAccess.getServiceSpecRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleServiceSpec" + + + // $ANTLR start "ruleServiceSpec" + // InternalRos1Parser.g:376:1: ruleServiceSpec : ( ( rule__ServiceSpec__Group__0 ) ) ; + public final void ruleServiceSpec() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:380:2: ( ( ( rule__ServiceSpec__Group__0 ) ) ) + // InternalRos1Parser.g:381:2: ( ( rule__ServiceSpec__Group__0 ) ) + { + // InternalRos1Parser.g:381:2: ( ( rule__ServiceSpec__Group__0 ) ) + // InternalRos1Parser.g:382:3: ( rule__ServiceSpec__Group__0 ) + { + before(grammarAccess.getServiceSpecAccess().getGroup()); + // InternalRos1Parser.g:383:3: ( rule__ServiceSpec__Group__0 ) + // InternalRos1Parser.g:383:4: rule__ServiceSpec__Group__0 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceSpecAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleServiceSpec" + + + // $ANTLR start "entryRuleActionSpec" + // InternalRos1Parser.g:392:1: entryRuleActionSpec : ruleActionSpec EOF ; + public final void entryRuleActionSpec() throws RecognitionException { + try { + // InternalRos1Parser.g:393:1: ( ruleActionSpec EOF ) + // InternalRos1Parser.g:394:1: ruleActionSpec EOF + { + before(grammarAccess.getActionSpecRule()); + pushFollow(FOLLOW_1); + ruleActionSpec(); + + state._fsp--; + + after(grammarAccess.getActionSpecRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleActionSpec" + + + // $ANTLR start "ruleActionSpec" + // InternalRos1Parser.g:401:1: ruleActionSpec : ( ( rule__ActionSpec__Group__0 ) ) ; + public final void ruleActionSpec() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:405:2: ( ( ( rule__ActionSpec__Group__0 ) ) ) + // InternalRos1Parser.g:406:2: ( ( rule__ActionSpec__Group__0 ) ) + { + // InternalRos1Parser.g:406:2: ( ( rule__ActionSpec__Group__0 ) ) + // InternalRos1Parser.g:407:3: ( rule__ActionSpec__Group__0 ) + { + before(grammarAccess.getActionSpecAccess().getGroup()); + // InternalRos1Parser.g:408:3: ( rule__ActionSpec__Group__0 ) + // InternalRos1Parser.g:408:4: rule__ActionSpec__Group__0 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getActionSpecAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleActionSpec" + + + // $ANTLR start "entryRuleMessageDefinition" + // InternalRos1Parser.g:417:1: entryRuleMessageDefinition : ruleMessageDefinition EOF ; + public final void entryRuleMessageDefinition() throws RecognitionException { + try { + // InternalRos1Parser.g:418:1: ( ruleMessageDefinition EOF ) + // InternalRos1Parser.g:419:1: ruleMessageDefinition EOF + { + before(grammarAccess.getMessageDefinitionRule()); + pushFollow(FOLLOW_1); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getMessageDefinitionRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleMessageDefinition" + + + // $ANTLR start "ruleMessageDefinition" + // InternalRos1Parser.g:426:1: ruleMessageDefinition : ( ( rule__MessageDefinition__Group__0 ) ) ; + public final void ruleMessageDefinition() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:430:2: ( ( ( rule__MessageDefinition__Group__0 ) ) ) + // InternalRos1Parser.g:431:2: ( ( rule__MessageDefinition__Group__0 ) ) + { + // InternalRos1Parser.g:431:2: ( ( rule__MessageDefinition__Group__0 ) ) + // InternalRos1Parser.g:432:3: ( rule__MessageDefinition__Group__0 ) + { + before(grammarAccess.getMessageDefinitionAccess().getGroup()); + // InternalRos1Parser.g:433:3: ( rule__MessageDefinition__Group__0 ) + // InternalRos1Parser.g:433:4: rule__MessageDefinition__Group__0 + { + pushFollow(FOLLOW_2); + rule__MessageDefinition__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getMessageDefinitionAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleMessageDefinition" + + + // $ANTLR start "entryRulePublisher" + // InternalRos1Parser.g:442:1: entryRulePublisher : rulePublisher EOF ; + public final void entryRulePublisher() throws RecognitionException { + try { + // InternalRos1Parser.g:443:1: ( rulePublisher EOF ) + // InternalRos1Parser.g:444: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:451:1: rulePublisher : ( ( rule__Publisher__Group__0 ) ) ; + public final void rulePublisher() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:455:2: ( ( ( rule__Publisher__Group__0 ) ) ) + // InternalRos1Parser.g:456:2: ( ( rule__Publisher__Group__0 ) ) + { + // InternalRos1Parser.g:456:2: ( ( rule__Publisher__Group__0 ) ) + // InternalRos1Parser.g:457:3: ( rule__Publisher__Group__0 ) + { + before(grammarAccess.getPublisherAccess().getGroup()); + // InternalRos1Parser.g:458:3: ( rule__Publisher__Group__0 ) + // InternalRos1Parser.g:458: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:467:1: entryRuleSubscriber : ruleSubscriber EOF ; + public final void entryRuleSubscriber() throws RecognitionException { + try { + // InternalRos1Parser.g:468:1: ( ruleSubscriber EOF ) + // InternalRos1Parser.g:469: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:476:1: ruleSubscriber : ( ( rule__Subscriber__Group__0 ) ) ; + public final void ruleSubscriber() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:480:2: ( ( ( rule__Subscriber__Group__0 ) ) ) + // InternalRos1Parser.g:481:2: ( ( rule__Subscriber__Group__0 ) ) + { + // InternalRos1Parser.g:481:2: ( ( rule__Subscriber__Group__0 ) ) + // InternalRos1Parser.g:482:3: ( rule__Subscriber__Group__0 ) + { + before(grammarAccess.getSubscriberAccess().getGroup()); + // InternalRos1Parser.g:483:3: ( rule__Subscriber__Group__0 ) + // InternalRos1Parser.g:483: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 "entryRuleServiceServer" + // InternalRos1Parser.g:492:1: entryRuleServiceServer : ruleServiceServer EOF ; + public final void entryRuleServiceServer() throws RecognitionException { + try { + // InternalRos1Parser.g:493:1: ( ruleServiceServer EOF ) + // InternalRos1Parser.g:494:1: ruleServiceServer EOF + { + before(grammarAccess.getServiceServerRule()); + pushFollow(FOLLOW_1); + ruleServiceServer(); + + state._fsp--; + + after(grammarAccess.getServiceServerRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleServiceServer" + + + // $ANTLR start "ruleServiceServer" + // InternalRos1Parser.g:501:1: ruleServiceServer : ( ( rule__ServiceServer__Group__0 ) ) ; + public final void ruleServiceServer() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:505:2: ( ( ( rule__ServiceServer__Group__0 ) ) ) + // InternalRos1Parser.g:506:2: ( ( rule__ServiceServer__Group__0 ) ) + { + // InternalRos1Parser.g:506:2: ( ( rule__ServiceServer__Group__0 ) ) + // InternalRos1Parser.g:507:3: ( rule__ServiceServer__Group__0 ) + { + before(grammarAccess.getServiceServerAccess().getGroup()); + // InternalRos1Parser.g:508:3: ( rule__ServiceServer__Group__0 ) + // InternalRos1Parser.g:508:4: rule__ServiceServer__Group__0 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceServerAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleServiceServer" + + + // $ANTLR start "entryRuleServiceClient" + // InternalRos1Parser.g:517:1: entryRuleServiceClient : ruleServiceClient EOF ; + public final void entryRuleServiceClient() throws RecognitionException { + try { + // InternalRos1Parser.g:518:1: ( ruleServiceClient EOF ) + // InternalRos1Parser.g:519:1: ruleServiceClient EOF + { + before(grammarAccess.getServiceClientRule()); + pushFollow(FOLLOW_1); + ruleServiceClient(); + + state._fsp--; + + after(grammarAccess.getServiceClientRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleServiceClient" + + + // $ANTLR start "ruleServiceClient" + // InternalRos1Parser.g:526:1: ruleServiceClient : ( ( rule__ServiceClient__Group__0 ) ) ; + public final void ruleServiceClient() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:530:2: ( ( ( rule__ServiceClient__Group__0 ) ) ) + // InternalRos1Parser.g:531:2: ( ( rule__ServiceClient__Group__0 ) ) + { + // InternalRos1Parser.g:531:2: ( ( rule__ServiceClient__Group__0 ) ) + // InternalRos1Parser.g:532:3: ( rule__ServiceClient__Group__0 ) + { + before(grammarAccess.getServiceClientAccess().getGroup()); + // InternalRos1Parser.g:533:3: ( rule__ServiceClient__Group__0 ) + // InternalRos1Parser.g:533:4: rule__ServiceClient__Group__0 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceClientAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleServiceClient" + + + // $ANTLR start "entryRuleActionServer" + // InternalRos1Parser.g:542:1: entryRuleActionServer : ruleActionServer EOF ; + public final void entryRuleActionServer() throws RecognitionException { + try { + // InternalRos1Parser.g:543:1: ( ruleActionServer EOF ) + // InternalRos1Parser.g:544:1: ruleActionServer EOF + { + before(grammarAccess.getActionServerRule()); + pushFollow(FOLLOW_1); + ruleActionServer(); + + state._fsp--; + + after(grammarAccess.getActionServerRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleActionServer" + + + // $ANTLR start "ruleActionServer" + // InternalRos1Parser.g:551:1: ruleActionServer : ( ( rule__ActionServer__Group__0 ) ) ; + public final void ruleActionServer() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:555:2: ( ( ( rule__ActionServer__Group__0 ) ) ) + // InternalRos1Parser.g:556:2: ( ( rule__ActionServer__Group__0 ) ) + { + // InternalRos1Parser.g:556:2: ( ( rule__ActionServer__Group__0 ) ) + // InternalRos1Parser.g:557:3: ( rule__ActionServer__Group__0 ) + { + before(grammarAccess.getActionServerAccess().getGroup()); + // InternalRos1Parser.g:558:3: ( rule__ActionServer__Group__0 ) + // InternalRos1Parser.g:558:4: rule__ActionServer__Group__0 + { + pushFollow(FOLLOW_2); + rule__ActionServer__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getActionServerAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleActionServer" + + + // $ANTLR start "entryRuleActionClient" + // InternalRos1Parser.g:567:1: entryRuleActionClient : ruleActionClient EOF ; + public final void entryRuleActionClient() throws RecognitionException { + try { + // InternalRos1Parser.g:568:1: ( ruleActionClient EOF ) + // InternalRos1Parser.g:569:1: ruleActionClient EOF + { + before(grammarAccess.getActionClientRule()); + pushFollow(FOLLOW_1); + ruleActionClient(); + + state._fsp--; + + after(grammarAccess.getActionClientRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleActionClient" + + + // $ANTLR start "ruleActionClient" + // InternalRos1Parser.g:576:1: ruleActionClient : ( ( rule__ActionClient__Group__0 ) ) ; + public final void ruleActionClient() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:580:2: ( ( ( rule__ActionClient__Group__0 ) ) ) + // InternalRos1Parser.g:581:2: ( ( rule__ActionClient__Group__0 ) ) + { + // InternalRos1Parser.g:581:2: ( ( rule__ActionClient__Group__0 ) ) + // InternalRos1Parser.g:582:3: ( rule__ActionClient__Group__0 ) + { + before(grammarAccess.getActionClientAccess().getGroup()); + // InternalRos1Parser.g:583:3: ( rule__ActionClient__Group__0 ) + // InternalRos1Parser.g:583:4: rule__ActionClient__Group__0 + { + pushFollow(FOLLOW_2); + rule__ActionClient__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getActionClientAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleActionClient" + + + // $ANTLR start "entryRuleDependency" + // InternalRos1Parser.g:592:1: entryRuleDependency : ruleDependency EOF ; + public final void entryRuleDependency() throws RecognitionException { + try { + // InternalRos1Parser.g:593:1: ( ruleDependency EOF ) + // InternalRos1Parser.g:594: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:601:1: ruleDependency : ( ( rule__Dependency__Alternatives ) ) ; + public final void ruleDependency() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:605:2: ( ( ( rule__Dependency__Alternatives ) ) ) + // InternalRos1Parser.g:606:2: ( ( rule__Dependency__Alternatives ) ) + { + // InternalRos1Parser.g:606:2: ( ( rule__Dependency__Alternatives ) ) + // InternalRos1Parser.g:607:3: ( rule__Dependency__Alternatives ) + { + before(grammarAccess.getDependencyAccess().getAlternatives()); + // InternalRos1Parser.g:608:3: ( rule__Dependency__Alternatives ) + // InternalRos1Parser.g:608: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:617:1: entryRulePackageDependency : rulePackageDependency EOF ; + public final void entryRulePackageDependency() throws RecognitionException { + try { + // InternalRos1Parser.g:618:1: ( rulePackageDependency EOF ) + // InternalRos1Parser.g:619: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:626:1: rulePackageDependency : ( ( rule__PackageDependency__PackageAssignment ) ) ; + public final void rulePackageDependency() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:630:2: ( ( ( rule__PackageDependency__PackageAssignment ) ) ) + // InternalRos1Parser.g:631:2: ( ( rule__PackageDependency__PackageAssignment ) ) + { + // InternalRos1Parser.g:631:2: ( ( rule__PackageDependency__PackageAssignment ) ) + // InternalRos1Parser.g:632:3: ( rule__PackageDependency__PackageAssignment ) + { + before(grammarAccess.getPackageDependencyAccess().getPackageAssignment()); + // InternalRos1Parser.g:633:3: ( rule__PackageDependency__PackageAssignment ) + // InternalRos1Parser.g:633: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:642:1: entryRuleExternalDependency : ruleExternalDependency EOF ; + public final void entryRuleExternalDependency() throws RecognitionException { + try { + // InternalRos1Parser.g:643:1: ( ruleExternalDependency EOF ) + // InternalRos1Parser.g:644: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:651:1: ruleExternalDependency : ( ( rule__ExternalDependency__Group__0 ) ) ; + public final void ruleExternalDependency() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:655:2: ( ( ( rule__ExternalDependency__Group__0 ) ) ) + // InternalRos1Parser.g:656:2: ( ( rule__ExternalDependency__Group__0 ) ) + { + // InternalRos1Parser.g:656:2: ( ( rule__ExternalDependency__Group__0 ) ) + // InternalRos1Parser.g:657:3: ( rule__ExternalDependency__Group__0 ) + { + before(grammarAccess.getExternalDependencyAccess().getGroup()); + // InternalRos1Parser.g:658:3: ( rule__ExternalDependency__Group__0 ) + // InternalRos1Parser.g:658: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 "entryRuleNamespace" + // InternalRos1Parser.g:667:1: entryRuleNamespace : ruleNamespace EOF ; + public final void entryRuleNamespace() throws RecognitionException { + try { + // InternalRos1Parser.g:668:1: ( ruleNamespace EOF ) + // InternalRos1Parser.g:669:1: ruleNamespace EOF + { + before(grammarAccess.getNamespaceRule()); + pushFollow(FOLLOW_1); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getNamespaceRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleNamespace" + + + // $ANTLR start "ruleNamespace" + // InternalRos1Parser.g:676:1: ruleNamespace : ( ( rule__Namespace__Alternatives ) ) ; + public final void ruleNamespace() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:680:2: ( ( ( rule__Namespace__Alternatives ) ) ) + // InternalRos1Parser.g:681:2: ( ( rule__Namespace__Alternatives ) ) + { + // InternalRos1Parser.g:681:2: ( ( rule__Namespace__Alternatives ) ) + // InternalRos1Parser.g:682:3: ( rule__Namespace__Alternatives ) + { + before(grammarAccess.getNamespaceAccess().getAlternatives()); + // InternalRos1Parser.g:683:3: ( rule__Namespace__Alternatives ) + // InternalRos1Parser.g:683:4: rule__Namespace__Alternatives + { + pushFollow(FOLLOW_2); + rule__Namespace__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getNamespaceAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleNamespace" + + + // $ANTLR start "entryRuleGraphName" + // InternalRos1Parser.g:692:1: entryRuleGraphName : ruleGraphName EOF ; + public final void entryRuleGraphName() throws RecognitionException { + try { + // InternalRos1Parser.g:693:1: ( ruleGraphName EOF ) + // InternalRos1Parser.g:694:1: ruleGraphName EOF + { + before(grammarAccess.getGraphNameRule()); + pushFollow(FOLLOW_1); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getGraphNameRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleGraphName" + + + // $ANTLR start "ruleGraphName" + // InternalRos1Parser.g:701:1: ruleGraphName : ( GraphName ) ; + public final void ruleGraphName() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:705:2: ( ( GraphName ) ) + // InternalRos1Parser.g:706:2: ( GraphName ) + { + // InternalRos1Parser.g:706:2: ( GraphName ) + // InternalRos1Parser.g:707:3: GraphName + { + before(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + match(input,GraphName,FOLLOW_2); + after(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleGraphName" + + + // $ANTLR start "entryRuleGlobalNamespace" + // InternalRos1Parser.g:717:1: entryRuleGlobalNamespace : ruleGlobalNamespace EOF ; + public final void entryRuleGlobalNamespace() throws RecognitionException { + try { + // InternalRos1Parser.g:718:1: ( ruleGlobalNamespace EOF ) + // InternalRos1Parser.g:719:1: ruleGlobalNamespace EOF + { + before(grammarAccess.getGlobalNamespaceRule()); + pushFollow(FOLLOW_1); + ruleGlobalNamespace(); + + state._fsp--; + + after(grammarAccess.getGlobalNamespaceRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleGlobalNamespace" + + + // $ANTLR start "ruleGlobalNamespace" + // InternalRos1Parser.g:726:1: ruleGlobalNamespace : ( ( rule__GlobalNamespace__Group__0 ) ) ; + public final void ruleGlobalNamespace() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:730:2: ( ( ( rule__GlobalNamespace__Group__0 ) ) ) + // InternalRos1Parser.g:731:2: ( ( rule__GlobalNamespace__Group__0 ) ) + { + // InternalRos1Parser.g:731:2: ( ( rule__GlobalNamespace__Group__0 ) ) + // InternalRos1Parser.g:732:3: ( rule__GlobalNamespace__Group__0 ) + { + before(grammarAccess.getGlobalNamespaceAccess().getGroup()); + // InternalRos1Parser.g:733:3: ( rule__GlobalNamespace__Group__0 ) + // InternalRos1Parser.g:733:4: rule__GlobalNamespace__Group__0 + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getGlobalNamespaceAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleGlobalNamespace" + + + // $ANTLR start "entryRuleRelativeNamespace_Impl" + // InternalRos1Parser.g:742:1: entryRuleRelativeNamespace_Impl : ruleRelativeNamespace_Impl EOF ; + public final void entryRuleRelativeNamespace_Impl() throws RecognitionException { + try { + // InternalRos1Parser.g:743:1: ( ruleRelativeNamespace_Impl EOF ) + // InternalRos1Parser.g:744:1: ruleRelativeNamespace_Impl EOF + { + before(grammarAccess.getRelativeNamespace_ImplRule()); + pushFollow(FOLLOW_1); + ruleRelativeNamespace_Impl(); + + state._fsp--; + + after(grammarAccess.getRelativeNamespace_ImplRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleRelativeNamespace_Impl" + + + // $ANTLR start "ruleRelativeNamespace_Impl" + // InternalRos1Parser.g:751:1: ruleRelativeNamespace_Impl : ( ( rule__RelativeNamespace_Impl__Group__0 ) ) ; + public final void ruleRelativeNamespace_Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:755:2: ( ( ( rule__RelativeNamespace_Impl__Group__0 ) ) ) + // InternalRos1Parser.g:756:2: ( ( rule__RelativeNamespace_Impl__Group__0 ) ) + { + // InternalRos1Parser.g:756:2: ( ( rule__RelativeNamespace_Impl__Group__0 ) ) + // InternalRos1Parser.g:757:3: ( rule__RelativeNamespace_Impl__Group__0 ) + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup()); + // InternalRos1Parser.g:758:3: ( rule__RelativeNamespace_Impl__Group__0 ) + // InternalRos1Parser.g:758:4: rule__RelativeNamespace_Impl__Group__0 + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleRelativeNamespace_Impl" + + + // $ANTLR start "entryRulePrivateNamespace" + // InternalRos1Parser.g:767:1: entryRulePrivateNamespace : rulePrivateNamespace EOF ; + public final void entryRulePrivateNamespace() throws RecognitionException { + try { + // InternalRos1Parser.g:768:1: ( rulePrivateNamespace EOF ) + // InternalRos1Parser.g:769:1: rulePrivateNamespace EOF + { + before(grammarAccess.getPrivateNamespaceRule()); + pushFollow(FOLLOW_1); + rulePrivateNamespace(); + + state._fsp--; + + after(grammarAccess.getPrivateNamespaceRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulePrivateNamespace" + + + // $ANTLR start "rulePrivateNamespace" + // InternalRos1Parser.g:776:1: rulePrivateNamespace : ( ( rule__PrivateNamespace__Group__0 ) ) ; + public final void rulePrivateNamespace() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:780:2: ( ( ( rule__PrivateNamespace__Group__0 ) ) ) + // InternalRos1Parser.g:781:2: ( ( rule__PrivateNamespace__Group__0 ) ) + { + // InternalRos1Parser.g:781:2: ( ( rule__PrivateNamespace__Group__0 ) ) + // InternalRos1Parser.g:782:3: ( rule__PrivateNamespace__Group__0 ) + { + before(grammarAccess.getPrivateNamespaceAccess().getGroup()); + // InternalRos1Parser.g:783:3: ( rule__PrivateNamespace__Group__0 ) + // InternalRos1Parser.g:783:4: rule__PrivateNamespace__Group__0 + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getPrivateNamespaceAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulePrivateNamespace" + + + // $ANTLR start "entryRuleParameter" + // InternalRos1Parser.g:792:1: entryRuleParameter : ruleParameter EOF ; + public final void entryRuleParameter() throws RecognitionException { + try { + // InternalRos1Parser.g:793:1: ( ruleParameter EOF ) + // InternalRos1Parser.g:794: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:801:1: ruleParameter : ( ( rule__Parameter__Group__0 ) ) ; + public final void ruleParameter() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:805:2: ( ( ( rule__Parameter__Group__0 ) ) ) + // InternalRos1Parser.g:806:2: ( ( rule__Parameter__Group__0 ) ) + { + // InternalRos1Parser.g:806:2: ( ( rule__Parameter__Group__0 ) ) + // InternalRos1Parser.g:807:3: ( rule__Parameter__Group__0 ) + { + before(grammarAccess.getParameterAccess().getGroup()); + // InternalRos1Parser.g:808:3: ( rule__Parameter__Group__0 ) + // InternalRos1Parser.g:808: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 "entryRuleParameterType" + // InternalRos1Parser.g:817:1: entryRuleParameterType : ruleParameterType EOF ; + public final void entryRuleParameterType() throws RecognitionException { + try { + // InternalRos1Parser.g:818:1: ( ruleParameterType EOF ) + // InternalRos1Parser.g:819:1: ruleParameterType EOF + { + before(grammarAccess.getParameterTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterType" + + + // $ANTLR start "ruleParameterType" + // InternalRos1Parser.g:826:1: ruleParameterType : ( ( rule__ParameterType__Alternatives ) ) ; + public final void ruleParameterType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:830:2: ( ( ( rule__ParameterType__Alternatives ) ) ) + // InternalRos1Parser.g:831:2: ( ( rule__ParameterType__Alternatives ) ) + { + // InternalRos1Parser.g:831:2: ( ( rule__ParameterType__Alternatives ) ) + // InternalRos1Parser.g:832:3: ( rule__ParameterType__Alternatives ) + { + before(grammarAccess.getParameterTypeAccess().getAlternatives()); + // InternalRos1Parser.g:833:3: ( rule__ParameterType__Alternatives ) + // InternalRos1Parser.g:833:4: rule__ParameterType__Alternatives + { + pushFollow(FOLLOW_2); + rule__ParameterType__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterTypeAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterType" + + + // $ANTLR start "entryRuleParameterValue" + // InternalRos1Parser.g:842:1: entryRuleParameterValue : ruleParameterValue EOF ; + public final void entryRuleParameterValue() throws RecognitionException { + try { + // InternalRos1Parser.g:843:1: ( ruleParameterValue EOF ) + // InternalRos1Parser.g:844:1: ruleParameterValue EOF + { + before(grammarAccess.getParameterValueRule()); + pushFollow(FOLLOW_1); + ruleParameterValue(); + + state._fsp--; + + after(grammarAccess.getParameterValueRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterValue" + + + // $ANTLR start "ruleParameterValue" + // InternalRos1Parser.g:851:1: ruleParameterValue : ( ( rule__ParameterValue__Alternatives ) ) ; + public final void ruleParameterValue() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:855:2: ( ( ( rule__ParameterValue__Alternatives ) ) ) + // InternalRos1Parser.g:856:2: ( ( rule__ParameterValue__Alternatives ) ) + { + // InternalRos1Parser.g:856:2: ( ( rule__ParameterValue__Alternatives ) ) + // InternalRos1Parser.g:857:3: ( rule__ParameterValue__Alternatives ) + { + before(grammarAccess.getParameterValueAccess().getAlternatives()); + // InternalRos1Parser.g:858:3: ( rule__ParameterValue__Alternatives ) + // InternalRos1Parser.g:858:4: rule__ParameterValue__Alternatives + { + pushFollow(FOLLOW_2); + rule__ParameterValue__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterValueAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterValue" + + + // $ANTLR start "entryRuleParameterListType" + // InternalRos1Parser.g:867:1: entryRuleParameterListType : ruleParameterListType EOF ; + public final void entryRuleParameterListType() throws RecognitionException { + try { + // InternalRos1Parser.g:868:1: ( ruleParameterListType EOF ) + // InternalRos1Parser.g:869:1: ruleParameterListType EOF + { + before(grammarAccess.getParameterListTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterListType(); + + state._fsp--; + + after(grammarAccess.getParameterListTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterListType" + + + // $ANTLR start "ruleParameterListType" + // InternalRos1Parser.g:876:1: ruleParameterListType : ( ( rule__ParameterListType__Group__0 ) ) ; + public final void ruleParameterListType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:880:2: ( ( ( rule__ParameterListType__Group__0 ) ) ) + // InternalRos1Parser.g:881:2: ( ( rule__ParameterListType__Group__0 ) ) + { + // InternalRos1Parser.g:881:2: ( ( rule__ParameterListType__Group__0 ) ) + // InternalRos1Parser.g:882:3: ( rule__ParameterListType__Group__0 ) + { + before(grammarAccess.getParameterListTypeAccess().getGroup()); + // InternalRos1Parser.g:883:3: ( rule__ParameterListType__Group__0 ) + // InternalRos1Parser.g:883:4: rule__ParameterListType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterListType" + + + // $ANTLR start "entryRuleParameterStructType" + // InternalRos1Parser.g:892:1: entryRuleParameterStructType : ruleParameterStructType EOF ; + public final void entryRuleParameterStructType() throws RecognitionException { + try { + // InternalRos1Parser.g:893:1: ( ruleParameterStructType EOF ) + // InternalRos1Parser.g:894:1: ruleParameterStructType EOF + { + before(grammarAccess.getParameterStructTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterStructType(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterStructType" + + + // $ANTLR start "ruleParameterStructType" + // InternalRos1Parser.g:901:1: ruleParameterStructType : ( ( rule__ParameterStructType__Group__0 ) ) ; + public final void ruleParameterStructType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:905:2: ( ( ( rule__ParameterStructType__Group__0 ) ) ) + // InternalRos1Parser.g:906:2: ( ( rule__ParameterStructType__Group__0 ) ) + { + // InternalRos1Parser.g:906:2: ( ( rule__ParameterStructType__Group__0 ) ) + // InternalRos1Parser.g:907:3: ( rule__ParameterStructType__Group__0 ) + { + before(grammarAccess.getParameterStructTypeAccess().getGroup()); + // InternalRos1Parser.g:908:3: ( rule__ParameterStructType__Group__0 ) + // InternalRos1Parser.g:908:4: rule__ParameterStructType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterStructType" + + + // $ANTLR start "entryRuleParameterIntegerType" + // InternalRos1Parser.g:917:1: entryRuleParameterIntegerType : ruleParameterIntegerType EOF ; + public final void entryRuleParameterIntegerType() throws RecognitionException { + try { + // InternalRos1Parser.g:918:1: ( ruleParameterIntegerType EOF ) + // InternalRos1Parser.g:919:1: ruleParameterIntegerType EOF + { + before(grammarAccess.getParameterIntegerTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterIntegerType(); + + state._fsp--; + + after(grammarAccess.getParameterIntegerTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterIntegerType" + + + // $ANTLR start "ruleParameterIntegerType" + // InternalRos1Parser.g:926:1: ruleParameterIntegerType : ( ( rule__ParameterIntegerType__Group__0 ) ) ; + public final void ruleParameterIntegerType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:930:2: ( ( ( rule__ParameterIntegerType__Group__0 ) ) ) + // InternalRos1Parser.g:931:2: ( ( rule__ParameterIntegerType__Group__0 ) ) + { + // InternalRos1Parser.g:931:2: ( ( rule__ParameterIntegerType__Group__0 ) ) + // InternalRos1Parser.g:932:3: ( rule__ParameterIntegerType__Group__0 ) + { + before(grammarAccess.getParameterIntegerTypeAccess().getGroup()); + // InternalRos1Parser.g:933:3: ( rule__ParameterIntegerType__Group__0 ) + // InternalRos1Parser.g:933:4: rule__ParameterIntegerType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterIntegerTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterIntegerType" + + + // $ANTLR start "entryRuleParameterStringType" + // InternalRos1Parser.g:942:1: entryRuleParameterStringType : ruleParameterStringType EOF ; + public final void entryRuleParameterStringType() throws RecognitionException { + try { + // InternalRos1Parser.g:943:1: ( ruleParameterStringType EOF ) + // InternalRos1Parser.g:944:1: ruleParameterStringType EOF + { + before(grammarAccess.getParameterStringTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterStringType(); + + state._fsp--; + + after(grammarAccess.getParameterStringTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterStringType" + + + // $ANTLR start "ruleParameterStringType" + // InternalRos1Parser.g:951:1: ruleParameterStringType : ( ( rule__ParameterStringType__Group__0 ) ) ; + public final void ruleParameterStringType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:955:2: ( ( ( rule__ParameterStringType__Group__0 ) ) ) + // InternalRos1Parser.g:956:2: ( ( rule__ParameterStringType__Group__0 ) ) + { + // InternalRos1Parser.g:956:2: ( ( rule__ParameterStringType__Group__0 ) ) + // InternalRos1Parser.g:957:3: ( rule__ParameterStringType__Group__0 ) + { + before(grammarAccess.getParameterStringTypeAccess().getGroup()); + // InternalRos1Parser.g:958:3: ( rule__ParameterStringType__Group__0 ) + // InternalRos1Parser.g:958:4: rule__ParameterStringType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStringTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterStringType" + + + // $ANTLR start "entryRuleParameterDoubleType" + // InternalRos1Parser.g:967:1: entryRuleParameterDoubleType : ruleParameterDoubleType EOF ; + public final void entryRuleParameterDoubleType() throws RecognitionException { + try { + // InternalRos1Parser.g:968:1: ( ruleParameterDoubleType EOF ) + // InternalRos1Parser.g:969:1: ruleParameterDoubleType EOF + { + before(grammarAccess.getParameterDoubleTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterDoubleType(); + + state._fsp--; + + after(grammarAccess.getParameterDoubleTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterDoubleType" + + + // $ANTLR start "ruleParameterDoubleType" + // InternalRos1Parser.g:976:1: ruleParameterDoubleType : ( ( rule__ParameterDoubleType__Group__0 ) ) ; + public final void ruleParameterDoubleType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:980:2: ( ( ( rule__ParameterDoubleType__Group__0 ) ) ) + // InternalRos1Parser.g:981:2: ( ( rule__ParameterDoubleType__Group__0 ) ) + { + // InternalRos1Parser.g:981:2: ( ( rule__ParameterDoubleType__Group__0 ) ) + // InternalRos1Parser.g:982:3: ( rule__ParameterDoubleType__Group__0 ) + { + before(grammarAccess.getParameterDoubleTypeAccess().getGroup()); + // InternalRos1Parser.g:983:3: ( rule__ParameterDoubleType__Group__0 ) + // InternalRos1Parser.g:983:4: rule__ParameterDoubleType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterDoubleTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterDoubleType" + + + // $ANTLR start "entryRuleParameterBooleanType" + // InternalRos1Parser.g:992:1: entryRuleParameterBooleanType : ruleParameterBooleanType EOF ; + public final void entryRuleParameterBooleanType() throws RecognitionException { + try { + // InternalRos1Parser.g:993:1: ( ruleParameterBooleanType EOF ) + // InternalRos1Parser.g:994:1: ruleParameterBooleanType EOF + { + before(grammarAccess.getParameterBooleanTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterBooleanType(); + + state._fsp--; + + after(grammarAccess.getParameterBooleanTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterBooleanType" + + + // $ANTLR start "ruleParameterBooleanType" + // InternalRos1Parser.g:1001:1: ruleParameterBooleanType : ( ( rule__ParameterBooleanType__Group__0 ) ) ; + public final void ruleParameterBooleanType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1005:2: ( ( ( rule__ParameterBooleanType__Group__0 ) ) ) + // InternalRos1Parser.g:1006:2: ( ( rule__ParameterBooleanType__Group__0 ) ) + { + // InternalRos1Parser.g:1006:2: ( ( rule__ParameterBooleanType__Group__0 ) ) + // InternalRos1Parser.g:1007:3: ( rule__ParameterBooleanType__Group__0 ) + { + before(grammarAccess.getParameterBooleanTypeAccess().getGroup()); + // InternalRos1Parser.g:1008:3: ( rule__ParameterBooleanType__Group__0 ) + // InternalRos1Parser.g:1008:4: rule__ParameterBooleanType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBooleanTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterBooleanType" + + + // $ANTLR start "entryRuleParameterBase64Type" + // InternalRos1Parser.g:1017:1: entryRuleParameterBase64Type : ruleParameterBase64Type EOF ; + public final void entryRuleParameterBase64Type() throws RecognitionException { + try { + // InternalRos1Parser.g:1018:1: ( ruleParameterBase64Type EOF ) + // InternalRos1Parser.g:1019:1: ruleParameterBase64Type EOF + { + before(grammarAccess.getParameterBase64TypeRule()); + pushFollow(FOLLOW_1); + ruleParameterBase64Type(); + + state._fsp--; + + after(grammarAccess.getParameterBase64TypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterBase64Type" + + + // $ANTLR start "ruleParameterBase64Type" + // InternalRos1Parser.g:1026:1: ruleParameterBase64Type : ( ( rule__ParameterBase64Type__Group__0 ) ) ; + public final void ruleParameterBase64Type() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1030:2: ( ( ( rule__ParameterBase64Type__Group__0 ) ) ) + // InternalRos1Parser.g:1031:2: ( ( rule__ParameterBase64Type__Group__0 ) ) + { + // InternalRos1Parser.g:1031:2: ( ( rule__ParameterBase64Type__Group__0 ) ) + // InternalRos1Parser.g:1032:3: ( rule__ParameterBase64Type__Group__0 ) + { + before(grammarAccess.getParameterBase64TypeAccess().getGroup()); + // InternalRos1Parser.g:1033:3: ( rule__ParameterBase64Type__Group__0 ) + // InternalRos1Parser.g:1033:4: rule__ParameterBase64Type__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBase64TypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterBase64Type" + + + // $ANTLR start "entryRuleParameterArrayType" + // InternalRos1Parser.g:1042:1: entryRuleParameterArrayType : ruleParameterArrayType EOF ; + public final void entryRuleParameterArrayType() throws RecognitionException { + try { + // InternalRos1Parser.g:1043:1: ( ruleParameterArrayType EOF ) + // InternalRos1Parser.g:1044:1: ruleParameterArrayType EOF + { + before(grammarAccess.getParameterArrayTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterArrayType(); + + state._fsp--; + + after(grammarAccess.getParameterArrayTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterArrayType" + + + // $ANTLR start "ruleParameterArrayType" + // InternalRos1Parser.g:1051:1: ruleParameterArrayType : ( ( rule__ParameterArrayType__Group__0 ) ) ; + public final void ruleParameterArrayType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1055:2: ( ( ( rule__ParameterArrayType__Group__0 ) ) ) + // InternalRos1Parser.g:1056:2: ( ( rule__ParameterArrayType__Group__0 ) ) + { + // InternalRos1Parser.g:1056:2: ( ( rule__ParameterArrayType__Group__0 ) ) + // InternalRos1Parser.g:1057:3: ( rule__ParameterArrayType__Group__0 ) + { + before(grammarAccess.getParameterArrayTypeAccess().getGroup()); + // InternalRos1Parser.g:1058:3: ( rule__ParameterArrayType__Group__0 ) + // InternalRos1Parser.g:1058:4: rule__ParameterArrayType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterArrayTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterArrayType" + + + // $ANTLR start "entryRuleParameterList" + // InternalRos1Parser.g:1067:1: entryRuleParameterList : ruleParameterList EOF ; + public final void entryRuleParameterList() throws RecognitionException { + try { + // InternalRos1Parser.g:1068:1: ( ruleParameterList EOF ) + // InternalRos1Parser.g:1069:1: ruleParameterList EOF + { + before(grammarAccess.getParameterListRule()); + pushFollow(FOLLOW_1); + ruleParameterList(); + + state._fsp--; + + after(grammarAccess.getParameterListRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterList" + + + // $ANTLR start "ruleParameterList" + // InternalRos1Parser.g:1076:1: ruleParameterList : ( ( rule__ParameterList__Group__0 ) ) ; + public final void ruleParameterList() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1080:2: ( ( ( rule__ParameterList__Group__0 ) ) ) + // InternalRos1Parser.g:1081:2: ( ( rule__ParameterList__Group__0 ) ) + { + // InternalRos1Parser.g:1081:2: ( ( rule__ParameterList__Group__0 ) ) + // InternalRos1Parser.g:1082:3: ( rule__ParameterList__Group__0 ) + { + before(grammarAccess.getParameterListAccess().getGroup()); + // InternalRos1Parser.g:1083:3: ( rule__ParameterList__Group__0 ) + // InternalRos1Parser.g:1083:4: rule__ParameterList__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterList__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterList" + + + // $ANTLR start "entryRuleParameterAny" + // InternalRos1Parser.g:1092:1: entryRuleParameterAny : ruleParameterAny EOF ; + public final void entryRuleParameterAny() throws RecognitionException { + try { + // InternalRos1Parser.g:1093:1: ( ruleParameterAny EOF ) + // InternalRos1Parser.g:1094:1: ruleParameterAny EOF + { + before(grammarAccess.getParameterAnyRule()); + pushFollow(FOLLOW_1); + ruleParameterAny(); + + state._fsp--; + + after(grammarAccess.getParameterAnyRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterAny" + + + // $ANTLR start "ruleParameterAny" + // InternalRos1Parser.g:1101:1: ruleParameterAny : ( ( rule__ParameterAny__Group__0 ) ) ; + public final void ruleParameterAny() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1105:2: ( ( ( rule__ParameterAny__Group__0 ) ) ) + // InternalRos1Parser.g:1106:2: ( ( rule__ParameterAny__Group__0 ) ) + { + // InternalRos1Parser.g:1106:2: ( ( rule__ParameterAny__Group__0 ) ) + // InternalRos1Parser.g:1107:3: ( rule__ParameterAny__Group__0 ) + { + before(grammarAccess.getParameterAnyAccess().getGroup()); + // InternalRos1Parser.g:1108:3: ( rule__ParameterAny__Group__0 ) + // InternalRos1Parser.g:1108:4: rule__ParameterAny__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterAny__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAnyAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterAny" + + + // $ANTLR start "entryRuleParameterString" + // InternalRos1Parser.g:1117:1: entryRuleParameterString : ruleParameterString EOF ; + public final void entryRuleParameterString() throws RecognitionException { + try { + // InternalRos1Parser.g:1118:1: ( ruleParameterString EOF ) + // InternalRos1Parser.g:1119:1: ruleParameterString EOF + { + before(grammarAccess.getParameterStringRule()); + pushFollow(FOLLOW_1); + ruleParameterString(); + + state._fsp--; + + after(grammarAccess.getParameterStringRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterString" + + + // $ANTLR start "ruleParameterString" + // InternalRos1Parser.g:1126:1: ruleParameterString : ( ( rule__ParameterString__ValueAssignment ) ) ; + public final void ruleParameterString() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1130:2: ( ( ( rule__ParameterString__ValueAssignment ) ) ) + // InternalRos1Parser.g:1131:2: ( ( rule__ParameterString__ValueAssignment ) ) + { + // InternalRos1Parser.g:1131:2: ( ( rule__ParameterString__ValueAssignment ) ) + // InternalRos1Parser.g:1132:3: ( rule__ParameterString__ValueAssignment ) + { + before(grammarAccess.getParameterStringAccess().getValueAssignment()); + // InternalRos1Parser.g:1133:3: ( rule__ParameterString__ValueAssignment ) + // InternalRos1Parser.g:1133:4: rule__ParameterString__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterString__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStringAccess().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterString" + + + // $ANTLR start "entryRuleParameterBase64" + // InternalRos1Parser.g:1142:1: entryRuleParameterBase64 : ruleParameterBase64 EOF ; + public final void entryRuleParameterBase64() throws RecognitionException { + try { + // InternalRos1Parser.g:1143:1: ( ruleParameterBase64 EOF ) + // InternalRos1Parser.g:1144:1: ruleParameterBase64 EOF + { + before(grammarAccess.getParameterBase64Rule()); + pushFollow(FOLLOW_1); + ruleParameterBase64(); + + state._fsp--; + + after(grammarAccess.getParameterBase64Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterBase64" + + + // $ANTLR start "ruleParameterBase64" + // InternalRos1Parser.g:1151:1: ruleParameterBase64 : ( ( rule__ParameterBase64__ValueAssignment ) ) ; + public final void ruleParameterBase64() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1155:2: ( ( ( rule__ParameterBase64__ValueAssignment ) ) ) + // InternalRos1Parser.g:1156:2: ( ( rule__ParameterBase64__ValueAssignment ) ) + { + // InternalRos1Parser.g:1156:2: ( ( rule__ParameterBase64__ValueAssignment ) ) + // InternalRos1Parser.g:1157:3: ( rule__ParameterBase64__ValueAssignment ) + { + before(grammarAccess.getParameterBase64Access().getValueAssignment()); + // InternalRos1Parser.g:1158:3: ( rule__ParameterBase64__ValueAssignment ) + // InternalRos1Parser.g:1158:4: rule__ParameterBase64__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterBase64__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBase64Access().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterBase64" + + + // $ANTLR start "entryRuleParameterInteger" + // InternalRos1Parser.g:1167:1: entryRuleParameterInteger : ruleParameterInteger EOF ; + public final void entryRuleParameterInteger() throws RecognitionException { + try { + // InternalRos1Parser.g:1168:1: ( ruleParameterInteger EOF ) + // InternalRos1Parser.g:1169:1: ruleParameterInteger EOF + { + before(grammarAccess.getParameterIntegerRule()); + pushFollow(FOLLOW_1); + ruleParameterInteger(); + + state._fsp--; + + after(grammarAccess.getParameterIntegerRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterInteger" + + + // $ANTLR start "ruleParameterInteger" + // InternalRos1Parser.g:1176:1: ruleParameterInteger : ( ( rule__ParameterInteger__ValueAssignment ) ) ; + public final void ruleParameterInteger() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1180:2: ( ( ( rule__ParameterInteger__ValueAssignment ) ) ) + // InternalRos1Parser.g:1181:2: ( ( rule__ParameterInteger__ValueAssignment ) ) + { + // InternalRos1Parser.g:1181:2: ( ( rule__ParameterInteger__ValueAssignment ) ) + // InternalRos1Parser.g:1182:3: ( rule__ParameterInteger__ValueAssignment ) + { + before(grammarAccess.getParameterIntegerAccess().getValueAssignment()); + // InternalRos1Parser.g:1183:3: ( rule__ParameterInteger__ValueAssignment ) + // InternalRos1Parser.g:1183:4: rule__ParameterInteger__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterInteger__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterIntegerAccess().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterInteger" + + + // $ANTLR start "entryRuleParameterDouble" + // InternalRos1Parser.g:1192:1: entryRuleParameterDouble : ruleParameterDouble EOF ; + public final void entryRuleParameterDouble() throws RecognitionException { + try { + // InternalRos1Parser.g:1193:1: ( ruleParameterDouble EOF ) + // InternalRos1Parser.g:1194:1: ruleParameterDouble EOF + { + before(grammarAccess.getParameterDoubleRule()); + pushFollow(FOLLOW_1); + ruleParameterDouble(); + + state._fsp--; + + after(grammarAccess.getParameterDoubleRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterDouble" + + + // $ANTLR start "ruleParameterDouble" + // InternalRos1Parser.g:1201:1: ruleParameterDouble : ( ( rule__ParameterDouble__ValueAssignment ) ) ; + public final void ruleParameterDouble() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1205:2: ( ( ( rule__ParameterDouble__ValueAssignment ) ) ) + // InternalRos1Parser.g:1206:2: ( ( rule__ParameterDouble__ValueAssignment ) ) + { + // InternalRos1Parser.g:1206:2: ( ( rule__ParameterDouble__ValueAssignment ) ) + // InternalRos1Parser.g:1207:3: ( rule__ParameterDouble__ValueAssignment ) + { + before(grammarAccess.getParameterDoubleAccess().getValueAssignment()); + // InternalRos1Parser.g:1208:3: ( rule__ParameterDouble__ValueAssignment ) + // InternalRos1Parser.g:1208:4: rule__ParameterDouble__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterDouble__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterDoubleAccess().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterDouble" + + + // $ANTLR start "entryRuleParameterBoolean" + // InternalRos1Parser.g:1217:1: entryRuleParameterBoolean : ruleParameterBoolean EOF ; + public final void entryRuleParameterBoolean() throws RecognitionException { + try { + // InternalRos1Parser.g:1218:1: ( ruleParameterBoolean EOF ) + // InternalRos1Parser.g:1219:1: ruleParameterBoolean EOF + { + before(grammarAccess.getParameterBooleanRule()); + pushFollow(FOLLOW_1); + ruleParameterBoolean(); + + state._fsp--; + + after(grammarAccess.getParameterBooleanRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterBoolean" + + + // $ANTLR start "ruleParameterBoolean" + // InternalRos1Parser.g:1226:1: ruleParameterBoolean : ( ( rule__ParameterBoolean__ValueAssignment ) ) ; + public final void ruleParameterBoolean() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1230:2: ( ( ( rule__ParameterBoolean__ValueAssignment ) ) ) + // InternalRos1Parser.g:1231:2: ( ( rule__ParameterBoolean__ValueAssignment ) ) + { + // InternalRos1Parser.g:1231:2: ( ( rule__ParameterBoolean__ValueAssignment ) ) + // InternalRos1Parser.g:1232:3: ( rule__ParameterBoolean__ValueAssignment ) + { + before(grammarAccess.getParameterBooleanAccess().getValueAssignment()); + // InternalRos1Parser.g:1233:3: ( rule__ParameterBoolean__ValueAssignment ) + // InternalRos1Parser.g:1233:4: rule__ParameterBoolean__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterBoolean__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBooleanAccess().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterBoolean" + + + // $ANTLR start "entryRuleParameterStruct" + // InternalRos1Parser.g:1242:1: entryRuleParameterStruct : ruleParameterStruct EOF ; + public final void entryRuleParameterStruct() throws RecognitionException { + try { + // InternalRos1Parser.g:1243:1: ( ruleParameterStruct EOF ) + // InternalRos1Parser.g:1244:1: ruleParameterStruct EOF + { + before(grammarAccess.getParameterStructRule()); + pushFollow(FOLLOW_1); + ruleParameterStruct(); + + state._fsp--; + + after(grammarAccess.getParameterStructRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterStruct" + + + // $ANTLR start "ruleParameterStruct" + // InternalRos1Parser.g:1251:1: ruleParameterStruct : ( ( rule__ParameterStruct__Group__0 ) ) ; + public final void ruleParameterStruct() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1255:2: ( ( ( rule__ParameterStruct__Group__0 ) ) ) + // InternalRos1Parser.g:1256:2: ( ( rule__ParameterStruct__Group__0 ) ) + { + // InternalRos1Parser.g:1256:2: ( ( rule__ParameterStruct__Group__0 ) ) + // InternalRos1Parser.g:1257:3: ( rule__ParameterStruct__Group__0 ) + { + before(grammarAccess.getParameterStructAccess().getGroup()); + // InternalRos1Parser.g:1258:3: ( rule__ParameterStruct__Group__0 ) + // InternalRos1Parser.g:1258:4: rule__ParameterStruct__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterStruct" + + + // $ANTLR start "entryRuleParameterDate" + // InternalRos1Parser.g:1267:1: entryRuleParameterDate : ruleParameterDate EOF ; + public final void entryRuleParameterDate() throws RecognitionException { + try { + // InternalRos1Parser.g:1268:1: ( ruleParameterDate EOF ) + // InternalRos1Parser.g:1269:1: ruleParameterDate EOF + { + before(grammarAccess.getParameterDateRule()); + pushFollow(FOLLOW_1); + ruleParameterDate(); + + state._fsp--; + + after(grammarAccess.getParameterDateRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterDate" + + + // $ANTLR start "ruleParameterDate" + // InternalRos1Parser.g:1276:1: ruleParameterDate : ( ( rule__ParameterDate__ValueAssignment ) ) ; + public final void ruleParameterDate() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1280:2: ( ( ( rule__ParameterDate__ValueAssignment ) ) ) + // InternalRos1Parser.g:1281:2: ( ( rule__ParameterDate__ValueAssignment ) ) + { + // InternalRos1Parser.g:1281:2: ( ( rule__ParameterDate__ValueAssignment ) ) + // InternalRos1Parser.g:1282:3: ( rule__ParameterDate__ValueAssignment ) + { + before(grammarAccess.getParameterDateAccess().getValueAssignment()); + // InternalRos1Parser.g:1283:3: ( rule__ParameterDate__ValueAssignment ) + // InternalRos1Parser.g:1283:4: rule__ParameterDate__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterDate__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterDateAccess().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterDate" + + + // $ANTLR start "entryRuleParameterStructMember" + // InternalRos1Parser.g:1292:1: entryRuleParameterStructMember : ruleParameterStructMember EOF ; + public final void entryRuleParameterStructMember() throws RecognitionException { + try { + // InternalRos1Parser.g:1293:1: ( ruleParameterStructMember EOF ) + // InternalRos1Parser.g:1294:1: ruleParameterStructMember EOF + { + before(grammarAccess.getParameterStructMemberRule()); + pushFollow(FOLLOW_1); + ruleParameterStructMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructMemberRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterStructMember" + + + // $ANTLR start "ruleParameterStructMember" + // InternalRos1Parser.g:1301:1: ruleParameterStructMember : ( ( rule__ParameterStructMember__Group__0 ) ) ; + public final void ruleParameterStructMember() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1305:2: ( ( ( rule__ParameterStructMember__Group__0 ) ) ) + // InternalRos1Parser.g:1306:2: ( ( rule__ParameterStructMember__Group__0 ) ) + { + // InternalRos1Parser.g:1306:2: ( ( rule__ParameterStructMember__Group__0 ) ) + // InternalRos1Parser.g:1307:3: ( rule__ParameterStructMember__Group__0 ) + { + before(grammarAccess.getParameterStructMemberAccess().getGroup()); + // InternalRos1Parser.g:1308:3: ( rule__ParameterStructMember__Group__0 ) + // InternalRos1Parser.g:1308:4: rule__ParameterStructMember__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructMemberAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterStructMember" + + + // $ANTLR start "entryRuleParameterStructTypeMember" + // InternalRos1Parser.g:1317:1: entryRuleParameterStructTypeMember : ruleParameterStructTypeMember EOF ; + public final void entryRuleParameterStructTypeMember() throws RecognitionException { + try { + // InternalRos1Parser.g:1318:1: ( ruleParameterStructTypeMember EOF ) + // InternalRos1Parser.g:1319:1: ruleParameterStructTypeMember EOF + { + before(grammarAccess.getParameterStructTypeMemberRule()); + pushFollow(FOLLOW_1); + ruleParameterStructTypeMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeMemberRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterStructTypeMember" + + + // $ANTLR start "ruleParameterStructTypeMember" + // InternalRos1Parser.g:1326:1: ruleParameterStructTypeMember : ( ( rule__ParameterStructTypeMember__Group__0 ) ) ; + public final void ruleParameterStructTypeMember() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1330:2: ( ( ( rule__ParameterStructTypeMember__Group__0 ) ) ) + // InternalRos1Parser.g:1331:2: ( ( rule__ParameterStructTypeMember__Group__0 ) ) + { + // InternalRos1Parser.g:1331:2: ( ( rule__ParameterStructTypeMember__Group__0 ) ) + // InternalRos1Parser.g:1332:3: ( rule__ParameterStructTypeMember__Group__0 ) + { + before(grammarAccess.getParameterStructTypeMemberAccess().getGroup()); + // InternalRos1Parser.g:1333:3: ( rule__ParameterStructTypeMember__Group__0 ) + // InternalRos1Parser.g:1333:4: rule__ParameterStructTypeMember__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeMemberAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterStructTypeMember" + + + // $ANTLR start "entryRuleBase64Binary" + // InternalRos1Parser.g:1342:1: entryRuleBase64Binary : ruleBase64Binary EOF ; + public final void entryRuleBase64Binary() throws RecognitionException { + try { + // InternalRos1Parser.g:1343:1: ( ruleBase64Binary EOF ) + // InternalRos1Parser.g:1344:1: ruleBase64Binary EOF + { + before(grammarAccess.getBase64BinaryRule()); + pushFollow(FOLLOW_1); + ruleBase64Binary(); + + state._fsp--; + + after(grammarAccess.getBase64BinaryRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleBase64Binary" + + + // $ANTLR start "ruleBase64Binary" + // InternalRos1Parser.g:1351:1: ruleBase64Binary : ( RULE_BINARY ) ; + public final void ruleBase64Binary() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1355:2: ( ( RULE_BINARY ) ) + // InternalRos1Parser.g:1356:2: ( RULE_BINARY ) + { + // InternalRos1Parser.g:1356:2: ( RULE_BINARY ) + // InternalRos1Parser.g:1357:3: RULE_BINARY + { + before(grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); + match(input,RULE_BINARY,FOLLOW_2); + after(grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleBase64Binary" + + + // $ANTLR start "entryRuleboolean0" + // InternalRos1Parser.g:1367:1: entryRuleboolean0 : ruleboolean0 EOF ; + public final void entryRuleboolean0() throws RecognitionException { + try { + // InternalRos1Parser.g:1368:1: ( ruleboolean0 EOF ) + // InternalRos1Parser.g:1369:1: ruleboolean0 EOF + { + before(grammarAccess.getBoolean0Rule()); + pushFollow(FOLLOW_1); + ruleboolean0(); + + state._fsp--; + + after(grammarAccess.getBoolean0Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleboolean0" + + + // $ANTLR start "ruleboolean0" + // InternalRos1Parser.g:1376:1: ruleboolean0 : ( RULE_BOOLEAN ) ; + public final void ruleboolean0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1380:2: ( ( RULE_BOOLEAN ) ) + // InternalRos1Parser.g:1381:2: ( RULE_BOOLEAN ) + { + // InternalRos1Parser.g:1381:2: ( RULE_BOOLEAN ) + // InternalRos1Parser.g:1382:3: RULE_BOOLEAN + { + before(grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); + match(input,RULE_BOOLEAN,FOLLOW_2); + after(grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleboolean0" + + + // $ANTLR start "entryRuleDouble0" + // InternalRos1Parser.g:1392:1: entryRuleDouble0 : ruleDouble0 EOF ; + public final void entryRuleDouble0() throws RecognitionException { + try { + // InternalRos1Parser.g:1393:1: ( ruleDouble0 EOF ) + // InternalRos1Parser.g:1394:1: ruleDouble0 EOF + { + before(grammarAccess.getDouble0Rule()); + pushFollow(FOLLOW_1); + ruleDouble0(); + + state._fsp--; + + after(grammarAccess.getDouble0Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleDouble0" + + + // $ANTLR start "ruleDouble0" + // InternalRos1Parser.g:1401:1: ruleDouble0 : ( RULE_DOUBLE ) ; + public final void ruleDouble0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1405:2: ( ( RULE_DOUBLE ) ) + // InternalRos1Parser.g:1406:2: ( RULE_DOUBLE ) + { + // InternalRos1Parser.g:1406:2: ( RULE_DOUBLE ) + // InternalRos1Parser.g:1407:3: RULE_DOUBLE + { + before(grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); + match(input,RULE_DOUBLE,FOLLOW_2); + after(grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleDouble0" + + + // $ANTLR start "entryRuleInteger0" + // InternalRos1Parser.g:1417:1: entryRuleInteger0 : ruleInteger0 EOF ; + public final void entryRuleInteger0() throws RecognitionException { + try { + // InternalRos1Parser.g:1418:1: ( ruleInteger0 EOF ) + // InternalRos1Parser.g:1419:1: ruleInteger0 EOF + { + before(grammarAccess.getInteger0Rule()); + pushFollow(FOLLOW_1); + ruleInteger0(); + + state._fsp--; + + after(grammarAccess.getInteger0Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleInteger0" + + + // $ANTLR start "ruleInteger0" + // InternalRos1Parser.g:1426:1: ruleInteger0 : ( RULE_DECINT ) ; + public final void ruleInteger0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1430:2: ( ( RULE_DECINT ) ) + // InternalRos1Parser.g:1431:2: ( RULE_DECINT ) + { + // InternalRos1Parser.g:1431:2: ( RULE_DECINT ) + // InternalRos1Parser.g:1432:3: RULE_DECINT + { + before(grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); + match(input,RULE_DECINT,FOLLOW_2); + after(grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleInteger0" + + + // $ANTLR start "entryRuleDateTime0" + // InternalRos1Parser.g:1442:1: entryRuleDateTime0 : ruleDateTime0 EOF ; + public final void entryRuleDateTime0() throws RecognitionException { + try { + // InternalRos1Parser.g:1443:1: ( ruleDateTime0 EOF ) + // InternalRos1Parser.g:1444:1: ruleDateTime0 EOF + { + before(grammarAccess.getDateTime0Rule()); + pushFollow(FOLLOW_1); + ruleDateTime0(); + + state._fsp--; + + after(grammarAccess.getDateTime0Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleDateTime0" + + + // $ANTLR start "ruleDateTime0" + // InternalRos1Parser.g:1451:1: ruleDateTime0 : ( RULE_DATE_TIME ) ; + public final void ruleDateTime0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1455:2: ( ( RULE_DATE_TIME ) ) + // InternalRos1Parser.g:1456:2: ( RULE_DATE_TIME ) + { + // InternalRos1Parser.g:1456:2: ( RULE_DATE_TIME ) + // InternalRos1Parser.g:1457:3: RULE_DATE_TIME + { + before(grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); + match(input,RULE_DATE_TIME,FOLLOW_2); + after(grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleDateTime0" + + + // $ANTLR start "entryRuleMessagePart" + // InternalRos1Parser.g:1467:1: entryRuleMessagePart : ruleMessagePart EOF ; + public final void entryRuleMessagePart() throws RecognitionException { + try { + // InternalRos1Parser.g:1468:1: ( ruleMessagePart EOF ) + // InternalRos1Parser.g:1469:1: ruleMessagePart EOF + { + before(grammarAccess.getMessagePartRule()); + pushFollow(FOLLOW_1); + ruleMessagePart(); + + state._fsp--; + + after(grammarAccess.getMessagePartRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleMessagePart" + + + // $ANTLR start "ruleMessagePart" + // InternalRos1Parser.g:1476:1: ruleMessagePart : ( ( rule__MessagePart__Group__0 ) ) ; + public final void ruleMessagePart() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1480:2: ( ( ( rule__MessagePart__Group__0 ) ) ) + // InternalRos1Parser.g:1481:2: ( ( rule__MessagePart__Group__0 ) ) + { + // InternalRos1Parser.g:1481:2: ( ( rule__MessagePart__Group__0 ) ) + // InternalRos1Parser.g:1482:3: ( rule__MessagePart__Group__0 ) + { + before(grammarAccess.getMessagePartAccess().getGroup()); + // InternalRos1Parser.g:1483:3: ( rule__MessagePart__Group__0 ) + // InternalRos1Parser.g:1483:4: rule__MessagePart__Group__0 + { + pushFollow(FOLLOW_2); + rule__MessagePart__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getMessagePartAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleMessagePart" + + + // $ANTLR start "entryRuleAbstractType" + // InternalRos1Parser.g:1492:1: entryRuleAbstractType : ruleAbstractType EOF ; + public final void entryRuleAbstractType() throws RecognitionException { + try { + // InternalRos1Parser.g:1493:1: ( ruleAbstractType EOF ) + // InternalRos1Parser.g:1494:1: ruleAbstractType EOF + { + before(grammarAccess.getAbstractTypeRule()); + pushFollow(FOLLOW_1); + ruleAbstractType(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleAbstractType" + + + // $ANTLR start "ruleAbstractType" + // InternalRos1Parser.g:1501:1: ruleAbstractType : ( ( rule__AbstractType__Alternatives ) ) ; + public final void ruleAbstractType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1505:2: ( ( ( rule__AbstractType__Alternatives ) ) ) + // InternalRos1Parser.g:1506:2: ( ( rule__AbstractType__Alternatives ) ) + { + // InternalRos1Parser.g:1506:2: ( ( rule__AbstractType__Alternatives ) ) + // InternalRos1Parser.g:1507:3: ( rule__AbstractType__Alternatives ) + { + before(grammarAccess.getAbstractTypeAccess().getAlternatives()); + // InternalRos1Parser.g:1508:3: ( rule__AbstractType__Alternatives ) + // InternalRos1Parser.g:1508:4: rule__AbstractType__Alternatives + { + pushFollow(FOLLOW_2); + rule__AbstractType__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getAbstractTypeAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleAbstractType" + + + // $ANTLR start "entryRulebool" + // InternalRos1Parser.g:1517:1: entryRulebool : rulebool EOF ; + public final void entryRulebool() throws RecognitionException { + try { + // InternalRos1Parser.g:1518:1: ( rulebool EOF ) + // InternalRos1Parser.g:1519:1: rulebool EOF + { + before(grammarAccess.getBoolRule()); + pushFollow(FOLLOW_1); + rulebool(); + + state._fsp--; + + after(grammarAccess.getBoolRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulebool" + + + // $ANTLR start "rulebool" + // InternalRos1Parser.g:1526:1: rulebool : ( ( rule__Bool__Group__0 ) ) ; + public final void rulebool() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1530:2: ( ( ( rule__Bool__Group__0 ) ) ) + // InternalRos1Parser.g:1531:2: ( ( rule__Bool__Group__0 ) ) + { + // InternalRos1Parser.g:1531:2: ( ( rule__Bool__Group__0 ) ) + // InternalRos1Parser.g:1532:3: ( rule__Bool__Group__0 ) + { + before(grammarAccess.getBoolAccess().getGroup()); + // InternalRos1Parser.g:1533:3: ( rule__Bool__Group__0 ) + // InternalRos1Parser.g:1533:4: rule__Bool__Group__0 + { + pushFollow(FOLLOW_2); + rule__Bool__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getBoolAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulebool" + + + // $ANTLR start "entryRuleint8" + // InternalRos1Parser.g:1542:1: entryRuleint8 : ruleint8 EOF ; + public final void entryRuleint8() throws RecognitionException { + try { + // InternalRos1Parser.g:1543:1: ( ruleint8 EOF ) + // InternalRos1Parser.g:1544:1: ruleint8 EOF + { + before(grammarAccess.getInt8Rule()); + pushFollow(FOLLOW_1); + ruleint8(); + + state._fsp--; + + after(grammarAccess.getInt8Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint8" + + + // $ANTLR start "ruleint8" + // InternalRos1Parser.g:1551:1: ruleint8 : ( ( rule__Int8__Group__0 ) ) ; + public final void ruleint8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1555:2: ( ( ( rule__Int8__Group__0 ) ) ) + // InternalRos1Parser.g:1556:2: ( ( rule__Int8__Group__0 ) ) + { + // InternalRos1Parser.g:1556:2: ( ( rule__Int8__Group__0 ) ) + // InternalRos1Parser.g:1557:3: ( rule__Int8__Group__0 ) + { + before(grammarAccess.getInt8Access().getGroup()); + // InternalRos1Parser.g:1558:3: ( rule__Int8__Group__0 ) + // InternalRos1Parser.g:1558:4: rule__Int8__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int8__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt8Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint8" + + + // $ANTLR start "entryRuleuint8" + // InternalRos1Parser.g:1567:1: entryRuleuint8 : ruleuint8 EOF ; + public final void entryRuleuint8() throws RecognitionException { + try { + // InternalRos1Parser.g:1568:1: ( ruleuint8 EOF ) + // InternalRos1Parser.g:1569:1: ruleuint8 EOF + { + before(grammarAccess.getUint8Rule()); + pushFollow(FOLLOW_1); + ruleuint8(); + + state._fsp--; + + after(grammarAccess.getUint8Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint8" + + + // $ANTLR start "ruleuint8" + // InternalRos1Parser.g:1576:1: ruleuint8 : ( ( rule__Uint8__Group__0 ) ) ; + public final void ruleuint8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1580:2: ( ( ( rule__Uint8__Group__0 ) ) ) + // InternalRos1Parser.g:1581:2: ( ( rule__Uint8__Group__0 ) ) + { + // InternalRos1Parser.g:1581:2: ( ( rule__Uint8__Group__0 ) ) + // InternalRos1Parser.g:1582:3: ( rule__Uint8__Group__0 ) + { + before(grammarAccess.getUint8Access().getGroup()); + // InternalRos1Parser.g:1583:3: ( rule__Uint8__Group__0 ) + // InternalRos1Parser.g:1583:4: rule__Uint8__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint8__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint8Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint8" + + + // $ANTLR start "entryRuleint16" + // InternalRos1Parser.g:1592:1: entryRuleint16 : ruleint16 EOF ; + public final void entryRuleint16() throws RecognitionException { + try { + // InternalRos1Parser.g:1593:1: ( ruleint16 EOF ) + // InternalRos1Parser.g:1594:1: ruleint16 EOF + { + before(grammarAccess.getInt16Rule()); + pushFollow(FOLLOW_1); + ruleint16(); + + state._fsp--; + + after(grammarAccess.getInt16Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint16" + + + // $ANTLR start "ruleint16" + // InternalRos1Parser.g:1601:1: ruleint16 : ( ( rule__Int16__Group__0 ) ) ; + public final void ruleint16() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1605:2: ( ( ( rule__Int16__Group__0 ) ) ) + // InternalRos1Parser.g:1606:2: ( ( rule__Int16__Group__0 ) ) + { + // InternalRos1Parser.g:1606:2: ( ( rule__Int16__Group__0 ) ) + // InternalRos1Parser.g:1607:3: ( rule__Int16__Group__0 ) + { + before(grammarAccess.getInt16Access().getGroup()); + // InternalRos1Parser.g:1608:3: ( rule__Int16__Group__0 ) + // InternalRos1Parser.g:1608:4: rule__Int16__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int16__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt16Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint16" + + + // $ANTLR start "entryRuleuint16" + // InternalRos1Parser.g:1617:1: entryRuleuint16 : ruleuint16 EOF ; + public final void entryRuleuint16() throws RecognitionException { + try { + // InternalRos1Parser.g:1618:1: ( ruleuint16 EOF ) + // InternalRos1Parser.g:1619:1: ruleuint16 EOF + { + before(grammarAccess.getUint16Rule()); + pushFollow(FOLLOW_1); + ruleuint16(); + + state._fsp--; + + after(grammarAccess.getUint16Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint16" + + + // $ANTLR start "ruleuint16" + // InternalRos1Parser.g:1626:1: ruleuint16 : ( ( rule__Uint16__Group__0 ) ) ; + public final void ruleuint16() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1630:2: ( ( ( rule__Uint16__Group__0 ) ) ) + // InternalRos1Parser.g:1631:2: ( ( rule__Uint16__Group__0 ) ) + { + // InternalRos1Parser.g:1631:2: ( ( rule__Uint16__Group__0 ) ) + // InternalRos1Parser.g:1632:3: ( rule__Uint16__Group__0 ) + { + before(grammarAccess.getUint16Access().getGroup()); + // InternalRos1Parser.g:1633:3: ( rule__Uint16__Group__0 ) + // InternalRos1Parser.g:1633:4: rule__Uint16__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint16__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint16Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint16" + + + // $ANTLR start "entryRuleint32" + // InternalRos1Parser.g:1642:1: entryRuleint32 : ruleint32 EOF ; + public final void entryRuleint32() throws RecognitionException { + try { + // InternalRos1Parser.g:1643:1: ( ruleint32 EOF ) + // InternalRos1Parser.g:1644:1: ruleint32 EOF + { + before(grammarAccess.getInt32Rule()); + pushFollow(FOLLOW_1); + ruleint32(); + + state._fsp--; + + after(grammarAccess.getInt32Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint32" + + + // $ANTLR start "ruleint32" + // InternalRos1Parser.g:1651:1: ruleint32 : ( ( rule__Int32__Group__0 ) ) ; + public final void ruleint32() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1655:2: ( ( ( rule__Int32__Group__0 ) ) ) + // InternalRos1Parser.g:1656:2: ( ( rule__Int32__Group__0 ) ) + { + // InternalRos1Parser.g:1656:2: ( ( rule__Int32__Group__0 ) ) + // InternalRos1Parser.g:1657:3: ( rule__Int32__Group__0 ) + { + before(grammarAccess.getInt32Access().getGroup()); + // InternalRos1Parser.g:1658:3: ( rule__Int32__Group__0 ) + // InternalRos1Parser.g:1658:4: rule__Int32__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int32__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt32Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint32" + + + // $ANTLR start "entryRuleuint32" + // InternalRos1Parser.g:1667:1: entryRuleuint32 : ruleuint32 EOF ; + public final void entryRuleuint32() throws RecognitionException { + try { + // InternalRos1Parser.g:1668:1: ( ruleuint32 EOF ) + // InternalRos1Parser.g:1669:1: ruleuint32 EOF + { + before(grammarAccess.getUint32Rule()); + pushFollow(FOLLOW_1); + ruleuint32(); + + state._fsp--; + + after(grammarAccess.getUint32Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint32" + + + // $ANTLR start "ruleuint32" + // InternalRos1Parser.g:1676:1: ruleuint32 : ( ( rule__Uint32__Group__0 ) ) ; + public final void ruleuint32() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1680:2: ( ( ( rule__Uint32__Group__0 ) ) ) + // InternalRos1Parser.g:1681:2: ( ( rule__Uint32__Group__0 ) ) + { + // InternalRos1Parser.g:1681:2: ( ( rule__Uint32__Group__0 ) ) + // InternalRos1Parser.g:1682:3: ( rule__Uint32__Group__0 ) + { + before(grammarAccess.getUint32Access().getGroup()); + // InternalRos1Parser.g:1683:3: ( rule__Uint32__Group__0 ) + // InternalRos1Parser.g:1683:4: rule__Uint32__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint32__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint32Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint32" + + + // $ANTLR start "entryRuleint64" + // InternalRos1Parser.g:1692:1: entryRuleint64 : ruleint64 EOF ; + public final void entryRuleint64() throws RecognitionException { + try { + // InternalRos1Parser.g:1693:1: ( ruleint64 EOF ) + // InternalRos1Parser.g:1694:1: ruleint64 EOF + { + before(grammarAccess.getInt64Rule()); + pushFollow(FOLLOW_1); + ruleint64(); + + state._fsp--; + + after(grammarAccess.getInt64Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint64" + + + // $ANTLR start "ruleint64" + // InternalRos1Parser.g:1701:1: ruleint64 : ( ( rule__Int64__Group__0 ) ) ; + public final void ruleint64() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1705:2: ( ( ( rule__Int64__Group__0 ) ) ) + // InternalRos1Parser.g:1706:2: ( ( rule__Int64__Group__0 ) ) + { + // InternalRos1Parser.g:1706:2: ( ( rule__Int64__Group__0 ) ) + // InternalRos1Parser.g:1707:3: ( rule__Int64__Group__0 ) + { + before(grammarAccess.getInt64Access().getGroup()); + // InternalRos1Parser.g:1708:3: ( rule__Int64__Group__0 ) + // InternalRos1Parser.g:1708:4: rule__Int64__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int64__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt64Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint64" + + + // $ANTLR start "entryRuleuint64" + // InternalRos1Parser.g:1717:1: entryRuleuint64 : ruleuint64 EOF ; + public final void entryRuleuint64() throws RecognitionException { + try { + // InternalRos1Parser.g:1718:1: ( ruleuint64 EOF ) + // InternalRos1Parser.g:1719:1: ruleuint64 EOF + { + before(grammarAccess.getUint64Rule()); + pushFollow(FOLLOW_1); + ruleuint64(); + + state._fsp--; + + after(grammarAccess.getUint64Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint64" + + + // $ANTLR start "ruleuint64" + // InternalRos1Parser.g:1726:1: ruleuint64 : ( ( rule__Uint64__Group__0 ) ) ; + public final void ruleuint64() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1730:2: ( ( ( rule__Uint64__Group__0 ) ) ) + // InternalRos1Parser.g:1731:2: ( ( rule__Uint64__Group__0 ) ) + { + // InternalRos1Parser.g:1731:2: ( ( rule__Uint64__Group__0 ) ) + // InternalRos1Parser.g:1732:3: ( rule__Uint64__Group__0 ) + { + before(grammarAccess.getUint64Access().getGroup()); + // InternalRos1Parser.g:1733:3: ( rule__Uint64__Group__0 ) + // InternalRos1Parser.g:1733:4: rule__Uint64__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint64__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint64Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint64" + + + // $ANTLR start "entryRulefloat32" + // InternalRos1Parser.g:1742:1: entryRulefloat32 : rulefloat32 EOF ; + public final void entryRulefloat32() throws RecognitionException { + try { + // InternalRos1Parser.g:1743:1: ( rulefloat32 EOF ) + // InternalRos1Parser.g:1744:1: rulefloat32 EOF + { + before(grammarAccess.getFloat32Rule()); + pushFollow(FOLLOW_1); + rulefloat32(); + + state._fsp--; + + after(grammarAccess.getFloat32Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulefloat32" + + + // $ANTLR start "rulefloat32" + // InternalRos1Parser.g:1751:1: rulefloat32 : ( ( rule__Float32__Group__0 ) ) ; + public final void rulefloat32() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1755:2: ( ( ( rule__Float32__Group__0 ) ) ) + // InternalRos1Parser.g:1756:2: ( ( rule__Float32__Group__0 ) ) + { + // InternalRos1Parser.g:1756:2: ( ( rule__Float32__Group__0 ) ) + // InternalRos1Parser.g:1757:3: ( rule__Float32__Group__0 ) + { + before(grammarAccess.getFloat32Access().getGroup()); + // InternalRos1Parser.g:1758:3: ( rule__Float32__Group__0 ) + // InternalRos1Parser.g:1758:4: rule__Float32__Group__0 + { + pushFollow(FOLLOW_2); + rule__Float32__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getFloat32Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulefloat32" + + + // $ANTLR start "entryRulefloat64" + // InternalRos1Parser.g:1767:1: entryRulefloat64 : rulefloat64 EOF ; + public final void entryRulefloat64() throws RecognitionException { + try { + // InternalRos1Parser.g:1768:1: ( rulefloat64 EOF ) + // InternalRos1Parser.g:1769:1: rulefloat64 EOF + { + before(grammarAccess.getFloat64Rule()); + pushFollow(FOLLOW_1); + rulefloat64(); + + state._fsp--; + + after(grammarAccess.getFloat64Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulefloat64" + + + // $ANTLR start "rulefloat64" + // InternalRos1Parser.g:1776:1: rulefloat64 : ( ( rule__Float64__Group__0 ) ) ; + public final void rulefloat64() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1780:2: ( ( ( rule__Float64__Group__0 ) ) ) + // InternalRos1Parser.g:1781:2: ( ( rule__Float64__Group__0 ) ) + { + // InternalRos1Parser.g:1781:2: ( ( rule__Float64__Group__0 ) ) + // InternalRos1Parser.g:1782:3: ( rule__Float64__Group__0 ) + { + before(grammarAccess.getFloat64Access().getGroup()); + // InternalRos1Parser.g:1783:3: ( rule__Float64__Group__0 ) + // InternalRos1Parser.g:1783:4: rule__Float64__Group__0 + { + pushFollow(FOLLOW_2); + rule__Float64__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getFloat64Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulefloat64" + + + // $ANTLR start "entryRulestring0" + // InternalRos1Parser.g:1792:1: entryRulestring0 : rulestring0 EOF ; + public final void entryRulestring0() throws RecognitionException { + try { + // InternalRos1Parser.g:1793:1: ( rulestring0 EOF ) + // InternalRos1Parser.g:1794:1: rulestring0 EOF + { + before(grammarAccess.getString0Rule()); + pushFollow(FOLLOW_1); + rulestring0(); + + state._fsp--; + + after(grammarAccess.getString0Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulestring0" + + + // $ANTLR start "rulestring0" + // InternalRos1Parser.g:1801:1: rulestring0 : ( ( rule__String0__Group__0 ) ) ; + public final void rulestring0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1805:2: ( ( ( rule__String0__Group__0 ) ) ) + // InternalRos1Parser.g:1806:2: ( ( rule__String0__Group__0 ) ) + { + // InternalRos1Parser.g:1806:2: ( ( rule__String0__Group__0 ) ) + // InternalRos1Parser.g:1807:3: ( rule__String0__Group__0 ) + { + before(grammarAccess.getString0Access().getGroup()); + // InternalRos1Parser.g:1808:3: ( rule__String0__Group__0 ) + // InternalRos1Parser.g:1808:4: rule__String0__Group__0 + { + pushFollow(FOLLOW_2); + rule__String0__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getString0Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulestring0" + + + // $ANTLR start "entryRulebyte" + // InternalRos1Parser.g:1817:1: entryRulebyte : rulebyte EOF ; + public final void entryRulebyte() throws RecognitionException { + try { + // InternalRos1Parser.g:1818:1: ( rulebyte EOF ) + // InternalRos1Parser.g:1819:1: rulebyte EOF + { + before(grammarAccess.getByteRule()); + pushFollow(FOLLOW_1); + rulebyte(); + + state._fsp--; + + after(grammarAccess.getByteRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulebyte" + + + // $ANTLR start "rulebyte" + // InternalRos1Parser.g:1826:1: rulebyte : ( ( rule__Byte__Group__0 ) ) ; + public final void rulebyte() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1830:2: ( ( ( rule__Byte__Group__0 ) ) ) + // InternalRos1Parser.g:1831:2: ( ( rule__Byte__Group__0 ) ) + { + // InternalRos1Parser.g:1831:2: ( ( rule__Byte__Group__0 ) ) + // InternalRos1Parser.g:1832:3: ( rule__Byte__Group__0 ) + { + before(grammarAccess.getByteAccess().getGroup()); + // InternalRos1Parser.g:1833:3: ( rule__Byte__Group__0 ) + // InternalRos1Parser.g:1833:4: rule__Byte__Group__0 + { + pushFollow(FOLLOW_2); + rule__Byte__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getByteAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulebyte" + + + // $ANTLR start "entryRuletime" + // InternalRos1Parser.g:1842:1: entryRuletime : ruletime EOF ; + public final void entryRuletime() throws RecognitionException { + try { + // InternalRos1Parser.g:1843:1: ( ruletime EOF ) + // InternalRos1Parser.g:1844:1: ruletime EOF + { + before(grammarAccess.getTimeRule()); + pushFollow(FOLLOW_1); + ruletime(); + + state._fsp--; + + after(grammarAccess.getTimeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuletime" + + + // $ANTLR start "ruletime" + // InternalRos1Parser.g:1851:1: ruletime : ( ( rule__Time__Group__0 ) ) ; + public final void ruletime() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1855:2: ( ( ( rule__Time__Group__0 ) ) ) + // InternalRos1Parser.g:1856:2: ( ( rule__Time__Group__0 ) ) + { + // InternalRos1Parser.g:1856:2: ( ( rule__Time__Group__0 ) ) + // InternalRos1Parser.g:1857:3: ( rule__Time__Group__0 ) + { + before(grammarAccess.getTimeAccess().getGroup()); + // InternalRos1Parser.g:1858:3: ( rule__Time__Group__0 ) + // InternalRos1Parser.g:1858:4: rule__Time__Group__0 + { + pushFollow(FOLLOW_2); + rule__Time__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getTimeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruletime" + + + // $ANTLR start "entryRuleduration" + // InternalRos1Parser.g:1867:1: entryRuleduration : ruleduration EOF ; + public final void entryRuleduration() throws RecognitionException { + try { + // InternalRos1Parser.g:1868:1: ( ruleduration EOF ) + // InternalRos1Parser.g:1869:1: ruleduration EOF + { + before(grammarAccess.getDurationRule()); + pushFollow(FOLLOW_1); + ruleduration(); + + state._fsp--; + + after(grammarAccess.getDurationRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleduration" + + + // $ANTLR start "ruleduration" + // InternalRos1Parser.g:1876:1: ruleduration : ( ( rule__Duration__Group__0 ) ) ; + public final void ruleduration() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1880:2: ( ( ( rule__Duration__Group__0 ) ) ) + // InternalRos1Parser.g:1881:2: ( ( rule__Duration__Group__0 ) ) + { + // InternalRos1Parser.g:1881:2: ( ( rule__Duration__Group__0 ) ) + // InternalRos1Parser.g:1882:3: ( rule__Duration__Group__0 ) + { + before(grammarAccess.getDurationAccess().getGroup()); + // InternalRos1Parser.g:1883:3: ( rule__Duration__Group__0 ) + // InternalRos1Parser.g:1883:4: rule__Duration__Group__0 + { + pushFollow(FOLLOW_2); + rule__Duration__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getDurationAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleduration" + + + // $ANTLR start "entryRuleboolArray" + // InternalRos1Parser.g:1892:1: entryRuleboolArray : ruleboolArray EOF ; + public final void entryRuleboolArray() throws RecognitionException { + try { + // InternalRos1Parser.g:1893:1: ( ruleboolArray EOF ) + // InternalRos1Parser.g:1894:1: ruleboolArray EOF + { + before(grammarAccess.getBoolArrayRule()); + pushFollow(FOLLOW_1); + ruleboolArray(); + + state._fsp--; + + after(grammarAccess.getBoolArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleboolArray" + + + // $ANTLR start "ruleboolArray" + // InternalRos1Parser.g:1901:1: ruleboolArray : ( ( rule__BoolArray__Group__0 ) ) ; + public final void ruleboolArray() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1905:2: ( ( ( rule__BoolArray__Group__0 ) ) ) + // InternalRos1Parser.g:1906:2: ( ( rule__BoolArray__Group__0 ) ) + { + // InternalRos1Parser.g:1906:2: ( ( rule__BoolArray__Group__0 ) ) + // InternalRos1Parser.g:1907:3: ( rule__BoolArray__Group__0 ) + { + before(grammarAccess.getBoolArrayAccess().getGroup()); + // InternalRos1Parser.g:1908:3: ( rule__BoolArray__Group__0 ) + // InternalRos1Parser.g:1908:4: rule__BoolArray__Group__0 + { + pushFollow(FOLLOW_2); + rule__BoolArray__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getBoolArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleboolArray" + + + // $ANTLR start "entryRuleint8Array" + // InternalRos1Parser.g:1917:1: entryRuleint8Array : ruleint8Array EOF ; + public final void entryRuleint8Array() throws RecognitionException { + try { + // InternalRos1Parser.g:1918:1: ( ruleint8Array EOF ) + // InternalRos1Parser.g:1919:1: ruleint8Array EOF + { + before(grammarAccess.getInt8ArrayRule()); + pushFollow(FOLLOW_1); + ruleint8Array(); + + state._fsp--; + + after(grammarAccess.getInt8ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint8Array" + + + // $ANTLR start "ruleint8Array" + // InternalRos1Parser.g:1926:1: ruleint8Array : ( ( rule__Int8Array__Group__0 ) ) ; + public final void ruleint8Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1930:2: ( ( ( rule__Int8Array__Group__0 ) ) ) + // InternalRos1Parser.g:1931:2: ( ( rule__Int8Array__Group__0 ) ) + { + // InternalRos1Parser.g:1931:2: ( ( rule__Int8Array__Group__0 ) ) + // InternalRos1Parser.g:1932:3: ( rule__Int8Array__Group__0 ) + { + before(grammarAccess.getInt8ArrayAccess().getGroup()); + // InternalRos1Parser.g:1933:3: ( rule__Int8Array__Group__0 ) + // InternalRos1Parser.g:1933:4: rule__Int8Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int8Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt8ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint8Array" + + + // $ANTLR start "entryRuleuint8Array" + // InternalRos1Parser.g:1942:1: entryRuleuint8Array : ruleuint8Array EOF ; + public final void entryRuleuint8Array() throws RecognitionException { + try { + // InternalRos1Parser.g:1943:1: ( ruleuint8Array EOF ) + // InternalRos1Parser.g:1944:1: ruleuint8Array EOF + { + before(grammarAccess.getUint8ArrayRule()); + pushFollow(FOLLOW_1); + ruleuint8Array(); + + state._fsp--; + + after(grammarAccess.getUint8ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint8Array" + + + // $ANTLR start "ruleuint8Array" + // InternalRos1Parser.g:1951:1: ruleuint8Array : ( ( rule__Uint8Array__Group__0 ) ) ; + public final void ruleuint8Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1955:2: ( ( ( rule__Uint8Array__Group__0 ) ) ) + // InternalRos1Parser.g:1956:2: ( ( rule__Uint8Array__Group__0 ) ) + { + // InternalRos1Parser.g:1956:2: ( ( rule__Uint8Array__Group__0 ) ) + // InternalRos1Parser.g:1957:3: ( rule__Uint8Array__Group__0 ) + { + before(grammarAccess.getUint8ArrayAccess().getGroup()); + // InternalRos1Parser.g:1958:3: ( rule__Uint8Array__Group__0 ) + // InternalRos1Parser.g:1958:4: rule__Uint8Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint8Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint8ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint8Array" + + + // $ANTLR start "entryRuleint16Array" + // InternalRos1Parser.g:1967:1: entryRuleint16Array : ruleint16Array EOF ; + public final void entryRuleint16Array() throws RecognitionException { + try { + // InternalRos1Parser.g:1968:1: ( ruleint16Array EOF ) + // InternalRos1Parser.g:1969:1: ruleint16Array EOF + { + before(grammarAccess.getInt16ArrayRule()); + pushFollow(FOLLOW_1); + ruleint16Array(); + + state._fsp--; + + after(grammarAccess.getInt16ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint16Array" + + + // $ANTLR start "ruleint16Array" + // InternalRos1Parser.g:1976:1: ruleint16Array : ( ( rule__Int16Array__Group__0 ) ) ; + public final void ruleint16Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1980:2: ( ( ( rule__Int16Array__Group__0 ) ) ) + // InternalRos1Parser.g:1981:2: ( ( rule__Int16Array__Group__0 ) ) + { + // InternalRos1Parser.g:1981:2: ( ( rule__Int16Array__Group__0 ) ) + // InternalRos1Parser.g:1982:3: ( rule__Int16Array__Group__0 ) + { + before(grammarAccess.getInt16ArrayAccess().getGroup()); + // InternalRos1Parser.g:1983:3: ( rule__Int16Array__Group__0 ) + // InternalRos1Parser.g:1983:4: rule__Int16Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int16Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt16ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint16Array" + + + // $ANTLR start "entryRuleuint16Array" + // InternalRos1Parser.g:1992:1: entryRuleuint16Array : ruleuint16Array EOF ; + public final void entryRuleuint16Array() throws RecognitionException { + try { + // InternalRos1Parser.g:1993:1: ( ruleuint16Array EOF ) + // InternalRos1Parser.g:1994:1: ruleuint16Array EOF + { + before(grammarAccess.getUint16ArrayRule()); + pushFollow(FOLLOW_1); + ruleuint16Array(); + + state._fsp--; + + after(grammarAccess.getUint16ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint16Array" + + + // $ANTLR start "ruleuint16Array" + // InternalRos1Parser.g:2001:1: ruleuint16Array : ( ( rule__Uint16Array__Group__0 ) ) ; + public final void ruleuint16Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2005:2: ( ( ( rule__Uint16Array__Group__0 ) ) ) + // InternalRos1Parser.g:2006:2: ( ( rule__Uint16Array__Group__0 ) ) + { + // InternalRos1Parser.g:2006:2: ( ( rule__Uint16Array__Group__0 ) ) + // InternalRos1Parser.g:2007:3: ( rule__Uint16Array__Group__0 ) + { + before(grammarAccess.getUint16ArrayAccess().getGroup()); + // InternalRos1Parser.g:2008:3: ( rule__Uint16Array__Group__0 ) + // InternalRos1Parser.g:2008:4: rule__Uint16Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint16Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint16ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint16Array" + + + // $ANTLR start "entryRuleint32Array" + // InternalRos1Parser.g:2017:1: entryRuleint32Array : ruleint32Array EOF ; + public final void entryRuleint32Array() throws RecognitionException { + try { + // InternalRos1Parser.g:2018:1: ( ruleint32Array EOF ) + // InternalRos1Parser.g:2019:1: ruleint32Array EOF + { + before(grammarAccess.getInt32ArrayRule()); + pushFollow(FOLLOW_1); + ruleint32Array(); + + state._fsp--; + + after(grammarAccess.getInt32ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint32Array" + + + // $ANTLR start "ruleint32Array" + // InternalRos1Parser.g:2026:1: ruleint32Array : ( ( rule__Int32Array__Group__0 ) ) ; + public final void ruleint32Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2030:2: ( ( ( rule__Int32Array__Group__0 ) ) ) + // InternalRos1Parser.g:2031:2: ( ( rule__Int32Array__Group__0 ) ) + { + // InternalRos1Parser.g:2031:2: ( ( rule__Int32Array__Group__0 ) ) + // InternalRos1Parser.g:2032:3: ( rule__Int32Array__Group__0 ) + { + before(grammarAccess.getInt32ArrayAccess().getGroup()); + // InternalRos1Parser.g:2033:3: ( rule__Int32Array__Group__0 ) + // InternalRos1Parser.g:2033:4: rule__Int32Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int32Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt32ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint32Array" + + + // $ANTLR start "entryRuleuint32Array" + // InternalRos1Parser.g:2042:1: entryRuleuint32Array : ruleuint32Array EOF ; + public final void entryRuleuint32Array() throws RecognitionException { + try { + // InternalRos1Parser.g:2043:1: ( ruleuint32Array EOF ) + // InternalRos1Parser.g:2044:1: ruleuint32Array EOF + { + before(grammarAccess.getUint32ArrayRule()); + pushFollow(FOLLOW_1); + ruleuint32Array(); + + state._fsp--; + + after(grammarAccess.getUint32ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint32Array" + + + // $ANTLR start "ruleuint32Array" + // InternalRos1Parser.g:2051:1: ruleuint32Array : ( ( rule__Uint32Array__Group__0 ) ) ; + public final void ruleuint32Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2055:2: ( ( ( rule__Uint32Array__Group__0 ) ) ) + // InternalRos1Parser.g:2056:2: ( ( rule__Uint32Array__Group__0 ) ) + { + // InternalRos1Parser.g:2056:2: ( ( rule__Uint32Array__Group__0 ) ) + // InternalRos1Parser.g:2057:3: ( rule__Uint32Array__Group__0 ) + { + before(grammarAccess.getUint32ArrayAccess().getGroup()); + // InternalRos1Parser.g:2058:3: ( rule__Uint32Array__Group__0 ) + // InternalRos1Parser.g:2058:4: rule__Uint32Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint32Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint32ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint32Array" + + + // $ANTLR start "entryRuleint64Array" + // InternalRos1Parser.g:2067:1: entryRuleint64Array : ruleint64Array EOF ; + public final void entryRuleint64Array() throws RecognitionException { + try { + // InternalRos1Parser.g:2068:1: ( ruleint64Array EOF ) + // InternalRos1Parser.g:2069:1: ruleint64Array EOF + { + before(grammarAccess.getInt64ArrayRule()); + pushFollow(FOLLOW_1); + ruleint64Array(); + + state._fsp--; + + after(grammarAccess.getInt64ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint64Array" + + + // $ANTLR start "ruleint64Array" + // InternalRos1Parser.g:2076:1: ruleint64Array : ( ( rule__Int64Array__Group__0 ) ) ; + public final void ruleint64Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2080:2: ( ( ( rule__Int64Array__Group__0 ) ) ) + // InternalRos1Parser.g:2081:2: ( ( rule__Int64Array__Group__0 ) ) + { + // InternalRos1Parser.g:2081:2: ( ( rule__Int64Array__Group__0 ) ) + // InternalRos1Parser.g:2082:3: ( rule__Int64Array__Group__0 ) + { + before(grammarAccess.getInt64ArrayAccess().getGroup()); + // InternalRos1Parser.g:2083:3: ( rule__Int64Array__Group__0 ) + // InternalRos1Parser.g:2083:4: rule__Int64Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int64Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt64ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint64Array" + + + // $ANTLR start "entryRuleuint64Array" + // InternalRos1Parser.g:2092:1: entryRuleuint64Array : ruleuint64Array EOF ; + public final void entryRuleuint64Array() throws RecognitionException { + try { + // InternalRos1Parser.g:2093:1: ( ruleuint64Array EOF ) + // InternalRos1Parser.g:2094:1: ruleuint64Array EOF + { + before(grammarAccess.getUint64ArrayRule()); + pushFollow(FOLLOW_1); + ruleuint64Array(); + + state._fsp--; + + after(grammarAccess.getUint64ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint64Array" + + + // $ANTLR start "ruleuint64Array" + // InternalRos1Parser.g:2101:1: ruleuint64Array : ( ( rule__Uint64Array__Group__0 ) ) ; + public final void ruleuint64Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2105:2: ( ( ( rule__Uint64Array__Group__0 ) ) ) + // InternalRos1Parser.g:2106:2: ( ( rule__Uint64Array__Group__0 ) ) + { + // InternalRos1Parser.g:2106:2: ( ( rule__Uint64Array__Group__0 ) ) + // InternalRos1Parser.g:2107:3: ( rule__Uint64Array__Group__0 ) + { + before(grammarAccess.getUint64ArrayAccess().getGroup()); + // InternalRos1Parser.g:2108:3: ( rule__Uint64Array__Group__0 ) + // InternalRos1Parser.g:2108:4: rule__Uint64Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint64Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint64ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint64Array" + + + // $ANTLR start "entryRulefloat32Array" + // InternalRos1Parser.g:2117:1: entryRulefloat32Array : rulefloat32Array EOF ; + public final void entryRulefloat32Array() throws RecognitionException { + try { + // InternalRos1Parser.g:2118:1: ( rulefloat32Array EOF ) + // InternalRos1Parser.g:2119:1: rulefloat32Array EOF + { + before(grammarAccess.getFloat32ArrayRule()); + pushFollow(FOLLOW_1); + rulefloat32Array(); + + state._fsp--; + + after(grammarAccess.getFloat32ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulefloat32Array" + + + // $ANTLR start "rulefloat32Array" + // InternalRos1Parser.g:2126:1: rulefloat32Array : ( ( rule__Float32Array__Group__0 ) ) ; + public final void rulefloat32Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2130:2: ( ( ( rule__Float32Array__Group__0 ) ) ) + // InternalRos1Parser.g:2131:2: ( ( rule__Float32Array__Group__0 ) ) + { + // InternalRos1Parser.g:2131:2: ( ( rule__Float32Array__Group__0 ) ) + // InternalRos1Parser.g:2132:3: ( rule__Float32Array__Group__0 ) + { + before(grammarAccess.getFloat32ArrayAccess().getGroup()); + // InternalRos1Parser.g:2133:3: ( rule__Float32Array__Group__0 ) + // InternalRos1Parser.g:2133:4: rule__Float32Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Float32Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getFloat32ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulefloat32Array" + + + // $ANTLR start "entryRulefloat64Array" + // InternalRos1Parser.g:2142:1: entryRulefloat64Array : rulefloat64Array EOF ; + public final void entryRulefloat64Array() throws RecognitionException { + try { + // InternalRos1Parser.g:2143:1: ( rulefloat64Array EOF ) + // InternalRos1Parser.g:2144:1: rulefloat64Array EOF + { + before(grammarAccess.getFloat64ArrayRule()); + pushFollow(FOLLOW_1); + rulefloat64Array(); + + state._fsp--; + + after(grammarAccess.getFloat64ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulefloat64Array" + + + // $ANTLR start "rulefloat64Array" + // InternalRos1Parser.g:2151:1: rulefloat64Array : ( ( rule__Float64Array__Group__0 ) ) ; + public final void rulefloat64Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2155:2: ( ( ( rule__Float64Array__Group__0 ) ) ) + // InternalRos1Parser.g:2156:2: ( ( rule__Float64Array__Group__0 ) ) + { + // InternalRos1Parser.g:2156:2: ( ( rule__Float64Array__Group__0 ) ) + // InternalRos1Parser.g:2157:3: ( rule__Float64Array__Group__0 ) + { + before(grammarAccess.getFloat64ArrayAccess().getGroup()); + // InternalRos1Parser.g:2158:3: ( rule__Float64Array__Group__0 ) + // InternalRos1Parser.g:2158:4: rule__Float64Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Float64Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getFloat64ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulefloat64Array" + + + // $ANTLR start "entryRulestring0Array" + // InternalRos1Parser.g:2167:1: entryRulestring0Array : rulestring0Array EOF ; + public final void entryRulestring0Array() throws RecognitionException { + try { + // InternalRos1Parser.g:2168:1: ( rulestring0Array EOF ) + // InternalRos1Parser.g:2169:1: rulestring0Array EOF + { + before(grammarAccess.getString0ArrayRule()); + pushFollow(FOLLOW_1); + rulestring0Array(); + + state._fsp--; + + after(grammarAccess.getString0ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulestring0Array" + + + // $ANTLR start "rulestring0Array" + // InternalRos1Parser.g:2176:1: rulestring0Array : ( ( rule__String0Array__Group__0 ) ) ; + public final void rulestring0Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2180:2: ( ( ( rule__String0Array__Group__0 ) ) ) + // InternalRos1Parser.g:2181:2: ( ( rule__String0Array__Group__0 ) ) + { + // InternalRos1Parser.g:2181:2: ( ( rule__String0Array__Group__0 ) ) + // InternalRos1Parser.g:2182:3: ( rule__String0Array__Group__0 ) + { + before(grammarAccess.getString0ArrayAccess().getGroup()); + // InternalRos1Parser.g:2183:3: ( rule__String0Array__Group__0 ) + // InternalRos1Parser.g:2183:4: rule__String0Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__String0Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getString0ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulestring0Array" + + + // $ANTLR start "entryRulebyteArray" + // InternalRos1Parser.g:2192:1: entryRulebyteArray : rulebyteArray EOF ; + public final void entryRulebyteArray() throws RecognitionException { + try { + // InternalRos1Parser.g:2193:1: ( rulebyteArray EOF ) + // InternalRos1Parser.g:2194:1: rulebyteArray EOF + { + before(grammarAccess.getByteArrayRule()); + pushFollow(FOLLOW_1); + rulebyteArray(); + + state._fsp--; + + after(grammarAccess.getByteArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulebyteArray" + + + // $ANTLR start "rulebyteArray" + // InternalRos1Parser.g:2201:1: rulebyteArray : ( ( rule__ByteArray__Group__0 ) ) ; + public final void rulebyteArray() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2205:2: ( ( ( rule__ByteArray__Group__0 ) ) ) + // InternalRos1Parser.g:2206:2: ( ( rule__ByteArray__Group__0 ) ) + { + // InternalRos1Parser.g:2206:2: ( ( rule__ByteArray__Group__0 ) ) + // InternalRos1Parser.g:2207:3: ( rule__ByteArray__Group__0 ) + { + before(grammarAccess.getByteArrayAccess().getGroup()); + // InternalRos1Parser.g:2208:3: ( rule__ByteArray__Group__0 ) + // InternalRos1Parser.g:2208:4: rule__ByteArray__Group__0 + { + pushFollow(FOLLOW_2); + rule__ByteArray__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getByteArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulebyteArray" + + + // $ANTLR start "entryRuleHeader" + // InternalRos1Parser.g:2217:1: entryRuleHeader : ruleHeader EOF ; + public final void entryRuleHeader() throws RecognitionException { + try { + // InternalRos1Parser.g:2218:1: ( ruleHeader EOF ) + // InternalRos1Parser.g:2219:1: ruleHeader EOF + { + before(grammarAccess.getHeaderRule()); + pushFollow(FOLLOW_1); + ruleHeader(); + + state._fsp--; + + after(grammarAccess.getHeaderRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleHeader" + + + // $ANTLR start "ruleHeader" + // InternalRos1Parser.g:2226:1: ruleHeader : ( ( rule__Header__Group__0 ) ) ; + public final void ruleHeader() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2230:2: ( ( ( rule__Header__Group__0 ) ) ) + // InternalRos1Parser.g:2231:2: ( ( rule__Header__Group__0 ) ) + { + // InternalRos1Parser.g:2231:2: ( ( rule__Header__Group__0 ) ) + // InternalRos1Parser.g:2232:3: ( rule__Header__Group__0 ) + { + before(grammarAccess.getHeaderAccess().getGroup()); + // InternalRos1Parser.g:2233:3: ( rule__Header__Group__0 ) + // InternalRos1Parser.g:2233:4: rule__Header__Group__0 + { + pushFollow(FOLLOW_2); + rule__Header__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getHeaderAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleHeader" + + + // $ANTLR start "entryRuleTopicSpecRef" + // InternalRos1Parser.g:2242:1: entryRuleTopicSpecRef : ruleTopicSpecRef EOF ; + public final void entryRuleTopicSpecRef() throws RecognitionException { + try { + // InternalRos1Parser.g:2243:1: ( ruleTopicSpecRef EOF ) + // InternalRos1Parser.g:2244:1: ruleTopicSpecRef EOF + { + before(grammarAccess.getTopicSpecRefRule()); + pushFollow(FOLLOW_1); + ruleTopicSpecRef(); + + state._fsp--; + + after(grammarAccess.getTopicSpecRefRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleTopicSpecRef" + + + // $ANTLR start "ruleTopicSpecRef" + // InternalRos1Parser.g:2251:1: ruleTopicSpecRef : ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) ; + public final void ruleTopicSpecRef() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2255:2: ( ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) ) + // InternalRos1Parser.g:2256:2: ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) + { + // InternalRos1Parser.g:2256:2: ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) + // InternalRos1Parser.g:2257:3: ( rule__TopicSpecRef__TopicSpecAssignment ) + { + before(grammarAccess.getTopicSpecRefAccess().getTopicSpecAssignment()); + // InternalRos1Parser.g:2258:3: ( rule__TopicSpecRef__TopicSpecAssignment ) + // InternalRos1Parser.g:2258:4: rule__TopicSpecRef__TopicSpecAssignment + { + pushFollow(FOLLOW_2); + rule__TopicSpecRef__TopicSpecAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getTopicSpecRefAccess().getTopicSpecAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleTopicSpecRef" + + + // $ANTLR start "entryRuleArrayTopicSpecRef" + // InternalRos1Parser.g:2267:1: entryRuleArrayTopicSpecRef : ruleArrayTopicSpecRef EOF ; + public final void entryRuleArrayTopicSpecRef() throws RecognitionException { + try { + // InternalRos1Parser.g:2268:1: ( ruleArrayTopicSpecRef EOF ) + // InternalRos1Parser.g:2269:1: ruleArrayTopicSpecRef EOF + { + before(grammarAccess.getArrayTopicSpecRefRule()); + pushFollow(FOLLOW_1); + ruleArrayTopicSpecRef(); + + state._fsp--; + + after(grammarAccess.getArrayTopicSpecRefRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleArrayTopicSpecRef" + + + // $ANTLR start "ruleArrayTopicSpecRef" + // InternalRos1Parser.g:2276:1: ruleArrayTopicSpecRef : ( ( rule__ArrayTopicSpecRef__Group__0 ) ) ; + public final void ruleArrayTopicSpecRef() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2280:2: ( ( ( rule__ArrayTopicSpecRef__Group__0 ) ) ) + // InternalRos1Parser.g:2281:2: ( ( rule__ArrayTopicSpecRef__Group__0 ) ) + { + // InternalRos1Parser.g:2281:2: ( ( rule__ArrayTopicSpecRef__Group__0 ) ) + // InternalRos1Parser.g:2282:3: ( rule__ArrayTopicSpecRef__Group__0 ) + { + before(grammarAccess.getArrayTopicSpecRefAccess().getGroup()); + // InternalRos1Parser.g:2283:3: ( rule__ArrayTopicSpecRef__Group__0 ) + // InternalRos1Parser.g:2283:4: rule__ArrayTopicSpecRef__Group__0 + { + pushFollow(FOLLOW_2); + rule__ArrayTopicSpecRef__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getArrayTopicSpecRefAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleArrayTopicSpecRef" + + + // $ANTLR start "entryRuleKEYWORD" + // InternalRos1Parser.g:2292:1: entryRuleKEYWORD : ruleKEYWORD EOF ; + public final void entryRuleKEYWORD() throws RecognitionException { + try { + // InternalRos1Parser.g:2293:1: ( ruleKEYWORD EOF ) + // InternalRos1Parser.g:2294:1: ruleKEYWORD EOF + { + before(grammarAccess.getKEYWORDRule()); + pushFollow(FOLLOW_1); + ruleKEYWORD(); + + state._fsp--; + + after(grammarAccess.getKEYWORDRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleKEYWORD" + + + // $ANTLR start "ruleKEYWORD" + // InternalRos1Parser.g:2301:1: ruleKEYWORD : ( ( rule__KEYWORD__Alternatives ) ) ; + public final void ruleKEYWORD() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2305:2: ( ( ( rule__KEYWORD__Alternatives ) ) ) + // InternalRos1Parser.g:2306:2: ( ( rule__KEYWORD__Alternatives ) ) + { + // InternalRos1Parser.g:2306:2: ( ( rule__KEYWORD__Alternatives ) ) + // InternalRos1Parser.g:2307:3: ( rule__KEYWORD__Alternatives ) + { + before(grammarAccess.getKEYWORDAccess().getAlternatives()); + // InternalRos1Parser.g:2308:3: ( rule__KEYWORD__Alternatives ) + // InternalRos1Parser.g:2308:4: rule__KEYWORD__Alternatives + { + pushFollow(FOLLOW_2); + rule__KEYWORD__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getKEYWORDAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleKEYWORD" + + + // $ANTLR start "rule__EString__Alternatives" + // InternalRos1Parser.g:2316:1: rule__EString__Alternatives : ( ( RULE_STRING ) | ( RULE_ID ) ); + public final void rule__EString__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2320:1: ( ( RULE_STRING ) | ( RULE_ID ) ) + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0==RULE_STRING) ) { + alt1=1; + } + else if ( (LA1_0==RULE_ID) ) { + alt1=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 1, 0, input); + + throw nvae; + } + switch (alt1) { + case 1 : + // InternalRos1Parser.g:2321:2: ( RULE_STRING ) + { + // InternalRos1Parser.g:2321:2: ( RULE_STRING ) + // InternalRos1Parser.g:2322:3: RULE_STRING + { + before(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + match(input,RULE_STRING,FOLLOW_2); + after(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:2327:2: ( RULE_ID ) + { + // InternalRos1Parser.g:2327:2: ( RULE_ID ) + // InternalRos1Parser.g:2328: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__RosNames__Alternatives" + // InternalRos1Parser.g:2337: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:2341: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:2342:2: ( RULE_ROS_CONVENTION_A ) + { + // InternalRos1Parser.g:2342:2: ( RULE_ROS_CONVENTION_A ) + // InternalRos1Parser.g:2343: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:2348:2: ( RULE_ID ) + { + // InternalRos1Parser.g:2348:2: ( RULE_ID ) + // InternalRos1Parser.g:2349:3: RULE_ID + { + before(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); + match(input,RULE_ID,FOLLOW_2); + after(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:2354:2: ( Node ) + { + // InternalRos1Parser.g:2354:2: ( Node ) + // InternalRos1Parser.g:2355: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__Node__Alternatives_3" + // InternalRos1Parser.g:2364:1: rule__Node__Alternatives_3 : ( ( ( rule__Node__Group_3_0__0 ) ) | ( ( rule__Node__Group_3_1__0 ) ) | ( ( rule__Node__Group_3_2__0 ) ) | ( ( rule__Node__Group_3_3__0 ) ) | ( ( rule__Node__Group_3_4__0 ) ) | ( ( rule__Node__Group_3_5__0 ) ) | ( ( rule__Node__Group_3_6__0 ) ) ); + public final void rule__Node__Alternatives_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2368:1: ( ( ( rule__Node__Group_3_0__0 ) ) | ( ( rule__Node__Group_3_1__0 ) ) | ( ( rule__Node__Group_3_2__0 ) ) | ( ( rule__Node__Group_3_3__0 ) ) | ( ( rule__Node__Group_3_4__0 ) ) | ( ( rule__Node__Group_3_5__0 ) ) | ( ( rule__Node__Group_3_6__0 ) ) ) + int alt3=7; + switch ( input.LA(1) ) { + case Publishers: + { + alt3=1; + } + break; + case Subscribers: + { + alt3=2; + } + break; + case Serviceserver: + { + alt3=3; + } + break; + case Serviceclient: + { + alt3=4; + } + break; + case Actionserver: + { + alt3=5; + } + break; + case Actionclient: + { + alt3=6; + } + break; + case Parameters: + { + alt3=7; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + + switch (alt3) { + case 1 : + // InternalRos1Parser.g:2369:2: ( ( rule__Node__Group_3_0__0 ) ) + { + // InternalRos1Parser.g:2369:2: ( ( rule__Node__Group_3_0__0 ) ) + // InternalRos1Parser.g:2370:3: ( rule__Node__Group_3_0__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_0()); + // InternalRos1Parser.g:2371:3: ( rule__Node__Group_3_0__0 ) + // InternalRos1Parser.g:2371:4: rule__Node__Group_3_0__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_0__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:2375:2: ( ( rule__Node__Group_3_1__0 ) ) + { + // InternalRos1Parser.g:2375:2: ( ( rule__Node__Group_3_1__0 ) ) + // InternalRos1Parser.g:2376:3: ( rule__Node__Group_3_1__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_1()); + // InternalRos1Parser.g:2377:3: ( rule__Node__Group_3_1__0 ) + // InternalRos1Parser.g:2377:4: rule__Node__Group_3_1__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_1__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_1()); + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:2381:2: ( ( rule__Node__Group_3_2__0 ) ) + { + // InternalRos1Parser.g:2381:2: ( ( rule__Node__Group_3_2__0 ) ) + // InternalRos1Parser.g:2382:3: ( rule__Node__Group_3_2__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_2()); + // InternalRos1Parser.g:2383:3: ( rule__Node__Group_3_2__0 ) + // InternalRos1Parser.g:2383:4: rule__Node__Group_3_2__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_2__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_2()); + + } + + + } + break; + case 4 : + // InternalRos1Parser.g:2387:2: ( ( rule__Node__Group_3_3__0 ) ) + { + // InternalRos1Parser.g:2387:2: ( ( rule__Node__Group_3_3__0 ) ) + // InternalRos1Parser.g:2388:3: ( rule__Node__Group_3_3__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_3()); + // InternalRos1Parser.g:2389:3: ( rule__Node__Group_3_3__0 ) + // InternalRos1Parser.g:2389:4: rule__Node__Group_3_3__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_3__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_3()); + + } + + + } + break; + case 5 : + // InternalRos1Parser.g:2393:2: ( ( rule__Node__Group_3_4__0 ) ) + { + // InternalRos1Parser.g:2393:2: ( ( rule__Node__Group_3_4__0 ) ) + // InternalRos1Parser.g:2394:3: ( rule__Node__Group_3_4__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_4()); + // InternalRos1Parser.g:2395:3: ( rule__Node__Group_3_4__0 ) + // InternalRos1Parser.g:2395:4: rule__Node__Group_3_4__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_4__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_4()); + + } + + + } + break; + case 6 : + // InternalRos1Parser.g:2399:2: ( ( rule__Node__Group_3_5__0 ) ) + { + // InternalRos1Parser.g:2399:2: ( ( rule__Node__Group_3_5__0 ) ) + // InternalRos1Parser.g:2400:3: ( rule__Node__Group_3_5__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_5()); + // InternalRos1Parser.g:2401:3: ( rule__Node__Group_3_5__0 ) + // InternalRos1Parser.g:2401:4: rule__Node__Group_3_5__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_5__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_5()); + + } + + + } + break; + case 7 : + // InternalRos1Parser.g:2405:2: ( ( rule__Node__Group_3_6__0 ) ) + { + // InternalRos1Parser.g:2405:2: ( ( rule__Node__Group_3_6__0 ) ) + // InternalRos1Parser.g:2406:3: ( rule__Node__Group_3_6__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_6()); + // InternalRos1Parser.g:2407:3: ( rule__Node__Group_3_6__0 ) + // InternalRos1Parser.g:2407:4: rule__Node__Group_3_6__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_6__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_6()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Alternatives_3" + + + // $ANTLR start "rule__SpecBase__Alternatives" + // InternalRos1Parser.g:2415:1: rule__SpecBase__Alternatives : ( ( ruleTopicSpec ) | ( ruleServiceSpec ) | ( ruleActionSpec ) ); + public final void rule__SpecBase__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2419:1: ( ( ruleTopicSpec ) | ( ruleServiceSpec ) | ( ruleActionSpec ) ) + int alt4=3; + switch ( input.LA(1) ) { + case Msg: + { + alt4=1; + } + break; + case Srv: + { + alt4=2; + } + break; + case Action_1: + { + alt4=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + + switch (alt4) { + case 1 : + // InternalRos1Parser.g:2420:2: ( ruleTopicSpec ) + { + // InternalRos1Parser.g:2420:2: ( ruleTopicSpec ) + // InternalRos1Parser.g:2421:3: ruleTopicSpec + { + before(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleTopicSpec(); + + state._fsp--; + + after(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:2426:2: ( ruleServiceSpec ) + { + // InternalRos1Parser.g:2426:2: ( ruleServiceSpec ) + // InternalRos1Parser.g:2427:3: ruleServiceSpec + { + before(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleServiceSpec(); + + state._fsp--; + + after(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:2432:2: ( ruleActionSpec ) + { + // InternalRos1Parser.g:2432:2: ( ruleActionSpec ) + // InternalRos1Parser.g:2433:3: ruleActionSpec + { + before(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); + pushFollow(FOLLOW_2); + ruleActionSpec(); + + state._fsp--; + + after(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SpecBase__Alternatives" + + + // $ANTLR start "rule__TopicSpec__NameAlternatives_2_0" + // InternalRos1Parser.g:2442:1: rule__TopicSpec__NameAlternatives_2_0 : ( ( ruleEString ) | ( Header ) | ( String ) ); + public final void rule__TopicSpec__NameAlternatives_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2446:1: ( ( ruleEString ) | ( Header ) | ( String ) ) + int alt5=3; + switch ( input.LA(1) ) { + case RULE_ID: + case RULE_STRING: + { + alt5=1; + } + break; + case Header: + { + alt5=2; + } + break; + case String: + { + alt5=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + + throw nvae; + } + + switch (alt5) { + case 1 : + // InternalRos1Parser.g:2447:2: ( ruleEString ) + { + // InternalRos1Parser.g:2447:2: ( ruleEString ) + // InternalRos1Parser.g:2448:3: ruleEString + { + before(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:2453:2: ( Header ) + { + // InternalRos1Parser.g:2453:2: ( Header ) + // InternalRos1Parser.g:2454:3: Header + { + before(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); + match(input,Header,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:2459:2: ( String ) + { + // InternalRos1Parser.g:2459:2: ( String ) + // InternalRos1Parser.g:2460:3: String + { + before(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); + match(input,String,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__NameAlternatives_2_0" + + + // $ANTLR start "rule__Dependency__Alternatives" + // InternalRos1Parser.g:2469:1: rule__Dependency__Alternatives : ( ( rulePackageDependency ) | ( ruleExternalDependency ) ); + public final void rule__Dependency__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2473:1: ( ( rulePackageDependency ) | ( ruleExternalDependency ) ) + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==RULE_ID||LA6_0==RULE_STRING) ) { + alt6=1; + } + else if ( (LA6_0==ExternalDependency) ) { + alt6=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + switch (alt6) { + case 1 : + // InternalRos1Parser.g:2474:2: ( rulePackageDependency ) + { + // InternalRos1Parser.g:2474:2: ( rulePackageDependency ) + // InternalRos1Parser.g:2475:3: rulePackageDependency + { + before(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + pushFollow(FOLLOW_2); + rulePackageDependency(); + + state._fsp--; + + after(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:2480:2: ( ruleExternalDependency ) + { + // InternalRos1Parser.g:2480:2: ( ruleExternalDependency ) + // InternalRos1Parser.g:2481: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__Namespace__Alternatives" + // InternalRos1Parser.g:2490:1: rule__Namespace__Alternatives : ( ( ruleGlobalNamespace ) | ( ruleRelativeNamespace_Impl ) | ( rulePrivateNamespace ) ); + public final void rule__Namespace__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2494:1: ( ( ruleGlobalNamespace ) | ( ruleRelativeNamespace_Impl ) | ( rulePrivateNamespace ) ) + int alt7=3; + switch ( input.LA(1) ) { + case GlobalNamespace: + { + alt7=1; + } + break; + case RelativeNamespace: + { + alt7=2; + } + break; + case PrivateNamespace: + { + alt7=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + + throw nvae; + } + + switch (alt7) { + case 1 : + // InternalRos1Parser.g:2495:2: ( ruleGlobalNamespace ) + { + // InternalRos1Parser.g:2495:2: ( ruleGlobalNamespace ) + // InternalRos1Parser.g:2496:3: ruleGlobalNamespace + { + before(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleGlobalNamespace(); + + state._fsp--; + + after(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:2501:2: ( ruleRelativeNamespace_Impl ) + { + // InternalRos1Parser.g:2501:2: ( ruleRelativeNamespace_Impl ) + // InternalRos1Parser.g:2502:3: ruleRelativeNamespace_Impl + { + before(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleRelativeNamespace_Impl(); + + state._fsp--; + + after(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:2507:2: ( rulePrivateNamespace ) + { + // InternalRos1Parser.g:2507:2: ( rulePrivateNamespace ) + // InternalRos1Parser.g:2508:3: rulePrivateNamespace + { + before(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + pushFollow(FOLLOW_2); + rulePrivateNamespace(); + + state._fsp--; + + after(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Namespace__Alternatives" + + + // $ANTLR start "rule__ParameterType__Alternatives" + // InternalRos1Parser.g:2517:1: rule__ParameterType__Alternatives : ( ( ruleParameterListType ) | ( ruleParameterStructType ) | ( ruleParameterIntegerType ) | ( ruleParameterStringType ) | ( ruleParameterDoubleType ) | ( ruleParameterBooleanType ) | ( ruleParameterBase64Type ) | ( ruleParameterArrayType ) ); + public final void rule__ParameterType__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2521:1: ( ( ruleParameterListType ) | ( ruleParameterStructType ) | ( ruleParameterIntegerType ) | ( ruleParameterStringType ) | ( ruleParameterDoubleType ) | ( ruleParameterBooleanType ) | ( ruleParameterBase64Type ) | ( ruleParameterArrayType ) ) + int alt8=8; + switch ( input.LA(1) ) { + case List: + { + alt8=1; + } + break; + case Struct: + { + alt8=2; + } + break; + case Integer: + { + alt8=3; + } + break; + case String: + { + alt8=4; + } + break; + case Double: + { + alt8=5; + } + break; + case Boolean: + { + alt8=6; + } + break; + case Base64: + { + alt8=7; + } + break; + case Array: + { + alt8=8; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 8, 0, input); + + throw nvae; + } + + switch (alt8) { + case 1 : + // InternalRos1Parser.g:2522:2: ( ruleParameterListType ) + { + // InternalRos1Parser.g:2522:2: ( ruleParameterListType ) + // InternalRos1Parser.g:2523:3: ruleParameterListType + { + before(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleParameterListType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:2528:2: ( ruleParameterStructType ) + { + // InternalRos1Parser.g:2528:2: ( ruleParameterStructType ) + // InternalRos1Parser.g:2529:3: ruleParameterStructType + { + before(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleParameterStructType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:2534:2: ( ruleParameterIntegerType ) + { + // InternalRos1Parser.g:2534:2: ( ruleParameterIntegerType ) + // InternalRos1Parser.g:2535:3: ruleParameterIntegerType + { + before(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); + pushFollow(FOLLOW_2); + ruleParameterIntegerType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); + + } + + + } + break; + case 4 : + // InternalRos1Parser.g:2540:2: ( ruleParameterStringType ) + { + // InternalRos1Parser.g:2540:2: ( ruleParameterStringType ) + // InternalRos1Parser.g:2541:3: ruleParameterStringType + { + before(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); + pushFollow(FOLLOW_2); + ruleParameterStringType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); + + } + + + } + break; + case 5 : + // InternalRos1Parser.g:2546:2: ( ruleParameterDoubleType ) + { + // InternalRos1Parser.g:2546:2: ( ruleParameterDoubleType ) + // InternalRos1Parser.g:2547:3: ruleParameterDoubleType + { + before(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); + pushFollow(FOLLOW_2); + ruleParameterDoubleType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); + + } + + + } + break; + case 6 : + // InternalRos1Parser.g:2552:2: ( ruleParameterBooleanType ) + { + // InternalRos1Parser.g:2552:2: ( ruleParameterBooleanType ) + // InternalRos1Parser.g:2553:3: ruleParameterBooleanType + { + before(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); + pushFollow(FOLLOW_2); + ruleParameterBooleanType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); + + } + + + } + break; + case 7 : + // InternalRos1Parser.g:2558:2: ( ruleParameterBase64Type ) + { + // InternalRos1Parser.g:2558:2: ( ruleParameterBase64Type ) + // InternalRos1Parser.g:2559:3: ruleParameterBase64Type + { + before(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); + pushFollow(FOLLOW_2); + ruleParameterBase64Type(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); + + } + + + } + break; + case 8 : + // InternalRos1Parser.g:2564:2: ( ruleParameterArrayType ) + { + // InternalRos1Parser.g:2564:2: ( ruleParameterArrayType ) + // InternalRos1Parser.g:2565:3: ruleParameterArrayType + { + before(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); + pushFollow(FOLLOW_2); + ruleParameterArrayType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterType__Alternatives" + + + // $ANTLR start "rule__ParameterValue__Alternatives" + // InternalRos1Parser.g:2574:1: rule__ParameterValue__Alternatives : ( ( ruleParameterString ) | ( ruleParameterBase64 ) | ( ruleParameterInteger ) | ( ruleParameterDouble ) | ( ruleParameterBoolean ) | ( ruleParameterList ) | ( ruleParameterStruct ) ); + public final void rule__ParameterValue__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2578:1: ( ( ruleParameterString ) | ( ruleParameterBase64 ) | ( ruleParameterInteger ) | ( ruleParameterDouble ) | ( ruleParameterBoolean ) | ( ruleParameterList ) | ( ruleParameterStruct ) ) + int alt9=7; + switch ( input.LA(1) ) { + case RULE_ID: + case RULE_STRING: + { + alt9=1; + } + break; + case RULE_BINARY: + { + alt9=2; + } + break; + case RULE_DECINT: + { + alt9=3; + } + break; + case RULE_DOUBLE: + { + alt9=4; + } + break; + case RULE_BOOLEAN: + { + alt9=5; + } + break; + case LeftSquareBracket: + { + int LA9_6 = input.LA(2); + + if ( (LA9_6==Comma||(LA9_6>=LeftSquareBracket && LA9_6<=RightSquareBracket)||LA9_6==RULE_ID||LA9_6==RULE_STRING||(LA9_6>=RULE_BINARY && LA9_6<=RULE_DOUBLE)) ) { + alt9=6; + } + else if ( (LA9_6==ParameterStructMember) ) { + alt9=7; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 9, 6, input); + + throw nvae; + } + } + break; + case EOF: + case Comma: + case RightSquareBracket: + case RULE_END: + { + alt9=7; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + + throw nvae; + } + + switch (alt9) { + case 1 : + // InternalRos1Parser.g:2579:2: ( ruleParameterString ) + { + // InternalRos1Parser.g:2579:2: ( ruleParameterString ) + // InternalRos1Parser.g:2580:3: ruleParameterString + { + before(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleParameterString(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:2585:2: ( ruleParameterBase64 ) + { + // InternalRos1Parser.g:2585:2: ( ruleParameterBase64 ) + // InternalRos1Parser.g:2586:3: ruleParameterBase64 + { + before(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleParameterBase64(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:2591:2: ( ruleParameterInteger ) + { + // InternalRos1Parser.g:2591:2: ( ruleParameterInteger ) + // InternalRos1Parser.g:2592:3: ruleParameterInteger + { + before(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); + pushFollow(FOLLOW_2); + ruleParameterInteger(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); + + } + + + } + break; + case 4 : + // InternalRos1Parser.g:2597:2: ( ruleParameterDouble ) + { + // InternalRos1Parser.g:2597:2: ( ruleParameterDouble ) + // InternalRos1Parser.g:2598:3: ruleParameterDouble + { + before(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); + pushFollow(FOLLOW_2); + ruleParameterDouble(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); + + } + + + } + break; + case 5 : + // InternalRos1Parser.g:2603:2: ( ruleParameterBoolean ) + { + // InternalRos1Parser.g:2603:2: ( ruleParameterBoolean ) + // InternalRos1Parser.g:2604:3: ruleParameterBoolean + { + before(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); + pushFollow(FOLLOW_2); + ruleParameterBoolean(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); + + } + + + } + break; + case 6 : + // InternalRos1Parser.g:2609:2: ( ruleParameterList ) + { + // InternalRos1Parser.g:2609:2: ( ruleParameterList ) + // InternalRos1Parser.g:2610:3: ruleParameterList + { + before(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); + pushFollow(FOLLOW_2); + ruleParameterList(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); + + } + + + } + break; + case 7 : + // InternalRos1Parser.g:2615:2: ( ruleParameterStruct ) + { + // InternalRos1Parser.g:2615:2: ( ruleParameterStruct ) + // InternalRos1Parser.g:2616:3: ruleParameterStruct + { + before(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); + pushFollow(FOLLOW_2); + ruleParameterStruct(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterValue__Alternatives" + + + // $ANTLR start "rule__MessagePart__DataAlternatives_1_0" + // InternalRos1Parser.g:2625:1: rule__MessagePart__DataAlternatives_1_0 : ( ( ruleKEYWORD ) | ( RULE_MESSAGE_ASIGMENT ) | ( ruleEString ) ); + public final void rule__MessagePart__DataAlternatives_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2629:1: ( ( ruleKEYWORD ) | ( RULE_MESSAGE_ASIGMENT ) | ( ruleEString ) ) + int alt10=3; + switch ( input.LA(1) ) { + case Duration: + case Feedback: + case Message: + case Service: + case Action: + case Result: + case Value: + case Goal: + case Name: + case Time: + case Type: + { + alt10=1; + } + break; + case RULE_MESSAGE_ASIGMENT: + { + alt10=2; + } + break; + case RULE_ID: + case RULE_STRING: + { + alt10=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 10, 0, input); + + throw nvae; + } + + switch (alt10) { + case 1 : + // InternalRos1Parser.g:2630:2: ( ruleKEYWORD ) + { + // InternalRos1Parser.g:2630:2: ( ruleKEYWORD ) + // InternalRos1Parser.g:2631:3: ruleKEYWORD + { + before(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); + pushFollow(FOLLOW_2); + ruleKEYWORD(); + + state._fsp--; + + after(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:2636:2: ( RULE_MESSAGE_ASIGMENT ) + { + // InternalRos1Parser.g:2636:2: ( RULE_MESSAGE_ASIGMENT ) + // InternalRos1Parser.g:2637:3: RULE_MESSAGE_ASIGMENT + { + before(grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); + match(input,RULE_MESSAGE_ASIGMENT,FOLLOW_2); + after(grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:2642:2: ( ruleEString ) + { + // InternalRos1Parser.g:2642:2: ( ruleEString ) + // InternalRos1Parser.g:2643:3: ruleEString + { + before(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__DataAlternatives_1_0" + + + // $ANTLR start "rule__AbstractType__Alternatives" + // InternalRos1Parser.g:2652:1: rule__AbstractType__Alternatives : ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) ); + public final void rule__AbstractType__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2656:1: ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) ) + int alt11=31; + alt11 = dfa11.predict(input); + switch (alt11) { + case 1 : + // InternalRos1Parser.g:2657:2: ( rulebool ) + { + // InternalRos1Parser.g:2657:2: ( rulebool ) + // InternalRos1Parser.g:2658:3: rulebool + { + before(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); + pushFollow(FOLLOW_2); + rulebool(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:2663:2: ( ruleint8 ) + { + // InternalRos1Parser.g:2663:2: ( ruleint8 ) + // InternalRos1Parser.g:2664:3: ruleint8 + { + before(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleint8(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:2669:2: ( ruleuint8 ) + { + // InternalRos1Parser.g:2669:2: ( ruleuint8 ) + // InternalRos1Parser.g:2670:3: ruleuint8 + { + before(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); + pushFollow(FOLLOW_2); + ruleuint8(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); + + } + + + } + break; + case 4 : + // InternalRos1Parser.g:2675:2: ( ruleint16 ) + { + // InternalRos1Parser.g:2675:2: ( ruleint16 ) + // InternalRos1Parser.g:2676:3: ruleint16 + { + before(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); + pushFollow(FOLLOW_2); + ruleint16(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); + + } + + + } + break; + case 5 : + // InternalRos1Parser.g:2681:2: ( ruleuint16 ) + { + // InternalRos1Parser.g:2681:2: ( ruleuint16 ) + // InternalRos1Parser.g:2682:3: ruleuint16 + { + before(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); + pushFollow(FOLLOW_2); + ruleuint16(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); + + } + + + } + break; + case 6 : + // InternalRos1Parser.g:2687:2: ( ruleint32 ) + { + // InternalRos1Parser.g:2687:2: ( ruleint32 ) + // InternalRos1Parser.g:2688:3: ruleint32 + { + before(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); + pushFollow(FOLLOW_2); + ruleint32(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); + + } + + + } + break; + case 7 : + // InternalRos1Parser.g:2693:2: ( ruleuint32 ) + { + // InternalRos1Parser.g:2693:2: ( ruleuint32 ) + // InternalRos1Parser.g:2694:3: ruleuint32 + { + before(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); + pushFollow(FOLLOW_2); + ruleuint32(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); + + } + + + } + break; + case 8 : + // InternalRos1Parser.g:2699:2: ( ruleint64 ) + { + // InternalRos1Parser.g:2699:2: ( ruleint64 ) + // InternalRos1Parser.g:2700:3: ruleint64 + { + before(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); + pushFollow(FOLLOW_2); + ruleint64(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); + + } + + + } + break; + case 9 : + // InternalRos1Parser.g:2705:2: ( ruleuint64 ) + { + // InternalRos1Parser.g:2705:2: ( ruleuint64 ) + // InternalRos1Parser.g:2706:3: ruleuint64 + { + before(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); + pushFollow(FOLLOW_2); + ruleuint64(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); + + } + + + } + break; + case 10 : + // InternalRos1Parser.g:2711:2: ( rulefloat32 ) + { + // InternalRos1Parser.g:2711:2: ( rulefloat32 ) + // InternalRos1Parser.g:2712:3: rulefloat32 + { + before(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); + pushFollow(FOLLOW_2); + rulefloat32(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); + + } + + + } + break; + case 11 : + // InternalRos1Parser.g:2717:2: ( rulefloat64 ) + { + // InternalRos1Parser.g:2717:2: ( rulefloat64 ) + // InternalRos1Parser.g:2718:3: rulefloat64 + { + before(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); + pushFollow(FOLLOW_2); + rulefloat64(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); + + } + + + } + break; + case 12 : + // InternalRos1Parser.g:2723:2: ( rulestring0 ) + { + // InternalRos1Parser.g:2723:2: ( rulestring0 ) + // InternalRos1Parser.g:2724:3: rulestring0 + { + before(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); + pushFollow(FOLLOW_2); + rulestring0(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); + + } + + + } + break; + case 13 : + // InternalRos1Parser.g:2729:2: ( rulebyte ) + { + // InternalRos1Parser.g:2729:2: ( rulebyte ) + // InternalRos1Parser.g:2730:3: rulebyte + { + before(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); + pushFollow(FOLLOW_2); + rulebyte(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); + + } + + + } + break; + case 14 : + // InternalRos1Parser.g:2735:2: ( ruletime ) + { + // InternalRos1Parser.g:2735:2: ( ruletime ) + // InternalRos1Parser.g:2736:3: ruletime + { + before(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); + pushFollow(FOLLOW_2); + ruletime(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); + + } + + + } + break; + case 15 : + // InternalRos1Parser.g:2741:2: ( ruleduration ) + { + // InternalRos1Parser.g:2741:2: ( ruleduration ) + // InternalRos1Parser.g:2742:3: ruleduration + { + before(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); + pushFollow(FOLLOW_2); + ruleduration(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); + + } + + + } + break; + case 16 : + // InternalRos1Parser.g:2747:2: ( ruleHeader ) + { + // InternalRos1Parser.g:2747:2: ( ruleHeader ) + // InternalRos1Parser.g:2748:3: ruleHeader + { + before(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); + pushFollow(FOLLOW_2); + ruleHeader(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); + + } + + + } + break; + case 17 : + // InternalRos1Parser.g:2753:2: ( ruleboolArray ) + { + // InternalRos1Parser.g:2753:2: ( ruleboolArray ) + // InternalRos1Parser.g:2754:3: ruleboolArray + { + before(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); + pushFollow(FOLLOW_2); + ruleboolArray(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); + + } + + + } + break; + case 18 : + // InternalRos1Parser.g:2759:2: ( ruleint8Array ) + { + // InternalRos1Parser.g:2759:2: ( ruleint8Array ) + // InternalRos1Parser.g:2760:3: ruleint8Array + { + before(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); + pushFollow(FOLLOW_2); + ruleint8Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); + + } + + + } + break; + case 19 : + // InternalRos1Parser.g:2765:2: ( ruleuint8Array ) + { + // InternalRos1Parser.g:2765:2: ( ruleuint8Array ) + // InternalRos1Parser.g:2766:3: ruleuint8Array + { + before(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); + pushFollow(FOLLOW_2); + ruleuint8Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); + + } + + + } + break; + case 20 : + // InternalRos1Parser.g:2771:2: ( ruleint16Array ) + { + // InternalRos1Parser.g:2771:2: ( ruleint16Array ) + // InternalRos1Parser.g:2772:3: ruleint16Array + { + before(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); + pushFollow(FOLLOW_2); + ruleint16Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); + + } + + + } + break; + case 21 : + // InternalRos1Parser.g:2777:2: ( ruleuint16Array ) + { + // InternalRos1Parser.g:2777:2: ( ruleuint16Array ) + // InternalRos1Parser.g:2778:3: ruleuint16Array + { + before(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); + pushFollow(FOLLOW_2); + ruleuint16Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); + + } + + + } + break; + case 22 : + // InternalRos1Parser.g:2783:2: ( ruleint32Array ) + { + // InternalRos1Parser.g:2783:2: ( ruleint32Array ) + // InternalRos1Parser.g:2784:3: ruleint32Array + { + before(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); + pushFollow(FOLLOW_2); + ruleint32Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); + + } + + + } + break; + case 23 : + // InternalRos1Parser.g:2789:2: ( ruleuint32Array ) + { + // InternalRos1Parser.g:2789:2: ( ruleuint32Array ) + // InternalRos1Parser.g:2790:3: ruleuint32Array + { + before(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); + pushFollow(FOLLOW_2); + ruleuint32Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); + + } + + + } + break; + case 24 : + // InternalRos1Parser.g:2795:2: ( ruleint64Array ) + { + // InternalRos1Parser.g:2795:2: ( ruleint64Array ) + // InternalRos1Parser.g:2796:3: ruleint64Array + { + before(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); + pushFollow(FOLLOW_2); + ruleint64Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); + + } + + + } + break; + case 25 : + // InternalRos1Parser.g:2801:2: ( ruleuint64Array ) + { + // InternalRos1Parser.g:2801:2: ( ruleuint64Array ) + // InternalRos1Parser.g:2802:3: ruleuint64Array + { + before(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); + pushFollow(FOLLOW_2); + ruleuint64Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); + + } + + + } + break; + case 26 : + // InternalRos1Parser.g:2807:2: ( rulefloat32Array ) + { + // InternalRos1Parser.g:2807:2: ( rulefloat32Array ) + // InternalRos1Parser.g:2808:3: rulefloat32Array + { + before(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); + pushFollow(FOLLOW_2); + rulefloat32Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); + + } + + + } + break; + case 27 : + // InternalRos1Parser.g:2813:2: ( rulefloat64Array ) + { + // InternalRos1Parser.g:2813:2: ( rulefloat64Array ) + // InternalRos1Parser.g:2814:3: rulefloat64Array + { + before(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); + pushFollow(FOLLOW_2); + rulefloat64Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); + + } + + + } + break; + case 28 : + // InternalRos1Parser.g:2819:2: ( rulestring0Array ) + { + // InternalRos1Parser.g:2819:2: ( rulestring0Array ) + // InternalRos1Parser.g:2820:3: rulestring0Array + { + before(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); + pushFollow(FOLLOW_2); + rulestring0Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); + + } + + + } + break; + case 29 : + // InternalRos1Parser.g:2825:2: ( rulebyteArray ) + { + // InternalRos1Parser.g:2825:2: ( rulebyteArray ) + // InternalRos1Parser.g:2826:3: rulebyteArray + { + before(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); + pushFollow(FOLLOW_2); + rulebyteArray(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); + + } + + + } + break; + case 30 : + // InternalRos1Parser.g:2831:2: ( ruleTopicSpecRef ) + { + // InternalRos1Parser.g:2831:2: ( ruleTopicSpecRef ) + // InternalRos1Parser.g:2832:3: ruleTopicSpecRef + { + before(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); + pushFollow(FOLLOW_2); + ruleTopicSpecRef(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); + + } + + + } + break; + case 31 : + // InternalRos1Parser.g:2837:2: ( ruleArrayTopicSpecRef ) + { + // InternalRos1Parser.g:2837:2: ( ruleArrayTopicSpecRef ) + // InternalRos1Parser.g:2838:3: ruleArrayTopicSpecRef + { + before(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); + pushFollow(FOLLOW_2); + ruleArrayTopicSpecRef(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AbstractType__Alternatives" + + + // $ANTLR start "rule__KEYWORD__Alternatives" + // InternalRos1Parser.g:2847:1: rule__KEYWORD__Alternatives : ( ( Goal ) | ( Message ) | ( Result ) | ( Feedback ) | ( Name ) | ( Value ) | ( Service ) | ( Type ) | ( Action ) | ( Duration ) | ( Time ) ); + public final void rule__KEYWORD__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2851:1: ( ( Goal ) | ( Message ) | ( Result ) | ( Feedback ) | ( Name ) | ( Value ) | ( Service ) | ( Type ) | ( Action ) | ( Duration ) | ( Time ) ) + int alt12=11; + switch ( input.LA(1) ) { + case Goal: + { + alt12=1; + } + break; + case Message: + { + alt12=2; + } + break; + case Result: + { + alt12=3; + } + break; + case Feedback: + { + alt12=4; + } + break; + case Name: + { + alt12=5; + } + break; + case Value: + { + alt12=6; + } + break; + case Service: + { + alt12=7; + } + break; + case Type: + { + alt12=8; + } + break; + case Action: + { + alt12=9; + } + break; + case Duration: + { + alt12=10; + } + break; + case Time: + { + alt12=11; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 12, 0, input); + + throw nvae; + } + + switch (alt12) { + case 1 : + // InternalRos1Parser.g:2852:2: ( Goal ) + { + // InternalRos1Parser.g:2852:2: ( Goal ) + // InternalRos1Parser.g:2853:3: Goal + { + before(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); + match(input,Goal,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:2858:2: ( Message ) + { + // InternalRos1Parser.g:2858:2: ( Message ) + // InternalRos1Parser.g:2859:3: Message + { + before(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); + match(input,Message,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:2864:2: ( Result ) + { + // InternalRos1Parser.g:2864:2: ( Result ) + // InternalRos1Parser.g:2865:3: Result + { + before(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); + match(input,Result,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); + + } + + + } + break; + case 4 : + // InternalRos1Parser.g:2870:2: ( Feedback ) + { + // InternalRos1Parser.g:2870:2: ( Feedback ) + // InternalRos1Parser.g:2871:3: Feedback + { + before(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); + match(input,Feedback,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); + + } + + + } + break; + case 5 : + // InternalRos1Parser.g:2876:2: ( Name ) + { + // InternalRos1Parser.g:2876:2: ( Name ) + // InternalRos1Parser.g:2877:3: Name + { + before(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); + match(input,Name,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); + + } + + + } + break; + case 6 : + // InternalRos1Parser.g:2882:2: ( Value ) + { + // InternalRos1Parser.g:2882:2: ( Value ) + // InternalRos1Parser.g:2883:3: Value + { + before(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); + match(input,Value,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); + + } + + + } + break; + case 7 : + // InternalRos1Parser.g:2888:2: ( Service ) + { + // InternalRos1Parser.g:2888:2: ( Service ) + // InternalRos1Parser.g:2889:3: Service + { + before(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); + match(input,Service,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); + + } + + + } + break; + case 8 : + // InternalRos1Parser.g:2894:2: ( Type ) + { + // InternalRos1Parser.g:2894:2: ( Type ) + // InternalRos1Parser.g:2895:3: Type + { + before(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); + match(input,Type,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); + + } + + + } + break; + case 9 : + // InternalRos1Parser.g:2900:2: ( Action ) + { + // InternalRos1Parser.g:2900:2: ( Action ) + // InternalRos1Parser.g:2901:3: Action + { + before(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); + match(input,Action,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); + + } + + + } + break; + case 10 : + // InternalRos1Parser.g:2906:2: ( Duration ) + { + // InternalRos1Parser.g:2906:2: ( Duration ) + // InternalRos1Parser.g:2907:3: Duration + { + before(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); + match(input,Duration,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); + + } + + + } + break; + case 11 : + // InternalRos1Parser.g:2912:2: ( Time ) + { + // InternalRos1Parser.g:2912:2: ( Time ) + // InternalRos1Parser.g:2913:3: Time + { + before(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); + match(input,Time,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__KEYWORD__Alternatives" + + + // $ANTLR start "rule__CatkinPackage__Group__0" + // InternalRos1Parser.g:2922: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:2926:1: ( rule__CatkinPackage__Group__0__Impl rule__CatkinPackage__Group__1 ) + // InternalRos1Parser.g:2927: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:2934:1: rule__CatkinPackage__Group__0__Impl : ( () ) ; + public final void rule__CatkinPackage__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2938:1: ( ( () ) ) + // InternalRos1Parser.g:2939:1: ( () ) + { + // InternalRos1Parser.g:2939:1: ( () ) + // InternalRos1Parser.g:2940:2: () + { + before(grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0()); + // InternalRos1Parser.g:2941:2: () + // InternalRos1Parser.g:2941: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:2949: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:2953:1: ( rule__CatkinPackage__Group__1__Impl rule__CatkinPackage__Group__2 ) + // InternalRos1Parser.g:2954: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:2961: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:2965:1: ( ( ( rule__CatkinPackage__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:2966:1: ( ( rule__CatkinPackage__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:2966:1: ( ( rule__CatkinPackage__NameAssignment_1 ) ) + // InternalRos1Parser.g:2967:2: ( rule__CatkinPackage__NameAssignment_1 ) + { + before(grammarAccess.getCatkinPackageAccess().getNameAssignment_1()); + // InternalRos1Parser.g:2968:2: ( rule__CatkinPackage__NameAssignment_1 ) + // InternalRos1Parser.g:2968: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:2976: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:2980:1: ( rule__CatkinPackage__Group__2__Impl rule__CatkinPackage__Group__3 ) + // InternalRos1Parser.g:2981: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:2988:1: rule__CatkinPackage__Group__2__Impl : ( Colon ) ; + public final void rule__CatkinPackage__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2992:1: ( ( Colon ) ) + // InternalRos1Parser.g:2993:1: ( Colon ) + { + // InternalRos1Parser.g:2993:1: ( Colon ) + // InternalRos1Parser.g:2994: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:3003: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:3007:1: ( rule__CatkinPackage__Group__3__Impl rule__CatkinPackage__Group__4 ) + // InternalRos1Parser.g:3008: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:3015:1: rule__CatkinPackage__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__CatkinPackage__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3019:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:3020:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:3020:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:3021: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:3030: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:3034:1: ( rule__CatkinPackage__Group__4__Impl rule__CatkinPackage__Group__5 ) + // InternalRos1Parser.g:3035: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:3042: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:3046:1: ( ( ( rule__CatkinPackage__Group_4__0 )? ) ) + // InternalRos1Parser.g:3047:1: ( ( rule__CatkinPackage__Group_4__0 )? ) + { + // InternalRos1Parser.g:3047:1: ( ( rule__CatkinPackage__Group_4__0 )? ) + // InternalRos1Parser.g:3048:2: ( rule__CatkinPackage__Group_4__0 )? + { + before(grammarAccess.getCatkinPackageAccess().getGroup_4()); + // InternalRos1Parser.g:3049:2: ( rule__CatkinPackage__Group_4__0 )? + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==FromGitRepo) ) { + alt13=1; + } + switch (alt13) { + case 1 : + // InternalRos1Parser.g:3049: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:3057: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:3061:1: ( rule__CatkinPackage__Group__5__Impl rule__CatkinPackage__Group__6 ) + // InternalRos1Parser.g:3062: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:3069: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:3073:1: ( ( ( rule__CatkinPackage__Group_5__0 )? ) ) + // InternalRos1Parser.g:3074:1: ( ( rule__CatkinPackage__Group_5__0 )? ) + { + // InternalRos1Parser.g:3074:1: ( ( rule__CatkinPackage__Group_5__0 )? ) + // InternalRos1Parser.g:3075:2: ( rule__CatkinPackage__Group_5__0 )? + { + before(grammarAccess.getCatkinPackageAccess().getGroup_5()); + // InternalRos1Parser.g:3076:2: ( rule__CatkinPackage__Group_5__0 )? + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0==Artifacts) ) { + alt14=1; + } + switch (alt14) { + case 1 : + // InternalRos1Parser.g:3076: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:3084: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:3088:1: ( rule__CatkinPackage__Group__6__Impl rule__CatkinPackage__Group__7 ) + // InternalRos1Parser.g:3089: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:3096: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:3100:1: ( ( ( rule__CatkinPackage__Group_6__0 )? ) ) + // InternalRos1Parser.g:3101:1: ( ( rule__CatkinPackage__Group_6__0 )? ) + { + // InternalRos1Parser.g:3101:1: ( ( rule__CatkinPackage__Group_6__0 )? ) + // InternalRos1Parser.g:3102:2: ( rule__CatkinPackage__Group_6__0 )? + { + before(grammarAccess.getCatkinPackageAccess().getGroup_6()); + // InternalRos1Parser.g:3103:2: ( rule__CatkinPackage__Group_6__0 )? + int alt15=2; + int LA15_0 = input.LA(1); + + if ( (LA15_0==Dependencies) ) { + alt15=1; + } + switch (alt15) { + case 1 : + // InternalRos1Parser.g:3103: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:3111: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:3115:1: ( rule__CatkinPackage__Group__7__Impl ) + // InternalRos1Parser.g:3116: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:3122:1: rule__CatkinPackage__Group__7__Impl : ( RULE_END ) ; + public final void rule__CatkinPackage__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3126:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:3127:1: ( RULE_END ) + { + // InternalRos1Parser.g:3127:1: ( RULE_END ) + // InternalRos1Parser.g:3128: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:3138: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:3142:1: ( rule__CatkinPackage__Group_4__0__Impl rule__CatkinPackage__Group_4__1 ) + // InternalRos1Parser.g:3143: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:3150: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:3154:1: ( ( FromGitRepo ) ) + // InternalRos1Parser.g:3155:1: ( FromGitRepo ) + { + // InternalRos1Parser.g:3155:1: ( FromGitRepo ) + // InternalRos1Parser.g:3156: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:3165: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:3169:1: ( rule__CatkinPackage__Group_4__1__Impl ) + // InternalRos1Parser.g:3170: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:3176: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:3180:1: ( ( ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) ) ) + // InternalRos1Parser.g:3181:1: ( ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) ) + { + // InternalRos1Parser.g:3181:1: ( ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) ) + // InternalRos1Parser.g:3182:2: ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) + { + before(grammarAccess.getCatkinPackageAccess().getFromGitRepoAssignment_4_1()); + // InternalRos1Parser.g:3183:2: ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) + // InternalRos1Parser.g:3183: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:3192: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:3196:1: ( rule__CatkinPackage__Group_5__0__Impl rule__CatkinPackage__Group_5__1 ) + // InternalRos1Parser.g:3197: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:3204: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:3208:1: ( ( Artifacts ) ) + // InternalRos1Parser.g:3209:1: ( Artifacts ) + { + // InternalRos1Parser.g:3209:1: ( Artifacts ) + // InternalRos1Parser.g:3210: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:3219: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:3223:1: ( rule__CatkinPackage__Group_5__1__Impl rule__CatkinPackage__Group_5__2 ) + // InternalRos1Parser.g:3224: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:3231: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:3235:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:3236:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:3236:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:3237: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:3246: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:3250:1: ( rule__CatkinPackage__Group_5__2__Impl rule__CatkinPackage__Group_5__3 ) + // InternalRos1Parser.g:3251: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:3258: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:3262:1: ( ( ( rule__CatkinPackage__ArtifactAssignment_5_2 )* ) ) + // InternalRos1Parser.g:3263:1: ( ( rule__CatkinPackage__ArtifactAssignment_5_2 )* ) + { + // InternalRos1Parser.g:3263:1: ( ( rule__CatkinPackage__ArtifactAssignment_5_2 )* ) + // InternalRos1Parser.g:3264:2: ( rule__CatkinPackage__ArtifactAssignment_5_2 )* + { + before(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_5_2()); + // InternalRos1Parser.g:3265:2: ( rule__CatkinPackage__ArtifactAssignment_5_2 )* + loop16: + do { + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0==Node||(LA16_0>=RULE_ID && LA16_0<=RULE_ROS_CONVENTION_A)) ) { + alt16=1; + } + + + switch (alt16) { + case 1 : + // InternalRos1Parser.g:3265:3: rule__CatkinPackage__ArtifactAssignment_5_2 + { + pushFollow(FOLLOW_9); + rule__CatkinPackage__ArtifactAssignment_5_2(); + + state._fsp--; + + + } + break; + + default : + break loop16; + } + } 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:3273: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:3277:1: ( rule__CatkinPackage__Group_5__3__Impl ) + // InternalRos1Parser.g:3278: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:3284: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:3288:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:3289:1: ( RULE_END ) + { + // InternalRos1Parser.g:3289:1: ( RULE_END ) + // InternalRos1Parser.g:3290: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:3300: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:3304:1: ( rule__CatkinPackage__Group_6__0__Impl rule__CatkinPackage__Group_6__1 ) + // InternalRos1Parser.g:3305: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:3312: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:3316:1: ( ( Dependencies ) ) + // InternalRos1Parser.g:3317:1: ( Dependencies ) + { + // InternalRos1Parser.g:3317:1: ( Dependencies ) + // InternalRos1Parser.g:3318: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:3327: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:3331:1: ( rule__CatkinPackage__Group_6__1__Impl rule__CatkinPackage__Group_6__2 ) + // InternalRos1Parser.g:3332: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:3339: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:3343:1: ( ( LeftSquareBracket ) ) + // InternalRos1Parser.g:3344:1: ( LeftSquareBracket ) + { + // InternalRos1Parser.g:3344:1: ( LeftSquareBracket ) + // InternalRos1Parser.g:3345: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:3354: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:3358:1: ( rule__CatkinPackage__Group_6__2__Impl rule__CatkinPackage__Group_6__3 ) + // InternalRos1Parser.g:3359: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:3366: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:3370:1: ( ( ( rule__CatkinPackage__DependencyAssignment_6_2 ) ) ) + // InternalRos1Parser.g:3371:1: ( ( rule__CatkinPackage__DependencyAssignment_6_2 ) ) + { + // InternalRos1Parser.g:3371:1: ( ( rule__CatkinPackage__DependencyAssignment_6_2 ) ) + // InternalRos1Parser.g:3372:2: ( rule__CatkinPackage__DependencyAssignment_6_2 ) + { + before(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_2()); + // InternalRos1Parser.g:3373:2: ( rule__CatkinPackage__DependencyAssignment_6_2 ) + // InternalRos1Parser.g:3373: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:3381: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:3385:1: ( rule__CatkinPackage__Group_6__3__Impl rule__CatkinPackage__Group_6__4 ) + // InternalRos1Parser.g:3386: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:3393: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:3397:1: ( ( ( rule__CatkinPackage__Group_6_3__0 )* ) ) + // InternalRos1Parser.g:3398:1: ( ( rule__CatkinPackage__Group_6_3__0 )* ) + { + // InternalRos1Parser.g:3398:1: ( ( rule__CatkinPackage__Group_6_3__0 )* ) + // InternalRos1Parser.g:3399:2: ( rule__CatkinPackage__Group_6_3__0 )* + { + before(grammarAccess.getCatkinPackageAccess().getGroup_6_3()); + // InternalRos1Parser.g:3400:2: ( rule__CatkinPackage__Group_6_3__0 )* + loop17: + do { + int alt17=2; + int LA17_0 = input.LA(1); + + if ( (LA17_0==Comma) ) { + alt17=1; + } + + + switch (alt17) { + case 1 : + // InternalRos1Parser.g:3400:3: rule__CatkinPackage__Group_6_3__0 + { + pushFollow(FOLLOW_13); + rule__CatkinPackage__Group_6_3__0(); + + state._fsp--; + + + } + break; + + default : + break loop17; + } + } 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:3408: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:3412:1: ( rule__CatkinPackage__Group_6__4__Impl ) + // InternalRos1Parser.g:3413: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:3419: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:3423:1: ( ( RightSquareBracket ) ) + // InternalRos1Parser.g:3424:1: ( RightSquareBracket ) + { + // InternalRos1Parser.g:3424:1: ( RightSquareBracket ) + // InternalRos1Parser.g:3425: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:3435: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:3439:1: ( rule__CatkinPackage__Group_6_3__0__Impl rule__CatkinPackage__Group_6_3__1 ) + // InternalRos1Parser.g:3440: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:3447: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:3451:1: ( ( Comma ) ) + // InternalRos1Parser.g:3452:1: ( Comma ) + { + // InternalRos1Parser.g:3452:1: ( Comma ) + // InternalRos1Parser.g:3453: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:3462: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:3466:1: ( rule__CatkinPackage__Group_6_3__1__Impl ) + // InternalRos1Parser.g:3467: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:3473: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:3477:1: ( ( ( rule__CatkinPackage__DependencyAssignment_6_3_1 ) ) ) + // InternalRos1Parser.g:3478:1: ( ( rule__CatkinPackage__DependencyAssignment_6_3_1 ) ) + { + // InternalRos1Parser.g:3478:1: ( ( rule__CatkinPackage__DependencyAssignment_6_3_1 ) ) + // InternalRos1Parser.g:3479:2: ( rule__CatkinPackage__DependencyAssignment_6_3_1 ) + { + before(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_3_1()); + // InternalRos1Parser.g:3480:2: ( rule__CatkinPackage__DependencyAssignment_6_3_1 ) + // InternalRos1Parser.g:3480: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__Package_Impl__Group__0" + // InternalRos1Parser.g:3489:1: rule__Package_Impl__Group__0 : rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 ; + public final void rule__Package_Impl__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3493:1: ( rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 ) + // InternalRos1Parser.g:3494:2: rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 + { + pushFollow(FOLLOW_3); + rule__Package_Impl__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__0" + + + // $ANTLR start "rule__Package_Impl__Group__0__Impl" + // InternalRos1Parser.g:3501:1: rule__Package_Impl__Group__0__Impl : ( () ) ; + public final void rule__Package_Impl__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3505:1: ( ( () ) ) + // InternalRos1Parser.g:3506:1: ( () ) + { + // InternalRos1Parser.g:3506:1: ( () ) + // InternalRos1Parser.g:3507:2: () + { + before(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); + // InternalRos1Parser.g:3508:2: () + // InternalRos1Parser.g:3508:3: + { + } + + after(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__0__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__1" + // InternalRos1Parser.g:3516:1: rule__Package_Impl__Group__1 : rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 ; + public final void rule__Package_Impl__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3520:1: ( rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 ) + // InternalRos1Parser.g:3521:2: rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 + { + pushFollow(FOLLOW_4); + rule__Package_Impl__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__1" + + + // $ANTLR start "rule__Package_Impl__Group__1__Impl" + // InternalRos1Parser.g:3528:1: rule__Package_Impl__Group__1__Impl : ( ( rule__Package_Impl__NameAssignment_1 ) ) ; + public final void rule__Package_Impl__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3532:1: ( ( ( rule__Package_Impl__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:3533:1: ( ( rule__Package_Impl__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:3533:1: ( ( rule__Package_Impl__NameAssignment_1 ) ) + // InternalRos1Parser.g:3534:2: ( rule__Package_Impl__NameAssignment_1 ) + { + before(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); + // InternalRos1Parser.g:3535:2: ( rule__Package_Impl__NameAssignment_1 ) + // InternalRos1Parser.g:3535:3: rule__Package_Impl__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__1__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__2" + // InternalRos1Parser.g:3543:1: rule__Package_Impl__Group__2 : rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 ; + public final void rule__Package_Impl__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3547:1: ( rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 ) + // InternalRos1Parser.g:3548:2: rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 + { + pushFollow(FOLLOW_5); + rule__Package_Impl__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__2" + + + // $ANTLR start "rule__Package_Impl__Group__2__Impl" + // InternalRos1Parser.g:3555:1: rule__Package_Impl__Group__2__Impl : ( Colon ) ; + public final void rule__Package_Impl__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3559:1: ( ( Colon ) ) + // InternalRos1Parser.g:3560:1: ( Colon ) + { + // InternalRos1Parser.g:3560:1: ( Colon ) + // InternalRos1Parser.g:3561:2: Colon + { + before(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__2__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__3" + // InternalRos1Parser.g:3570:1: rule__Package_Impl__Group__3 : rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 ; + public final void rule__Package_Impl__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3574:1: ( rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 ) + // InternalRos1Parser.g:3575:2: rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 + { + pushFollow(FOLLOW_14); + rule__Package_Impl__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__3" + + + // $ANTLR start "rule__Package_Impl__Group__3__Impl" + // InternalRos1Parser.g:3582:1: rule__Package_Impl__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Package_Impl__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3586:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:3587:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:3587:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:3588:2: RULE_BEGIN + { + before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__3__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__4" + // InternalRos1Parser.g:3597:1: rule__Package_Impl__Group__4 : rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 ; + public final void rule__Package_Impl__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3601:1: ( rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 ) + // InternalRos1Parser.g:3602:2: rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 + { + pushFollow(FOLLOW_14); + rule__Package_Impl__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__4" + + + // $ANTLR start "rule__Package_Impl__Group__4__Impl" + // InternalRos1Parser.g:3609:1: rule__Package_Impl__Group__4__Impl : ( ( rule__Package_Impl__Group_4__0 )? ) ; + public final void rule__Package_Impl__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3613:1: ( ( ( rule__Package_Impl__Group_4__0 )? ) ) + // InternalRos1Parser.g:3614:1: ( ( rule__Package_Impl__Group_4__0 )? ) + { + // InternalRos1Parser.g:3614:1: ( ( rule__Package_Impl__Group_4__0 )? ) + // InternalRos1Parser.g:3615:2: ( rule__Package_Impl__Group_4__0 )? + { + before(grammarAccess.getPackage_ImplAccess().getGroup_4()); + // InternalRos1Parser.g:3616:2: ( rule__Package_Impl__Group_4__0 )? + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0==FromGitRepo) ) { + alt18=1; + } + switch (alt18) { + case 1 : + // InternalRos1Parser.g:3616:3: rule__Package_Impl__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_4__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPackage_ImplAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__4__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__5" + // InternalRos1Parser.g:3624:1: rule__Package_Impl__Group__5 : rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 ; + public final void rule__Package_Impl__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3628:1: ( rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 ) + // InternalRos1Parser.g:3629:2: rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 + { + pushFollow(FOLLOW_14); + rule__Package_Impl__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__5" + + + // $ANTLR start "rule__Package_Impl__Group__5__Impl" + // InternalRos1Parser.g:3636:1: rule__Package_Impl__Group__5__Impl : ( ( rule__Package_Impl__Group_5__0 )? ) ; + public final void rule__Package_Impl__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3640:1: ( ( ( rule__Package_Impl__Group_5__0 )? ) ) + // InternalRos1Parser.g:3641:1: ( ( rule__Package_Impl__Group_5__0 )? ) + { + // InternalRos1Parser.g:3641:1: ( ( rule__Package_Impl__Group_5__0 )? ) + // InternalRos1Parser.g:3642:2: ( rule__Package_Impl__Group_5__0 )? + { + before(grammarAccess.getPackage_ImplAccess().getGroup_5()); + // InternalRos1Parser.g:3643:2: ( rule__Package_Impl__Group_5__0 )? + int alt19=2; + int LA19_0 = input.LA(1); + + if ( (LA19_0==Specs) ) { + alt19=1; + } + switch (alt19) { + case 1 : + // InternalRos1Parser.g:3643:3: rule__Package_Impl__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPackage_ImplAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__5__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__6" + // InternalRos1Parser.g:3651:1: rule__Package_Impl__Group__6 : rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 ; + public final void rule__Package_Impl__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3655:1: ( rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 ) + // InternalRos1Parser.g:3656:2: rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 + { + pushFollow(FOLLOW_14); + rule__Package_Impl__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__6" + + + // $ANTLR start "rule__Package_Impl__Group__6__Impl" + // InternalRos1Parser.g:3663:1: rule__Package_Impl__Group__6__Impl : ( ( rule__Package_Impl__Group_6__0 )? ) ; + public final void rule__Package_Impl__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3667:1: ( ( ( rule__Package_Impl__Group_6__0 )? ) ) + // InternalRos1Parser.g:3668:1: ( ( rule__Package_Impl__Group_6__0 )? ) + { + // InternalRos1Parser.g:3668:1: ( ( rule__Package_Impl__Group_6__0 )? ) + // InternalRos1Parser.g:3669:2: ( rule__Package_Impl__Group_6__0 )? + { + before(grammarAccess.getPackage_ImplAccess().getGroup_6()); + // InternalRos1Parser.g:3670:2: ( rule__Package_Impl__Group_6__0 )? + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0==Dependencies) ) { + alt20=1; + } + switch (alt20) { + case 1 : + // InternalRos1Parser.g:3670:3: rule__Package_Impl__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPackage_ImplAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__6__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__7" + // InternalRos1Parser.g:3678:1: rule__Package_Impl__Group__7 : rule__Package_Impl__Group__7__Impl ; + public final void rule__Package_Impl__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3682:1: ( rule__Package_Impl__Group__7__Impl ) + // InternalRos1Parser.g:3683:2: rule__Package_Impl__Group__7__Impl + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__7__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__7" + + + // $ANTLR start "rule__Package_Impl__Group__7__Impl" + // InternalRos1Parser.g:3689:1: rule__Package_Impl__Group__7__Impl : ( RULE_END ) ; + public final void rule__Package_Impl__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3693:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:3694:1: ( RULE_END ) + { + // InternalRos1Parser.g:3694:1: ( RULE_END ) + // InternalRos1Parser.g:3695:2: RULE_END + { + before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__7__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_4__0" + // InternalRos1Parser.g:3705:1: rule__Package_Impl__Group_4__0 : rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 ; + public final void rule__Package_Impl__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3709:1: ( rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 ) + // InternalRos1Parser.g:3710:2: rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 + { + pushFollow(FOLLOW_7); + rule__Package_Impl__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_4__0" + + + // $ANTLR start "rule__Package_Impl__Group_4__0__Impl" + // InternalRos1Parser.g:3717:1: rule__Package_Impl__Group_4__0__Impl : ( FromGitRepo ) ; + public final void rule__Package_Impl__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3721:1: ( ( FromGitRepo ) ) + // InternalRos1Parser.g:3722:1: ( FromGitRepo ) + { + // InternalRos1Parser.g:3722:1: ( FromGitRepo ) + // InternalRos1Parser.g:3723:2: FromGitRepo + { + before(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); + match(input,FromGitRepo,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_4__0__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_4__1" + // InternalRos1Parser.g:3732:1: rule__Package_Impl__Group_4__1 : rule__Package_Impl__Group_4__1__Impl ; + public final void rule__Package_Impl__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3736:1: ( rule__Package_Impl__Group_4__1__Impl ) + // InternalRos1Parser.g:3737:2: rule__Package_Impl__Group_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_4__1" + + + // $ANTLR start "rule__Package_Impl__Group_4__1__Impl" + // InternalRos1Parser.g:3743:1: rule__Package_Impl__Group_4__1__Impl : ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) ; + public final void rule__Package_Impl__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3747:1: ( ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) ) + // InternalRos1Parser.g:3748:1: ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) + { + // InternalRos1Parser.g:3748:1: ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) + // InternalRos1Parser.g:3749:2: ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) + { + before(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); + // InternalRos1Parser.g:3750:2: ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) + // InternalRos1Parser.g:3750:3: rule__Package_Impl__FromGitRepoAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__FromGitRepoAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_4__1__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_5__0" + // InternalRos1Parser.g:3759:1: rule__Package_Impl__Group_5__0 : rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 ; + public final void rule__Package_Impl__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3763:1: ( rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 ) + // InternalRos1Parser.g:3764:2: rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 + { + pushFollow(FOLLOW_5); + rule__Package_Impl__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__0" + + + // $ANTLR start "rule__Package_Impl__Group_5__0__Impl" + // InternalRos1Parser.g:3771:1: rule__Package_Impl__Group_5__0__Impl : ( Specs ) ; + public final void rule__Package_Impl__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3775:1: ( ( Specs ) ) + // InternalRos1Parser.g:3776:1: ( Specs ) + { + // InternalRos1Parser.g:3776:1: ( Specs ) + // InternalRos1Parser.g:3777:2: Specs + { + before(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + match(input,Specs,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__0__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_5__1" + // InternalRos1Parser.g:3786:1: rule__Package_Impl__Group_5__1 : rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 ; + public final void rule__Package_Impl__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3790:1: ( rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 ) + // InternalRos1Parser.g:3791:2: rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 + { + pushFollow(FOLLOW_15); + rule__Package_Impl__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__1" + + + // $ANTLR start "rule__Package_Impl__Group_5__1__Impl" + // InternalRos1Parser.g:3798:1: rule__Package_Impl__Group_5__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Package_Impl__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3802:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:3803:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:3803:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:3804:2: RULE_BEGIN + { + before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__1__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_5__2" + // InternalRos1Parser.g:3813:1: rule__Package_Impl__Group_5__2 : rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 ; + public final void rule__Package_Impl__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3817:1: ( rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 ) + // InternalRos1Parser.g:3818:2: rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 + { + pushFollow(FOLLOW_15); + rule__Package_Impl__Group_5__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_5__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__2" + + + // $ANTLR start "rule__Package_Impl__Group_5__2__Impl" + // InternalRos1Parser.g:3825:1: rule__Package_Impl__Group_5__2__Impl : ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) ; + public final void rule__Package_Impl__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3829:1: ( ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) ) + // InternalRos1Parser.g:3830:1: ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) + { + // InternalRos1Parser.g:3830:1: ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) + // InternalRos1Parser.g:3831:2: ( rule__Package_Impl__SpecAssignment_5_2 )* + { + before(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); + // InternalRos1Parser.g:3832:2: ( rule__Package_Impl__SpecAssignment_5_2 )* + loop21: + do { + int alt21=2; + int LA21_0 = input.LA(1); + + if ( (LA21_0==Action_1||LA21_0==Msg||LA21_0==Srv) ) { + alt21=1; + } + + + switch (alt21) { + case 1 : + // InternalRos1Parser.g:3832:3: rule__Package_Impl__SpecAssignment_5_2 + { + pushFollow(FOLLOW_16); + rule__Package_Impl__SpecAssignment_5_2(); + + state._fsp--; + + + } + break; + + default : + break loop21; + } + } while (true); + + after(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__2__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_5__3" + // InternalRos1Parser.g:3840:1: rule__Package_Impl__Group_5__3 : rule__Package_Impl__Group_5__3__Impl ; + public final void rule__Package_Impl__Group_5__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3844:1: ( rule__Package_Impl__Group_5__3__Impl ) + // InternalRos1Parser.g:3845:2: rule__Package_Impl__Group_5__3__Impl + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_5__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__3" + + + // $ANTLR start "rule__Package_Impl__Group_5__3__Impl" + // InternalRos1Parser.g:3851:1: rule__Package_Impl__Group_5__3__Impl : ( RULE_END ) ; + public final void rule__Package_Impl__Group_5__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3855:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:3856:1: ( RULE_END ) + { + // InternalRos1Parser.g:3856:1: ( RULE_END ) + // InternalRos1Parser.g:3857:2: RULE_END + { + before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__3__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6__0" + // InternalRos1Parser.g:3867:1: rule__Package_Impl__Group_6__0 : rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 ; + public final void rule__Package_Impl__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3871:1: ( rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 ) + // InternalRos1Parser.g:3872:2: rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 + { + pushFollow(FOLLOW_10); + rule__Package_Impl__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__0" + + + // $ANTLR start "rule__Package_Impl__Group_6__0__Impl" + // InternalRos1Parser.g:3879:1: rule__Package_Impl__Group_6__0__Impl : ( Dependencies ) ; + public final void rule__Package_Impl__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3883:1: ( ( Dependencies ) ) + // InternalRos1Parser.g:3884:1: ( Dependencies ) + { + // InternalRos1Parser.g:3884:1: ( Dependencies ) + // InternalRos1Parser.g:3885:2: Dependencies + { + before(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); + match(input,Dependencies,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__0__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6__1" + // InternalRos1Parser.g:3894:1: rule__Package_Impl__Group_6__1 : rule__Package_Impl__Group_6__1__Impl rule__Package_Impl__Group_6__2 ; + public final void rule__Package_Impl__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3898:1: ( rule__Package_Impl__Group_6__1__Impl rule__Package_Impl__Group_6__2 ) + // InternalRos1Parser.g:3899:2: rule__Package_Impl__Group_6__1__Impl rule__Package_Impl__Group_6__2 + { + pushFollow(FOLLOW_11); + rule__Package_Impl__Group_6__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__1" + + + // $ANTLR start "rule__Package_Impl__Group_6__1__Impl" + // InternalRos1Parser.g:3906:1: rule__Package_Impl__Group_6__1__Impl : ( LeftSquareBracket ) ; + public final void rule__Package_Impl__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3910:1: ( ( LeftSquareBracket ) ) + // InternalRos1Parser.g:3911:1: ( LeftSquareBracket ) + { + // InternalRos1Parser.g:3911:1: ( LeftSquareBracket ) + // InternalRos1Parser.g:3912:2: LeftSquareBracket + { + before(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__1__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6__2" + // InternalRos1Parser.g:3921:1: rule__Package_Impl__Group_6__2 : rule__Package_Impl__Group_6__2__Impl rule__Package_Impl__Group_6__3 ; + public final void rule__Package_Impl__Group_6__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3925:1: ( rule__Package_Impl__Group_6__2__Impl rule__Package_Impl__Group_6__3 ) + // InternalRos1Parser.g:3926:2: rule__Package_Impl__Group_6__2__Impl rule__Package_Impl__Group_6__3 + { + pushFollow(FOLLOW_12); + rule__Package_Impl__Group_6__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__2" + + + // $ANTLR start "rule__Package_Impl__Group_6__2__Impl" + // InternalRos1Parser.g:3933:1: rule__Package_Impl__Group_6__2__Impl : ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) ; + public final void rule__Package_Impl__Group_6__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3937:1: ( ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) ) + // InternalRos1Parser.g:3938:1: ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) + { + // InternalRos1Parser.g:3938:1: ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) + // InternalRos1Parser.g:3939:2: ( rule__Package_Impl__DependencyAssignment_6_2 ) + { + before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); + // InternalRos1Parser.g:3940:2: ( rule__Package_Impl__DependencyAssignment_6_2 ) + // InternalRos1Parser.g:3940:3: rule__Package_Impl__DependencyAssignment_6_2 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__DependencyAssignment_6_2(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__2__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6__3" + // InternalRos1Parser.g:3948:1: rule__Package_Impl__Group_6__3 : rule__Package_Impl__Group_6__3__Impl rule__Package_Impl__Group_6__4 ; + public final void rule__Package_Impl__Group_6__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3952:1: ( rule__Package_Impl__Group_6__3__Impl rule__Package_Impl__Group_6__4 ) + // InternalRos1Parser.g:3953:2: rule__Package_Impl__Group_6__3__Impl rule__Package_Impl__Group_6__4 + { + pushFollow(FOLLOW_12); + rule__Package_Impl__Group_6__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__3" + + + // $ANTLR start "rule__Package_Impl__Group_6__3__Impl" + // InternalRos1Parser.g:3960:1: rule__Package_Impl__Group_6__3__Impl : ( ( rule__Package_Impl__Group_6_3__0 )* ) ; + public final void rule__Package_Impl__Group_6__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3964:1: ( ( ( rule__Package_Impl__Group_6_3__0 )* ) ) + // InternalRos1Parser.g:3965:1: ( ( rule__Package_Impl__Group_6_3__0 )* ) + { + // InternalRos1Parser.g:3965:1: ( ( rule__Package_Impl__Group_6_3__0 )* ) + // InternalRos1Parser.g:3966:2: ( rule__Package_Impl__Group_6_3__0 )* + { + before(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); + // InternalRos1Parser.g:3967:2: ( rule__Package_Impl__Group_6_3__0 )* + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( (LA22_0==Comma) ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalRos1Parser.g:3967:3: rule__Package_Impl__Group_6_3__0 + { + pushFollow(FOLLOW_13); + rule__Package_Impl__Group_6_3__0(); + + state._fsp--; + + + } + break; + + default : + break loop22; + } + } while (true); + + after(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__3__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6__4" + // InternalRos1Parser.g:3975:1: rule__Package_Impl__Group_6__4 : rule__Package_Impl__Group_6__4__Impl ; + public final void rule__Package_Impl__Group_6__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3979:1: ( rule__Package_Impl__Group_6__4__Impl ) + // InternalRos1Parser.g:3980:2: rule__Package_Impl__Group_6__4__Impl + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__4__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__4" + + + // $ANTLR start "rule__Package_Impl__Group_6__4__Impl" + // InternalRos1Parser.g:3986:1: rule__Package_Impl__Group_6__4__Impl : ( RightSquareBracket ) ; + public final void rule__Package_Impl__Group_6__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:3990:1: ( ( RightSquareBracket ) ) + // InternalRos1Parser.g:3991:1: ( RightSquareBracket ) + { + // InternalRos1Parser.g:3991:1: ( RightSquareBracket ) + // InternalRos1Parser.g:3992:2: RightSquareBracket + { + before(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__4__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6_3__0" + // InternalRos1Parser.g:4002:1: rule__Package_Impl__Group_6_3__0 : rule__Package_Impl__Group_6_3__0__Impl rule__Package_Impl__Group_6_3__1 ; + public final void rule__Package_Impl__Group_6_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4006:1: ( rule__Package_Impl__Group_6_3__0__Impl rule__Package_Impl__Group_6_3__1 ) + // InternalRos1Parser.g:4007:2: rule__Package_Impl__Group_6_3__0__Impl rule__Package_Impl__Group_6_3__1 + { + pushFollow(FOLLOW_11); + rule__Package_Impl__Group_6_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6_3__0" + + + // $ANTLR start "rule__Package_Impl__Group_6_3__0__Impl" + // InternalRos1Parser.g:4014:1: rule__Package_Impl__Group_6_3__0__Impl : ( Comma ) ; + public final void rule__Package_Impl__Group_6_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4018:1: ( ( Comma ) ) + // InternalRos1Parser.g:4019:1: ( Comma ) + { + // InternalRos1Parser.g:4019:1: ( Comma ) + // InternalRos1Parser.g:4020:2: Comma + { + before(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6_3__0__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6_3__1" + // InternalRos1Parser.g:4029:1: rule__Package_Impl__Group_6_3__1 : rule__Package_Impl__Group_6_3__1__Impl ; + public final void rule__Package_Impl__Group_6_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4033:1: ( rule__Package_Impl__Group_6_3__1__Impl ) + // InternalRos1Parser.g:4034:2: rule__Package_Impl__Group_6_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6_3__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6_3__1" + + + // $ANTLR start "rule__Package_Impl__Group_6_3__1__Impl" + // InternalRos1Parser.g:4040:1: rule__Package_Impl__Group_6_3__1__Impl : ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) ; + public final void rule__Package_Impl__Group_6_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4044:1: ( ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) ) + // InternalRos1Parser.g:4045:1: ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) + { + // InternalRos1Parser.g:4045:1: ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) + // InternalRos1Parser.g:4046:2: ( rule__Package_Impl__DependencyAssignment_6_3_1 ) + { + before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1()); + // InternalRos1Parser.g:4047:2: ( rule__Package_Impl__DependencyAssignment_6_3_1 ) + // InternalRos1Parser.g:4047:3: rule__Package_Impl__DependencyAssignment_6_3_1 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__DependencyAssignment_6_3_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6_3__1__Impl" + + + // $ANTLR start "rule__Artifact__Group__0" + // InternalRos1Parser.g:4056: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:4060:1: ( rule__Artifact__Group__0__Impl rule__Artifact__Group__1 ) + // InternalRos1Parser.g:4061: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:4068:1: rule__Artifact__Group__0__Impl : ( () ) ; + public final void rule__Artifact__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4072:1: ( ( () ) ) + // InternalRos1Parser.g:4073:1: ( () ) + { + // InternalRos1Parser.g:4073:1: ( () ) + // InternalRos1Parser.g:4074:2: () + { + before(grammarAccess.getArtifactAccess().getArtifactAction_0()); + // InternalRos1Parser.g:4075:2: () + // InternalRos1Parser.g:4075: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:4083: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:4087:1: ( rule__Artifact__Group__1__Impl rule__Artifact__Group__2 ) + // InternalRos1Parser.g:4088: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:4095: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:4099:1: ( ( ( rule__Artifact__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:4100:1: ( ( rule__Artifact__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:4100:1: ( ( rule__Artifact__NameAssignment_1 ) ) + // InternalRos1Parser.g:4101:2: ( rule__Artifact__NameAssignment_1 ) + { + before(grammarAccess.getArtifactAccess().getNameAssignment_1()); + // InternalRos1Parser.g:4102:2: ( rule__Artifact__NameAssignment_1 ) + // InternalRos1Parser.g:4102: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:4110: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:4114:1: ( rule__Artifact__Group__2__Impl rule__Artifact__Group__3 ) + // InternalRos1Parser.g:4115: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:4122:1: rule__Artifact__Group__2__Impl : ( Colon ) ; + public final void rule__Artifact__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4126:1: ( ( Colon ) ) + // InternalRos1Parser.g:4127:1: ( Colon ) + { + // InternalRos1Parser.g:4127:1: ( Colon ) + // InternalRos1Parser.g:4128: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:4137: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:4141:1: ( rule__Artifact__Group__3__Impl rule__Artifact__Group__4 ) + // InternalRos1Parser.g:4142:2: rule__Artifact__Group__3__Impl rule__Artifact__Group__4 + { + pushFollow(FOLLOW_17); + 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:4149:1: rule__Artifact__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Artifact__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4153:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:4154:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:4154:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:4155: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:4164: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:4168:1: ( rule__Artifact__Group__4__Impl rule__Artifact__Group__5 ) + // InternalRos1Parser.g:4169:2: rule__Artifact__Group__4__Impl rule__Artifact__Group__5 + { + pushFollow(FOLLOW_17); + 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:4176: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:4180:1: ( ( ( rule__Artifact__NodeAssignment_4 )? ) ) + // InternalRos1Parser.g:4181:1: ( ( rule__Artifact__NodeAssignment_4 )? ) + { + // InternalRos1Parser.g:4181:1: ( ( rule__Artifact__NodeAssignment_4 )? ) + // InternalRos1Parser.g:4182:2: ( rule__Artifact__NodeAssignment_4 )? + { + before(grammarAccess.getArtifactAccess().getNodeAssignment_4()); + // InternalRos1Parser.g:4183:2: ( rule__Artifact__NodeAssignment_4 )? + int alt23=2; + int LA23_0 = input.LA(1); + + if ( (LA23_0==Node_1) ) { + alt23=1; + } + switch (alt23) { + case 1 : + // InternalRos1Parser.g:4183: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:4191: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:4195:1: ( rule__Artifact__Group__5__Impl ) + // InternalRos1Parser.g:4196: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:4202:1: rule__Artifact__Group__5__Impl : ( RULE_END ) ; + public final void rule__Artifact__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4206:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:4207:1: ( RULE_END ) + { + // InternalRos1Parser.g:4207:1: ( RULE_END ) + // InternalRos1Parser.g:4208: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:4218: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:4222:1: ( rule__Node__Group__0__Impl rule__Node__Group__1 ) + // InternalRos1Parser.g:4223: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:4230:1: rule__Node__Group__0__Impl : ( Node_1 ) ; + public final void rule__Node__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4234:1: ( ( Node_1 ) ) + // InternalRos1Parser.g:4235:1: ( Node_1 ) + { + // InternalRos1Parser.g:4235:1: ( Node_1 ) + // InternalRos1Parser.g:4236: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:4245: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:4249:1: ( rule__Node__Group__1__Impl rule__Node__Group__2 ) + // InternalRos1Parser.g:4250: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:4257: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:4261:1: ( ( ( rule__Node__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:4262:1: ( ( rule__Node__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:4262:1: ( ( rule__Node__NameAssignment_1 ) ) + // InternalRos1Parser.g:4263:2: ( rule__Node__NameAssignment_1 ) + { + before(grammarAccess.getNodeAccess().getNameAssignment_1()); + // InternalRos1Parser.g:4264:2: ( rule__Node__NameAssignment_1 ) + // InternalRos1Parser.g:4264: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:4272: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:4276:1: ( rule__Node__Group__2__Impl rule__Node__Group__3 ) + // InternalRos1Parser.g:4277:2: rule__Node__Group__2__Impl rule__Node__Group__3 + { + pushFollow(FOLLOW_18); + 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:4284:1: rule__Node__Group__2__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4288:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:4289:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:4289:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:4290: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:4299: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:4303:1: ( rule__Node__Group__3__Impl rule__Node__Group__4 ) + // InternalRos1Parser.g:4304:2: rule__Node__Group__3__Impl rule__Node__Group__4 + { + pushFollow(FOLLOW_18); + 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:4311:1: rule__Node__Group__3__Impl : ( ( rule__Node__Alternatives_3 )* ) ; + public final void rule__Node__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4315:1: ( ( ( rule__Node__Alternatives_3 )* ) ) + // InternalRos1Parser.g:4316:1: ( ( rule__Node__Alternatives_3 )* ) + { + // InternalRos1Parser.g:4316:1: ( ( rule__Node__Alternatives_3 )* ) + // InternalRos1Parser.g:4317:2: ( rule__Node__Alternatives_3 )* + { + before(grammarAccess.getNodeAccess().getAlternatives_3()); + // InternalRos1Parser.g:4318:2: ( rule__Node__Alternatives_3 )* + loop24: + do { + int alt24=2; + int LA24_0 = input.LA(1); + + if ( ((LA24_0>=Serviceclient && LA24_0<=Actionserver)||(LA24_0>=Subscribers && LA24_0<=Publishers)) ) { + alt24=1; + } + + + switch (alt24) { + case 1 : + // InternalRos1Parser.g:4318:3: rule__Node__Alternatives_3 + { + pushFollow(FOLLOW_19); + rule__Node__Alternatives_3(); + + state._fsp--; + + + } + break; + + default : + break loop24; + } + } while (true); + + after(grammarAccess.getNodeAccess().getAlternatives_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:4326:1: rule__Node__Group__4 : rule__Node__Group__4__Impl ; + public final void rule__Node__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4330:1: ( rule__Node__Group__4__Impl ) + // InternalRos1Parser.g:4331:2: rule__Node__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group__4__Impl(); + + 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:4337:1: rule__Node__Group__4__Impl : ( RULE_END ) ; + public final void rule__Node__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4341:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:4342:1: ( RULE_END ) + { + // InternalRos1Parser.g:4342:1: ( RULE_END ) + // InternalRos1Parser.g:4343:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_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_3_0__0" + // InternalRos1Parser.g:4353:1: rule__Node__Group_3_0__0 : rule__Node__Group_3_0__0__Impl rule__Node__Group_3_0__1 ; + public final void rule__Node__Group_3_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4357:1: ( rule__Node__Group_3_0__0__Impl rule__Node__Group_3_0__1 ) + // InternalRos1Parser.g:4358:2: rule__Node__Group_3_0__0__Impl rule__Node__Group_3_0__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_0__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_0__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__0" + + + // $ANTLR start "rule__Node__Group_3_0__0__Impl" + // InternalRos1Parser.g:4365:1: rule__Node__Group_3_0__0__Impl : ( Publishers ) ; + public final void rule__Node__Group_3_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4369:1: ( ( Publishers ) ) + // InternalRos1Parser.g:4370:1: ( Publishers ) + { + // InternalRos1Parser.g:4370:1: ( Publishers ) + // InternalRos1Parser.g:4371:2: Publishers + { + before(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); + match(input,Publishers,FOLLOW_2); + after(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_0__1" + // InternalRos1Parser.g:4380:1: rule__Node__Group_3_0__1 : rule__Node__Group_3_0__1__Impl rule__Node__Group_3_0__2 ; + public final void rule__Node__Group_3_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4384:1: ( rule__Node__Group_3_0__1__Impl rule__Node__Group_3_0__2 ) + // InternalRos1Parser.g:4385:2: rule__Node__Group_3_0__1__Impl rule__Node__Group_3_0__2 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_0__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_0__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__1" + + + // $ANTLR start "rule__Node__Group_3_0__1__Impl" + // InternalRos1Parser.g:4392:1: rule__Node__Group_3_0__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4396:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:4397:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:4397:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:4398:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_0__2" + // InternalRos1Parser.g:4407:1: rule__Node__Group_3_0__2 : rule__Node__Group_3_0__2__Impl rule__Node__Group_3_0__3 ; + public final void rule__Node__Group_3_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4411:1: ( rule__Node__Group_3_0__2__Impl rule__Node__Group_3_0__3 ) + // InternalRos1Parser.g:4412:2: rule__Node__Group_3_0__2__Impl rule__Node__Group_3_0__3 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_0__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_0__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__2" + + + // $ANTLR start "rule__Node__Group_3_0__2__Impl" + // InternalRos1Parser.g:4419:1: rule__Node__Group_3_0__2__Impl : ( ( rule__Node__PublisherAssignment_3_0_2 )* ) ; + public final void rule__Node__Group_3_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4423:1: ( ( ( rule__Node__PublisherAssignment_3_0_2 )* ) ) + // InternalRos1Parser.g:4424:1: ( ( rule__Node__PublisherAssignment_3_0_2 )* ) + { + // InternalRos1Parser.g:4424:1: ( ( rule__Node__PublisherAssignment_3_0_2 )* ) + // InternalRos1Parser.g:4425:2: ( rule__Node__PublisherAssignment_3_0_2 )* + { + before(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); + // InternalRos1Parser.g:4426:2: ( rule__Node__PublisherAssignment_3_0_2 )* + loop25: + do { + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0==RULE_ID||LA25_0==RULE_STRING) ) { + alt25=1; + } + + + switch (alt25) { + case 1 : + // InternalRos1Parser.g:4426:3: rule__Node__PublisherAssignment_3_0_2 + { + pushFollow(FOLLOW_21); + rule__Node__PublisherAssignment_3_0_2(); + + state._fsp--; + + + } + break; + + default : + break loop25; + } + } while (true); + + after(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_0__3" + // InternalRos1Parser.g:4434:1: rule__Node__Group_3_0__3 : rule__Node__Group_3_0__3__Impl ; + public final void rule__Node__Group_3_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4438:1: ( rule__Node__Group_3_0__3__Impl ) + // InternalRos1Parser.g:4439:2: rule__Node__Group_3_0__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_0__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__3" + + + // $ANTLR start "rule__Node__Group_3_0__3__Impl" + // InternalRos1Parser.g:4445:1: rule__Node__Group_3_0__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4449:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:4450:1: ( RULE_END ) + { + // InternalRos1Parser.g:4450:1: ( RULE_END ) + // InternalRos1Parser.g:4451:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_1__0" + // InternalRos1Parser.g:4461:1: rule__Node__Group_3_1__0 : rule__Node__Group_3_1__0__Impl rule__Node__Group_3_1__1 ; + public final void rule__Node__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4465:1: ( rule__Node__Group_3_1__0__Impl rule__Node__Group_3_1__1 ) + // InternalRos1Parser.g:4466:2: rule__Node__Group_3_1__0__Impl rule__Node__Group_3_1__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__0" + + + // $ANTLR start "rule__Node__Group_3_1__0__Impl" + // InternalRos1Parser.g:4473:1: rule__Node__Group_3_1__0__Impl : ( Subscribers ) ; + public final void rule__Node__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4477:1: ( ( Subscribers ) ) + // InternalRos1Parser.g:4478:1: ( Subscribers ) + { + // InternalRos1Parser.g:4478:1: ( Subscribers ) + // InternalRos1Parser.g:4479:2: Subscribers + { + before(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); + match(input,Subscribers,FOLLOW_2); + after(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_1__1" + // InternalRos1Parser.g:4488:1: rule__Node__Group_3_1__1 : rule__Node__Group_3_1__1__Impl rule__Node__Group_3_1__2 ; + public final void rule__Node__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4492:1: ( rule__Node__Group_3_1__1__Impl rule__Node__Group_3_1__2 ) + // InternalRos1Parser.g:4493:2: rule__Node__Group_3_1__1__Impl rule__Node__Group_3_1__2 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_1__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_1__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__1" + + + // $ANTLR start "rule__Node__Group_3_1__1__Impl" + // InternalRos1Parser.g:4500:1: rule__Node__Group_3_1__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4504:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:4505:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:4505:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:4506:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_1__2" + // InternalRos1Parser.g:4515:1: rule__Node__Group_3_1__2 : rule__Node__Group_3_1__2__Impl rule__Node__Group_3_1__3 ; + public final void rule__Node__Group_3_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4519:1: ( rule__Node__Group_3_1__2__Impl rule__Node__Group_3_1__3 ) + // InternalRos1Parser.g:4520:2: rule__Node__Group_3_1__2__Impl rule__Node__Group_3_1__3 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_1__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_1__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__2" + + + // $ANTLR start "rule__Node__Group_3_1__2__Impl" + // InternalRos1Parser.g:4527:1: rule__Node__Group_3_1__2__Impl : ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) ; + public final void rule__Node__Group_3_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4531:1: ( ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) ) + // InternalRos1Parser.g:4532:1: ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) + { + // InternalRos1Parser.g:4532:1: ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) + // InternalRos1Parser.g:4533:2: ( rule__Node__SubscriberAssignment_3_1_2 )* + { + before(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); + // InternalRos1Parser.g:4534:2: ( rule__Node__SubscriberAssignment_3_1_2 )* + loop26: + do { + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0==RULE_ID||LA26_0==RULE_STRING) ) { + alt26=1; + } + + + switch (alt26) { + case 1 : + // InternalRos1Parser.g:4534:3: rule__Node__SubscriberAssignment_3_1_2 + { + pushFollow(FOLLOW_21); + rule__Node__SubscriberAssignment_3_1_2(); + + state._fsp--; + + + } + break; + + default : + break loop26; + } + } while (true); + + after(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_1__3" + // InternalRos1Parser.g:4542:1: rule__Node__Group_3_1__3 : rule__Node__Group_3_1__3__Impl ; + public final void rule__Node__Group_3_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4546:1: ( rule__Node__Group_3_1__3__Impl ) + // InternalRos1Parser.g:4547:2: rule__Node__Group_3_1__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_1__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__3" + + + // $ANTLR start "rule__Node__Group_3_1__3__Impl" + // InternalRos1Parser.g:4553:1: rule__Node__Group_3_1__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4557:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:4558:1: ( RULE_END ) + { + // InternalRos1Parser.g:4558:1: ( RULE_END ) + // InternalRos1Parser.g:4559:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_2__0" + // InternalRos1Parser.g:4569:1: rule__Node__Group_3_2__0 : rule__Node__Group_3_2__0__Impl rule__Node__Group_3_2__1 ; + public final void rule__Node__Group_3_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4573:1: ( rule__Node__Group_3_2__0__Impl rule__Node__Group_3_2__1 ) + // InternalRos1Parser.g:4574:2: rule__Node__Group_3_2__0__Impl rule__Node__Group_3_2__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__0" + + + // $ANTLR start "rule__Node__Group_3_2__0__Impl" + // InternalRos1Parser.g:4581:1: rule__Node__Group_3_2__0__Impl : ( Serviceserver ) ; + public final void rule__Node__Group_3_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4585:1: ( ( Serviceserver ) ) + // InternalRos1Parser.g:4586:1: ( Serviceserver ) + { + // InternalRos1Parser.g:4586:1: ( Serviceserver ) + // InternalRos1Parser.g:4587:2: Serviceserver + { + before(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); + match(input,Serviceserver,FOLLOW_2); + after(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_2__1" + // InternalRos1Parser.g:4596:1: rule__Node__Group_3_2__1 : rule__Node__Group_3_2__1__Impl rule__Node__Group_3_2__2 ; + public final void rule__Node__Group_3_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4600:1: ( rule__Node__Group_3_2__1__Impl rule__Node__Group_3_2__2 ) + // InternalRos1Parser.g:4601:2: rule__Node__Group_3_2__1__Impl rule__Node__Group_3_2__2 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_2__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_2__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__1" + + + // $ANTLR start "rule__Node__Group_3_2__1__Impl" + // InternalRos1Parser.g:4608:1: rule__Node__Group_3_2__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4612:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:4613:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:4613:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:4614:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_2__2" + // InternalRos1Parser.g:4623:1: rule__Node__Group_3_2__2 : rule__Node__Group_3_2__2__Impl rule__Node__Group_3_2__3 ; + public final void rule__Node__Group_3_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4627:1: ( rule__Node__Group_3_2__2__Impl rule__Node__Group_3_2__3 ) + // InternalRos1Parser.g:4628:2: rule__Node__Group_3_2__2__Impl rule__Node__Group_3_2__3 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_2__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_2__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__2" + + + // $ANTLR start "rule__Node__Group_3_2__2__Impl" + // InternalRos1Parser.g:4635:1: rule__Node__Group_3_2__2__Impl : ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) ; + public final void rule__Node__Group_3_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4639:1: ( ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) ) + // InternalRos1Parser.g:4640:1: ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) + { + // InternalRos1Parser.g:4640:1: ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) + // InternalRos1Parser.g:4641:2: ( rule__Node__ServiceserverAssignment_3_2_2 )* + { + before(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); + // InternalRos1Parser.g:4642:2: ( rule__Node__ServiceserverAssignment_3_2_2 )* + loop27: + do { + int alt27=2; + int LA27_0 = input.LA(1); + + if ( (LA27_0==RULE_ID||LA27_0==RULE_STRING) ) { + alt27=1; + } + + + switch (alt27) { + case 1 : + // InternalRos1Parser.g:4642:3: rule__Node__ServiceserverAssignment_3_2_2 + { + pushFollow(FOLLOW_21); + rule__Node__ServiceserverAssignment_3_2_2(); + + state._fsp--; + + + } + break; + + default : + break loop27; + } + } while (true); + + after(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_2__3" + // InternalRos1Parser.g:4650:1: rule__Node__Group_3_2__3 : rule__Node__Group_3_2__3__Impl ; + public final void rule__Node__Group_3_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4654:1: ( rule__Node__Group_3_2__3__Impl ) + // InternalRos1Parser.g:4655:2: rule__Node__Group_3_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_2__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__3" + + + // $ANTLR start "rule__Node__Group_3_2__3__Impl" + // InternalRos1Parser.g:4661:1: rule__Node__Group_3_2__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4665:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:4666:1: ( RULE_END ) + { + // InternalRos1Parser.g:4666:1: ( RULE_END ) + // InternalRos1Parser.g:4667:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_3__0" + // InternalRos1Parser.g:4677:1: rule__Node__Group_3_3__0 : rule__Node__Group_3_3__0__Impl rule__Node__Group_3_3__1 ; + public final void rule__Node__Group_3_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4681:1: ( rule__Node__Group_3_3__0__Impl rule__Node__Group_3_3__1 ) + // InternalRos1Parser.g:4682:2: rule__Node__Group_3_3__0__Impl rule__Node__Group_3_3__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__0" + + + // $ANTLR start "rule__Node__Group_3_3__0__Impl" + // InternalRos1Parser.g:4689:1: rule__Node__Group_3_3__0__Impl : ( Serviceclient ) ; + public final void rule__Node__Group_3_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4693:1: ( ( Serviceclient ) ) + // InternalRos1Parser.g:4694:1: ( Serviceclient ) + { + // InternalRos1Parser.g:4694:1: ( Serviceclient ) + // InternalRos1Parser.g:4695:2: Serviceclient + { + before(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); + match(input,Serviceclient,FOLLOW_2); + after(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_3__1" + // InternalRos1Parser.g:4704:1: rule__Node__Group_3_3__1 : rule__Node__Group_3_3__1__Impl rule__Node__Group_3_3__2 ; + public final void rule__Node__Group_3_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4708:1: ( rule__Node__Group_3_3__1__Impl rule__Node__Group_3_3__2 ) + // InternalRos1Parser.g:4709:2: rule__Node__Group_3_3__1__Impl rule__Node__Group_3_3__2 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_3__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_3__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__1" + + + // $ANTLR start "rule__Node__Group_3_3__1__Impl" + // InternalRos1Parser.g:4716:1: rule__Node__Group_3_3__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4720:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:4721:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:4721:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:4722:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_3__2" + // InternalRos1Parser.g:4731:1: rule__Node__Group_3_3__2 : rule__Node__Group_3_3__2__Impl rule__Node__Group_3_3__3 ; + public final void rule__Node__Group_3_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4735:1: ( rule__Node__Group_3_3__2__Impl rule__Node__Group_3_3__3 ) + // InternalRos1Parser.g:4736:2: rule__Node__Group_3_3__2__Impl rule__Node__Group_3_3__3 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_3__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_3__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__2" + + + // $ANTLR start "rule__Node__Group_3_3__2__Impl" + // InternalRos1Parser.g:4743:1: rule__Node__Group_3_3__2__Impl : ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) ; + public final void rule__Node__Group_3_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4747:1: ( ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) ) + // InternalRos1Parser.g:4748:1: ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) + { + // InternalRos1Parser.g:4748:1: ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) + // InternalRos1Parser.g:4749:2: ( rule__Node__ServiceclientAssignment_3_3_2 )* + { + before(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); + // InternalRos1Parser.g:4750:2: ( rule__Node__ServiceclientAssignment_3_3_2 )* + loop28: + do { + int alt28=2; + int LA28_0 = input.LA(1); + + if ( (LA28_0==RULE_ID||LA28_0==RULE_STRING) ) { + alt28=1; + } + + + switch (alt28) { + case 1 : + // InternalRos1Parser.g:4750:3: rule__Node__ServiceclientAssignment_3_3_2 + { + pushFollow(FOLLOW_21); + rule__Node__ServiceclientAssignment_3_3_2(); + + state._fsp--; + + + } + break; + + default : + break loop28; + } + } while (true); + + after(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_3__3" + // InternalRos1Parser.g:4758:1: rule__Node__Group_3_3__3 : rule__Node__Group_3_3__3__Impl ; + public final void rule__Node__Group_3_3__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4762:1: ( rule__Node__Group_3_3__3__Impl ) + // InternalRos1Parser.g:4763:2: rule__Node__Group_3_3__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_3__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__3" + + + // $ANTLR start "rule__Node__Group_3_3__3__Impl" + // InternalRos1Parser.g:4769:1: rule__Node__Group_3_3__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_3__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4773:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:4774:1: ( RULE_END ) + { + // InternalRos1Parser.g:4774:1: ( RULE_END ) + // InternalRos1Parser.g:4775:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_4__0" + // InternalRos1Parser.g:4785:1: rule__Node__Group_3_4__0 : rule__Node__Group_3_4__0__Impl rule__Node__Group_3_4__1 ; + public final void rule__Node__Group_3_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4789:1: ( rule__Node__Group_3_4__0__Impl rule__Node__Group_3_4__1 ) + // InternalRos1Parser.g:4790:2: rule__Node__Group_3_4__0__Impl rule__Node__Group_3_4__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__0" + + + // $ANTLR start "rule__Node__Group_3_4__0__Impl" + // InternalRos1Parser.g:4797:1: rule__Node__Group_3_4__0__Impl : ( Actionserver ) ; + public final void rule__Node__Group_3_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4801:1: ( ( Actionserver ) ) + // InternalRos1Parser.g:4802:1: ( Actionserver ) + { + // InternalRos1Parser.g:4802:1: ( Actionserver ) + // InternalRos1Parser.g:4803:2: Actionserver + { + before(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); + match(input,Actionserver,FOLLOW_2); + after(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_4__1" + // InternalRos1Parser.g:4812:1: rule__Node__Group_3_4__1 : rule__Node__Group_3_4__1__Impl rule__Node__Group_3_4__2 ; + public final void rule__Node__Group_3_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4816:1: ( rule__Node__Group_3_4__1__Impl rule__Node__Group_3_4__2 ) + // InternalRos1Parser.g:4817:2: rule__Node__Group_3_4__1__Impl rule__Node__Group_3_4__2 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_4__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_4__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__1" + + + // $ANTLR start "rule__Node__Group_3_4__1__Impl" + // InternalRos1Parser.g:4824:1: rule__Node__Group_3_4__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4828:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:4829:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:4829:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:4830:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_4__2" + // InternalRos1Parser.g:4839:1: rule__Node__Group_3_4__2 : rule__Node__Group_3_4__2__Impl rule__Node__Group_3_4__3 ; + public final void rule__Node__Group_3_4__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4843:1: ( rule__Node__Group_3_4__2__Impl rule__Node__Group_3_4__3 ) + // InternalRos1Parser.g:4844:2: rule__Node__Group_3_4__2__Impl rule__Node__Group_3_4__3 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_4__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_4__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__2" + + + // $ANTLR start "rule__Node__Group_3_4__2__Impl" + // InternalRos1Parser.g:4851:1: rule__Node__Group_3_4__2__Impl : ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) ; + public final void rule__Node__Group_3_4__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4855:1: ( ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) ) + // InternalRos1Parser.g:4856:1: ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) + { + // InternalRos1Parser.g:4856:1: ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) + // InternalRos1Parser.g:4857:2: ( rule__Node__ActionserverAssignment_3_4_2 )* + { + before(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); + // InternalRos1Parser.g:4858:2: ( rule__Node__ActionserverAssignment_3_4_2 )* + loop29: + do { + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0==RULE_ID||LA29_0==RULE_STRING) ) { + alt29=1; + } + + + switch (alt29) { + case 1 : + // InternalRos1Parser.g:4858:3: rule__Node__ActionserverAssignment_3_4_2 + { + pushFollow(FOLLOW_21); + rule__Node__ActionserverAssignment_3_4_2(); + + state._fsp--; + + + } + break; + + default : + break loop29; + } + } while (true); + + after(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_4__3" + // InternalRos1Parser.g:4866:1: rule__Node__Group_3_4__3 : rule__Node__Group_3_4__3__Impl ; + public final void rule__Node__Group_3_4__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4870:1: ( rule__Node__Group_3_4__3__Impl ) + // InternalRos1Parser.g:4871:2: rule__Node__Group_3_4__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_4__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__3" + + + // $ANTLR start "rule__Node__Group_3_4__3__Impl" + // InternalRos1Parser.g:4877:1: rule__Node__Group_3_4__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_4__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4881:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:4882:1: ( RULE_END ) + { + // InternalRos1Parser.g:4882:1: ( RULE_END ) + // InternalRos1Parser.g:4883:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_5__0" + // InternalRos1Parser.g:4893:1: rule__Node__Group_3_5__0 : rule__Node__Group_3_5__0__Impl rule__Node__Group_3_5__1 ; + public final void rule__Node__Group_3_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4897:1: ( rule__Node__Group_3_5__0__Impl rule__Node__Group_3_5__1 ) + // InternalRos1Parser.g:4898:2: rule__Node__Group_3_5__0__Impl rule__Node__Group_3_5__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__0" + + + // $ANTLR start "rule__Node__Group_3_5__0__Impl" + // InternalRos1Parser.g:4905:1: rule__Node__Group_3_5__0__Impl : ( Actionclient ) ; + public final void rule__Node__Group_3_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4909:1: ( ( Actionclient ) ) + // InternalRos1Parser.g:4910:1: ( Actionclient ) + { + // InternalRos1Parser.g:4910:1: ( Actionclient ) + // InternalRos1Parser.g:4911:2: Actionclient + { + before(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); + match(input,Actionclient,FOLLOW_2); + after(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_5__1" + // InternalRos1Parser.g:4920:1: rule__Node__Group_3_5__1 : rule__Node__Group_3_5__1__Impl rule__Node__Group_3_5__2 ; + public final void rule__Node__Group_3_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4924:1: ( rule__Node__Group_3_5__1__Impl rule__Node__Group_3_5__2 ) + // InternalRos1Parser.g:4925:2: rule__Node__Group_3_5__1__Impl rule__Node__Group_3_5__2 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__1" + + + // $ANTLR start "rule__Node__Group_3_5__1__Impl" + // InternalRos1Parser.g:4932:1: rule__Node__Group_3_5__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4936:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:4937:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:4937:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:4938:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_5__2" + // InternalRos1Parser.g:4947:1: rule__Node__Group_3_5__2 : rule__Node__Group_3_5__2__Impl rule__Node__Group_3_5__3 ; + public final void rule__Node__Group_3_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4951:1: ( rule__Node__Group_3_5__2__Impl rule__Node__Group_3_5__3 ) + // InternalRos1Parser.g:4952:2: rule__Node__Group_3_5__2__Impl rule__Node__Group_3_5__3 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_5__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_5__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__2" + + + // $ANTLR start "rule__Node__Group_3_5__2__Impl" + // InternalRos1Parser.g:4959:1: rule__Node__Group_3_5__2__Impl : ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) ; + public final void rule__Node__Group_3_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4963:1: ( ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) ) + // InternalRos1Parser.g:4964:1: ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) + { + // InternalRos1Parser.g:4964:1: ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) + // InternalRos1Parser.g:4965:2: ( rule__Node__ActionclientAssignment_3_5_2 )* + { + before(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); + // InternalRos1Parser.g:4966:2: ( rule__Node__ActionclientAssignment_3_5_2 )* + loop30: + do { + int alt30=2; + int LA30_0 = input.LA(1); + + if ( (LA30_0==RULE_ID||LA30_0==RULE_STRING) ) { + alt30=1; + } + + + switch (alt30) { + case 1 : + // InternalRos1Parser.g:4966:3: rule__Node__ActionclientAssignment_3_5_2 + { + pushFollow(FOLLOW_21); + rule__Node__ActionclientAssignment_3_5_2(); + + state._fsp--; + + + } + break; + + default : + break loop30; + } + } while (true); + + after(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_5__3" + // InternalRos1Parser.g:4974:1: rule__Node__Group_3_5__3 : rule__Node__Group_3_5__3__Impl ; + public final void rule__Node__Group_3_5__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4978:1: ( rule__Node__Group_3_5__3__Impl ) + // InternalRos1Parser.g:4979:2: rule__Node__Group_3_5__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_5__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__3" + + + // $ANTLR start "rule__Node__Group_3_5__3__Impl" + // InternalRos1Parser.g:4985:1: rule__Node__Group_3_5__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_5__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:4989:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:4990:1: ( RULE_END ) + { + // InternalRos1Parser.g:4990:1: ( RULE_END ) + // InternalRos1Parser.g:4991:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_6__0" + // InternalRos1Parser.g:5001:1: rule__Node__Group_3_6__0 : rule__Node__Group_3_6__0__Impl rule__Node__Group_3_6__1 ; + public final void rule__Node__Group_3_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5005:1: ( rule__Node__Group_3_6__0__Impl rule__Node__Group_3_6__1 ) + // InternalRos1Parser.g:5006:2: rule__Node__Group_3_6__0__Impl rule__Node__Group_3_6__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__0" + + + // $ANTLR start "rule__Node__Group_3_6__0__Impl" + // InternalRos1Parser.g:5013:1: rule__Node__Group_3_6__0__Impl : ( Parameters ) ; + public final void rule__Node__Group_3_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5017:1: ( ( Parameters ) ) + // InternalRos1Parser.g:5018:1: ( Parameters ) + { + // InternalRos1Parser.g:5018:1: ( Parameters ) + // InternalRos1Parser.g:5019:2: Parameters + { + before(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); + match(input,Parameters,FOLLOW_2); + after(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_6__1" + // InternalRos1Parser.g:5028:1: rule__Node__Group_3_6__1 : rule__Node__Group_3_6__1__Impl rule__Node__Group_3_6__2 ; + public final void rule__Node__Group_3_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5032:1: ( rule__Node__Group_3_6__1__Impl rule__Node__Group_3_6__2 ) + // InternalRos1Parser.g:5033:2: rule__Node__Group_3_6__1__Impl rule__Node__Group_3_6__2 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_6__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_6__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__1" + + + // $ANTLR start "rule__Node__Group_3_6__1__Impl" + // InternalRos1Parser.g:5040:1: rule__Node__Group_3_6__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5044:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:5045:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:5045:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:5046:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_6__2" + // InternalRos1Parser.g:5055:1: rule__Node__Group_3_6__2 : rule__Node__Group_3_6__2__Impl rule__Node__Group_3_6__3 ; + public final void rule__Node__Group_3_6__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5059:1: ( rule__Node__Group_3_6__2__Impl rule__Node__Group_3_6__3 ) + // InternalRos1Parser.g:5060:2: rule__Node__Group_3_6__2__Impl rule__Node__Group_3_6__3 + { + pushFollow(FOLLOW_20); + rule__Node__Group_3_6__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_6__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__2" + + + // $ANTLR start "rule__Node__Group_3_6__2__Impl" + // InternalRos1Parser.g:5067:1: rule__Node__Group_3_6__2__Impl : ( ( rule__Node__ParameterAssignment_3_6_2 )* ) ; + public final void rule__Node__Group_3_6__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5071:1: ( ( ( rule__Node__ParameterAssignment_3_6_2 )* ) ) + // InternalRos1Parser.g:5072:1: ( ( rule__Node__ParameterAssignment_3_6_2 )* ) + { + // InternalRos1Parser.g:5072:1: ( ( rule__Node__ParameterAssignment_3_6_2 )* ) + // InternalRos1Parser.g:5073:2: ( rule__Node__ParameterAssignment_3_6_2 )* + { + before(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); + // InternalRos1Parser.g:5074:2: ( rule__Node__ParameterAssignment_3_6_2 )* + loop31: + do { + int alt31=2; + int LA31_0 = input.LA(1); + + if ( (LA31_0==RULE_ID||LA31_0==RULE_STRING) ) { + alt31=1; + } + + + switch (alt31) { + case 1 : + // InternalRos1Parser.g:5074:3: rule__Node__ParameterAssignment_3_6_2 + { + pushFollow(FOLLOW_21); + rule__Node__ParameterAssignment_3_6_2(); + + state._fsp--; + + + } + break; + + default : + break loop31; + } + } while (true); + + after(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_6__3" + // InternalRos1Parser.g:5082:1: rule__Node__Group_3_6__3 : rule__Node__Group_3_6__3__Impl ; + public final void rule__Node__Group_3_6__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5086:1: ( rule__Node__Group_3_6__3__Impl ) + // InternalRos1Parser.g:5087:2: rule__Node__Group_3_6__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_6__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__3" + + + // $ANTLR start "rule__Node__Group_3_6__3__Impl" + // InternalRos1Parser.g:5093:1: rule__Node__Group_3_6__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_6__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5097:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:5098:1: ( RULE_END ) + { + // InternalRos1Parser.g:5098:1: ( RULE_END ) + // InternalRos1Parser.g:5099:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__3__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__0" + // InternalRos1Parser.g:5109:1: rule__TopicSpec__Group__0 : rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 ; + public final void rule__TopicSpec__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5113:1: ( rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 ) + // InternalRos1Parser.g:5114:2: rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 + { + pushFollow(FOLLOW_22); + rule__TopicSpec__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__0" + + + // $ANTLR start "rule__TopicSpec__Group__0__Impl" + // InternalRos1Parser.g:5121:1: rule__TopicSpec__Group__0__Impl : ( () ) ; + public final void rule__TopicSpec__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5125:1: ( ( () ) ) + // InternalRos1Parser.g:5126:1: ( () ) + { + // InternalRos1Parser.g:5126:1: ( () ) + // InternalRos1Parser.g:5127:2: () + { + before(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); + // InternalRos1Parser.g:5128:2: () + // InternalRos1Parser.g:5128:3: + { + } + + after(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__0__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__1" + // InternalRos1Parser.g:5136:1: rule__TopicSpec__Group__1 : rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 ; + public final void rule__TopicSpec__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5140:1: ( rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 ) + // InternalRos1Parser.g:5141:2: rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 + { + pushFollow(FOLLOW_23); + rule__TopicSpec__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__1" + + + // $ANTLR start "rule__TopicSpec__Group__1__Impl" + // InternalRos1Parser.g:5148:1: rule__TopicSpec__Group__1__Impl : ( Msg ) ; + public final void rule__TopicSpec__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5152:1: ( ( Msg ) ) + // InternalRos1Parser.g:5153:1: ( Msg ) + { + // InternalRos1Parser.g:5153:1: ( Msg ) + // InternalRos1Parser.g:5154:2: Msg + { + before(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); + match(input,Msg,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__1__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__2" + // InternalRos1Parser.g:5163:1: rule__TopicSpec__Group__2 : rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 ; + public final void rule__TopicSpec__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5167:1: ( rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 ) + // InternalRos1Parser.g:5168:2: rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 + { + pushFollow(FOLLOW_5); + rule__TopicSpec__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__2" + + + // $ANTLR start "rule__TopicSpec__Group__2__Impl" + // InternalRos1Parser.g:5175:1: rule__TopicSpec__Group__2__Impl : ( ( rule__TopicSpec__NameAssignment_2 ) ) ; + public final void rule__TopicSpec__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5179:1: ( ( ( rule__TopicSpec__NameAssignment_2 ) ) ) + // InternalRos1Parser.g:5180:1: ( ( rule__TopicSpec__NameAssignment_2 ) ) + { + // InternalRos1Parser.g:5180:1: ( ( rule__TopicSpec__NameAssignment_2 ) ) + // InternalRos1Parser.g:5181:2: ( rule__TopicSpec__NameAssignment_2 ) + { + before(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); + // InternalRos1Parser.g:5182:2: ( rule__TopicSpec__NameAssignment_2 ) + // InternalRos1Parser.g:5182:3: rule__TopicSpec__NameAssignment_2 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__NameAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__2__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__3" + // InternalRos1Parser.g:5190:1: rule__TopicSpec__Group__3 : rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 ; + public final void rule__TopicSpec__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5194:1: ( rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 ) + // InternalRos1Parser.g:5195:2: rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 + { + pushFollow(FOLLOW_24); + rule__TopicSpec__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__3" + + + // $ANTLR start "rule__TopicSpec__Group__3__Impl" + // InternalRos1Parser.g:5202:1: rule__TopicSpec__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__TopicSpec__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5206:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:5207:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:5207:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:5208:2: RULE_BEGIN + { + before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__3__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__4" + // InternalRos1Parser.g:5217:1: rule__TopicSpec__Group__4 : rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 ; + public final void rule__TopicSpec__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5221:1: ( rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 ) + // InternalRos1Parser.g:5222:2: rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 + { + pushFollow(FOLLOW_25); + rule__TopicSpec__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__4" + + + // $ANTLR start "rule__TopicSpec__Group__4__Impl" + // InternalRos1Parser.g:5229:1: rule__TopicSpec__Group__4__Impl : ( Message_1 ) ; + public final void rule__TopicSpec__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5233:1: ( ( Message_1 ) ) + // InternalRos1Parser.g:5234:1: ( Message_1 ) + { + // InternalRos1Parser.g:5234:1: ( Message_1 ) + // InternalRos1Parser.g:5235:2: Message_1 + { + before(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); + match(input,Message_1,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__4__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__5" + // InternalRos1Parser.g:5244:1: rule__TopicSpec__Group__5 : rule__TopicSpec__Group__5__Impl rule__TopicSpec__Group__6 ; + public final void rule__TopicSpec__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5248:1: ( rule__TopicSpec__Group__5__Impl rule__TopicSpec__Group__6 ) + // InternalRos1Parser.g:5249:2: rule__TopicSpec__Group__5__Impl rule__TopicSpec__Group__6 + { + pushFollow(FOLLOW_25); + rule__TopicSpec__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__5" + + + // $ANTLR start "rule__TopicSpec__Group__5__Impl" + // InternalRos1Parser.g:5256:1: rule__TopicSpec__Group__5__Impl : ( ( rule__TopicSpec__Group_5__0 )? ) ; + public final void rule__TopicSpec__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5260:1: ( ( ( rule__TopicSpec__Group_5__0 )? ) ) + // InternalRos1Parser.g:5261:1: ( ( rule__TopicSpec__Group_5__0 )? ) + { + // InternalRos1Parser.g:5261:1: ( ( rule__TopicSpec__Group_5__0 )? ) + // InternalRos1Parser.g:5262:2: ( rule__TopicSpec__Group_5__0 )? + { + before(grammarAccess.getTopicSpecAccess().getGroup_5()); + // InternalRos1Parser.g:5263:2: ( rule__TopicSpec__Group_5__0 )? + int alt32=2; + int LA32_0 = input.LA(1); + + if ( (LA32_0==RULE_BEGIN) ) { + alt32=1; + } + switch (alt32) { + case 1 : + // InternalRos1Parser.g:5263:3: rule__TopicSpec__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getTopicSpecAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__5__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__6" + // InternalRos1Parser.g:5271:1: rule__TopicSpec__Group__6 : rule__TopicSpec__Group__6__Impl ; + public final void rule__TopicSpec__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5275:1: ( rule__TopicSpec__Group__6__Impl ) + // InternalRos1Parser.g:5276:2: rule__TopicSpec__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__6__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__6" + + + // $ANTLR start "rule__TopicSpec__Group__6__Impl" + // InternalRos1Parser.g:5282:1: rule__TopicSpec__Group__6__Impl : ( RULE_END ) ; + public final void rule__TopicSpec__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5286:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:5287:1: ( RULE_END ) + { + // InternalRos1Parser.g:5287:1: ( RULE_END ) + // InternalRos1Parser.g:5288:2: RULE_END + { + before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__6__Impl" + + + // $ANTLR start "rule__TopicSpec__Group_5__0" + // InternalRos1Parser.g:5298:1: rule__TopicSpec__Group_5__0 : rule__TopicSpec__Group_5__0__Impl rule__TopicSpec__Group_5__1 ; + public final void rule__TopicSpec__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5302:1: ( rule__TopicSpec__Group_5__0__Impl rule__TopicSpec__Group_5__1 ) + // InternalRos1Parser.g:5303:2: rule__TopicSpec__Group_5__0__Impl rule__TopicSpec__Group_5__1 + { + pushFollow(FOLLOW_26); + rule__TopicSpec__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__0" + + + // $ANTLR start "rule__TopicSpec__Group_5__0__Impl" + // InternalRos1Parser.g:5310:1: rule__TopicSpec__Group_5__0__Impl : ( RULE_BEGIN ) ; + public final void rule__TopicSpec__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5314:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:5315:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:5315:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:5316:2: RULE_BEGIN + { + before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__0__Impl" + + + // $ANTLR start "rule__TopicSpec__Group_5__1" + // InternalRos1Parser.g:5325:1: rule__TopicSpec__Group_5__1 : rule__TopicSpec__Group_5__1__Impl rule__TopicSpec__Group_5__2 ; + public final void rule__TopicSpec__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5329:1: ( rule__TopicSpec__Group_5__1__Impl rule__TopicSpec__Group_5__2 ) + // InternalRos1Parser.g:5330:2: rule__TopicSpec__Group_5__1__Impl rule__TopicSpec__Group_5__2 + { + pushFollow(FOLLOW_27); + rule__TopicSpec__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__1" + + + // $ANTLR start "rule__TopicSpec__Group_5__1__Impl" + // InternalRos1Parser.g:5337:1: rule__TopicSpec__Group_5__1__Impl : ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) ; + public final void rule__TopicSpec__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5341:1: ( ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) ) + // InternalRos1Parser.g:5342:1: ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) + { + // InternalRos1Parser.g:5342:1: ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) + // InternalRos1Parser.g:5343:2: ( rule__TopicSpec__MessageAssignment_5_1 ) + { + before(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); + // InternalRos1Parser.g:5344:2: ( rule__TopicSpec__MessageAssignment_5_1 ) + // InternalRos1Parser.g:5344:3: rule__TopicSpec__MessageAssignment_5_1 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__MessageAssignment_5_1(); + + state._fsp--; + + + } + + after(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__1__Impl" + + + // $ANTLR start "rule__TopicSpec__Group_5__2" + // InternalRos1Parser.g:5352:1: rule__TopicSpec__Group_5__2 : rule__TopicSpec__Group_5__2__Impl ; + public final void rule__TopicSpec__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5356:1: ( rule__TopicSpec__Group_5__2__Impl ) + // InternalRos1Parser.g:5357:2: rule__TopicSpec__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__TopicSpec__Group_5__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__2" + + + // $ANTLR start "rule__TopicSpec__Group_5__2__Impl" + // InternalRos1Parser.g:5363:1: rule__TopicSpec__Group_5__2__Impl : ( RULE_END ) ; + public final void rule__TopicSpec__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5367:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:5368:1: ( RULE_END ) + { + // InternalRos1Parser.g:5368:1: ( RULE_END ) + // InternalRos1Parser.g:5369:2: RULE_END + { + before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__2__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__0" + // InternalRos1Parser.g:5379:1: rule__ServiceSpec__Group__0 : rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 ; + public final void rule__ServiceSpec__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5383:1: ( rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 ) + // InternalRos1Parser.g:5384:2: rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 + { + pushFollow(FOLLOW_28); + rule__ServiceSpec__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__0" + + + // $ANTLR start "rule__ServiceSpec__Group__0__Impl" + // InternalRos1Parser.g:5391:1: rule__ServiceSpec__Group__0__Impl : ( () ) ; + public final void rule__ServiceSpec__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5395:1: ( ( () ) ) + // InternalRos1Parser.g:5396:1: ( () ) + { + // InternalRos1Parser.g:5396:1: ( () ) + // InternalRos1Parser.g:5397:2: () + { + before(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); + // InternalRos1Parser.g:5398:2: () + // InternalRos1Parser.g:5398:3: + { + } + + after(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__0__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__1" + // InternalRos1Parser.g:5406:1: rule__ServiceSpec__Group__1 : rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 ; + public final void rule__ServiceSpec__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5410:1: ( rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 ) + // InternalRos1Parser.g:5411:2: rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 + { + pushFollow(FOLLOW_7); + rule__ServiceSpec__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__1" + + + // $ANTLR start "rule__ServiceSpec__Group__1__Impl" + // InternalRos1Parser.g:5418:1: rule__ServiceSpec__Group__1__Impl : ( Srv ) ; + public final void rule__ServiceSpec__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5422:1: ( ( Srv ) ) + // InternalRos1Parser.g:5423:1: ( Srv ) + { + // InternalRos1Parser.g:5423:1: ( Srv ) + // InternalRos1Parser.g:5424:2: Srv + { + before(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); + match(input,Srv,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__1__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__2" + // InternalRos1Parser.g:5433:1: rule__ServiceSpec__Group__2 : rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 ; + public final void rule__ServiceSpec__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5437:1: ( rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 ) + // InternalRos1Parser.g:5438:2: rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 + { + pushFollow(FOLLOW_5); + rule__ServiceSpec__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__2" + + + // $ANTLR start "rule__ServiceSpec__Group__2__Impl" + // InternalRos1Parser.g:5445:1: rule__ServiceSpec__Group__2__Impl : ( ( rule__ServiceSpec__NameAssignment_2 ) ) ; + public final void rule__ServiceSpec__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5449:1: ( ( ( rule__ServiceSpec__NameAssignment_2 ) ) ) + // InternalRos1Parser.g:5450:1: ( ( rule__ServiceSpec__NameAssignment_2 ) ) + { + // InternalRos1Parser.g:5450:1: ( ( rule__ServiceSpec__NameAssignment_2 ) ) + // InternalRos1Parser.g:5451:2: ( rule__ServiceSpec__NameAssignment_2 ) + { + before(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); + // InternalRos1Parser.g:5452:2: ( rule__ServiceSpec__NameAssignment_2 ) + // InternalRos1Parser.g:5452:3: rule__ServiceSpec__NameAssignment_2 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__NameAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__2__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__3" + // InternalRos1Parser.g:5460:1: rule__ServiceSpec__Group__3 : rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 ; + public final void rule__ServiceSpec__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5464:1: ( rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 ) + // InternalRos1Parser.g:5465:2: rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 + { + pushFollow(FOLLOW_29); + rule__ServiceSpec__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__3" + + + // $ANTLR start "rule__ServiceSpec__Group__3__Impl" + // InternalRos1Parser.g:5472:1: rule__ServiceSpec__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceSpec__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5476:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:5477:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:5477:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:5478:2: RULE_BEGIN + { + before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__3__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__4" + // InternalRos1Parser.g:5487:1: rule__ServiceSpec__Group__4 : rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 ; + public final void rule__ServiceSpec__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5491:1: ( rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 ) + // InternalRos1Parser.g:5492:2: rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 + { + pushFollow(FOLLOW_30); + rule__ServiceSpec__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__4" + + + // $ANTLR start "rule__ServiceSpec__Group__4__Impl" + // InternalRos1Parser.g:5499:1: rule__ServiceSpec__Group__4__Impl : ( Request ) ; + public final void rule__ServiceSpec__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5503:1: ( ( Request ) ) + // InternalRos1Parser.g:5504:1: ( Request ) + { + // InternalRos1Parser.g:5504:1: ( Request ) + // InternalRos1Parser.g:5505:2: Request + { + before(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); + match(input,Request,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__4__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__5" + // InternalRos1Parser.g:5514:1: rule__ServiceSpec__Group__5 : rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 ; + public final void rule__ServiceSpec__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5518:1: ( rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 ) + // InternalRos1Parser.g:5519:2: rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 + { + pushFollow(FOLLOW_30); + rule__ServiceSpec__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__5" + + + // $ANTLR start "rule__ServiceSpec__Group__5__Impl" + // InternalRos1Parser.g:5526:1: rule__ServiceSpec__Group__5__Impl : ( ( rule__ServiceSpec__Group_5__0 )? ) ; + public final void rule__ServiceSpec__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5530:1: ( ( ( rule__ServiceSpec__Group_5__0 )? ) ) + // InternalRos1Parser.g:5531:1: ( ( rule__ServiceSpec__Group_5__0 )? ) + { + // InternalRos1Parser.g:5531:1: ( ( rule__ServiceSpec__Group_5__0 )? ) + // InternalRos1Parser.g:5532:2: ( rule__ServiceSpec__Group_5__0 )? + { + before(grammarAccess.getServiceSpecAccess().getGroup_5()); + // InternalRos1Parser.g:5533:2: ( rule__ServiceSpec__Group_5__0 )? + int alt33=2; + int LA33_0 = input.LA(1); + + if ( (LA33_0==RULE_BEGIN) ) { + alt33=1; + } + switch (alt33) { + case 1 : + // InternalRos1Parser.g:5533:3: rule__ServiceSpec__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceSpecAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__5__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__6" + // InternalRos1Parser.g:5541:1: rule__ServiceSpec__Group__6 : rule__ServiceSpec__Group__6__Impl rule__ServiceSpec__Group__7 ; + public final void rule__ServiceSpec__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5545:1: ( rule__ServiceSpec__Group__6__Impl rule__ServiceSpec__Group__7 ) + // InternalRos1Parser.g:5546:2: rule__ServiceSpec__Group__6__Impl rule__ServiceSpec__Group__7 + { + pushFollow(FOLLOW_25); + rule__ServiceSpec__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__6" + + + // $ANTLR start "rule__ServiceSpec__Group__6__Impl" + // InternalRos1Parser.g:5553:1: rule__ServiceSpec__Group__6__Impl : ( Response ) ; + public final void rule__ServiceSpec__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5557:1: ( ( Response ) ) + // InternalRos1Parser.g:5558:1: ( Response ) + { + // InternalRos1Parser.g:5558:1: ( Response ) + // InternalRos1Parser.g:5559:2: Response + { + before(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); + match(input,Response,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__6__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__7" + // InternalRos1Parser.g:5568:1: rule__ServiceSpec__Group__7 : rule__ServiceSpec__Group__7__Impl rule__ServiceSpec__Group__8 ; + public final void rule__ServiceSpec__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5572:1: ( rule__ServiceSpec__Group__7__Impl rule__ServiceSpec__Group__8 ) + // InternalRos1Parser.g:5573:2: rule__ServiceSpec__Group__7__Impl rule__ServiceSpec__Group__8 + { + pushFollow(FOLLOW_25); + rule__ServiceSpec__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__7" + + + // $ANTLR start "rule__ServiceSpec__Group__7__Impl" + // InternalRos1Parser.g:5580:1: rule__ServiceSpec__Group__7__Impl : ( ( rule__ServiceSpec__Group_7__0 )? ) ; + public final void rule__ServiceSpec__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5584:1: ( ( ( rule__ServiceSpec__Group_7__0 )? ) ) + // InternalRos1Parser.g:5585:1: ( ( rule__ServiceSpec__Group_7__0 )? ) + { + // InternalRos1Parser.g:5585:1: ( ( rule__ServiceSpec__Group_7__0 )? ) + // InternalRos1Parser.g:5586:2: ( rule__ServiceSpec__Group_7__0 )? + { + before(grammarAccess.getServiceSpecAccess().getGroup_7()); + // InternalRos1Parser.g:5587:2: ( rule__ServiceSpec__Group_7__0 )? + int alt34=2; + int LA34_0 = input.LA(1); + + if ( (LA34_0==RULE_BEGIN) ) { + alt34=1; + } + switch (alt34) { + case 1 : + // InternalRos1Parser.g:5587:3: rule__ServiceSpec__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceSpecAccess().getGroup_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__7__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__8" + // InternalRos1Parser.g:5595:1: rule__ServiceSpec__Group__8 : rule__ServiceSpec__Group__8__Impl ; + public final void rule__ServiceSpec__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5599:1: ( rule__ServiceSpec__Group__8__Impl ) + // InternalRos1Parser.g:5600:2: rule__ServiceSpec__Group__8__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__8__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__8" + + + // $ANTLR start "rule__ServiceSpec__Group__8__Impl" + // InternalRos1Parser.g:5606:1: rule__ServiceSpec__Group__8__Impl : ( RULE_END ) ; + public final void rule__ServiceSpec__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5610:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:5611:1: ( RULE_END ) + { + // InternalRos1Parser.g:5611:1: ( RULE_END ) + // InternalRos1Parser.g:5612:2: RULE_END + { + before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__8__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_5__0" + // InternalRos1Parser.g:5622:1: rule__ServiceSpec__Group_5__0 : rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 ; + public final void rule__ServiceSpec__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5626:1: ( rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 ) + // InternalRos1Parser.g:5627:2: rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 + { + pushFollow(FOLLOW_26); + rule__ServiceSpec__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__0" + + + // $ANTLR start "rule__ServiceSpec__Group_5__0__Impl" + // InternalRos1Parser.g:5634:1: rule__ServiceSpec__Group_5__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceSpec__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5638:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:5639:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:5639:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:5640:2: RULE_BEGIN + { + before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__0__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_5__1" + // InternalRos1Parser.g:5649:1: rule__ServiceSpec__Group_5__1 : rule__ServiceSpec__Group_5__1__Impl rule__ServiceSpec__Group_5__2 ; + public final void rule__ServiceSpec__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5653:1: ( rule__ServiceSpec__Group_5__1__Impl rule__ServiceSpec__Group_5__2 ) + // InternalRos1Parser.g:5654:2: rule__ServiceSpec__Group_5__1__Impl rule__ServiceSpec__Group_5__2 + { + pushFollow(FOLLOW_27); + rule__ServiceSpec__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__1" + + + // $ANTLR start "rule__ServiceSpec__Group_5__1__Impl" + // InternalRos1Parser.g:5661:1: rule__ServiceSpec__Group_5__1__Impl : ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) ; + public final void rule__ServiceSpec__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5665:1: ( ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) ) + // InternalRos1Parser.g:5666:1: ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) + { + // InternalRos1Parser.g:5666:1: ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) + // InternalRos1Parser.g:5667:2: ( rule__ServiceSpec__RequestAssignment_5_1 ) + { + before(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); + // InternalRos1Parser.g:5668:2: ( rule__ServiceSpec__RequestAssignment_5_1 ) + // InternalRos1Parser.g:5668:3: rule__ServiceSpec__RequestAssignment_5_1 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__RequestAssignment_5_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__1__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_5__2" + // InternalRos1Parser.g:5676:1: rule__ServiceSpec__Group_5__2 : rule__ServiceSpec__Group_5__2__Impl ; + public final void rule__ServiceSpec__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5680:1: ( rule__ServiceSpec__Group_5__2__Impl ) + // InternalRos1Parser.g:5681:2: rule__ServiceSpec__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_5__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__2" + + + // $ANTLR start "rule__ServiceSpec__Group_5__2__Impl" + // InternalRos1Parser.g:5687:1: rule__ServiceSpec__Group_5__2__Impl : ( RULE_END ) ; + public final void rule__ServiceSpec__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5691:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:5692:1: ( RULE_END ) + { + // InternalRos1Parser.g:5692:1: ( RULE_END ) + // InternalRos1Parser.g:5693:2: RULE_END + { + before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__2__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_7__0" + // InternalRos1Parser.g:5703:1: rule__ServiceSpec__Group_7__0 : rule__ServiceSpec__Group_7__0__Impl rule__ServiceSpec__Group_7__1 ; + public final void rule__ServiceSpec__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5707:1: ( rule__ServiceSpec__Group_7__0__Impl rule__ServiceSpec__Group_7__1 ) + // InternalRos1Parser.g:5708:2: rule__ServiceSpec__Group_7__0__Impl rule__ServiceSpec__Group_7__1 + { + pushFollow(FOLLOW_26); + rule__ServiceSpec__Group_7__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_7__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__0" + + + // $ANTLR start "rule__ServiceSpec__Group_7__0__Impl" + // InternalRos1Parser.g:5715:1: rule__ServiceSpec__Group_7__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceSpec__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5719:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:5720:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:5720:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:5721:2: RULE_BEGIN + { + before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__0__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_7__1" + // InternalRos1Parser.g:5730:1: rule__ServiceSpec__Group_7__1 : rule__ServiceSpec__Group_7__1__Impl rule__ServiceSpec__Group_7__2 ; + public final void rule__ServiceSpec__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5734:1: ( rule__ServiceSpec__Group_7__1__Impl rule__ServiceSpec__Group_7__2 ) + // InternalRos1Parser.g:5735:2: rule__ServiceSpec__Group_7__1__Impl rule__ServiceSpec__Group_7__2 + { + pushFollow(FOLLOW_27); + rule__ServiceSpec__Group_7__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_7__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__1" + + + // $ANTLR start "rule__ServiceSpec__Group_7__1__Impl" + // InternalRos1Parser.g:5742:1: rule__ServiceSpec__Group_7__1__Impl : ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) ; + public final void rule__ServiceSpec__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5746:1: ( ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) ) + // InternalRos1Parser.g:5747:1: ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) + { + // InternalRos1Parser.g:5747:1: ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) + // InternalRos1Parser.g:5748:2: ( rule__ServiceSpec__ResponseAssignment_7_1 ) + { + before(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); + // InternalRos1Parser.g:5749:2: ( rule__ServiceSpec__ResponseAssignment_7_1 ) + // InternalRos1Parser.g:5749:3: rule__ServiceSpec__ResponseAssignment_7_1 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__ResponseAssignment_7_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__1__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_7__2" + // InternalRos1Parser.g:5757:1: rule__ServiceSpec__Group_7__2 : rule__ServiceSpec__Group_7__2__Impl ; + public final void rule__ServiceSpec__Group_7__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5761:1: ( rule__ServiceSpec__Group_7__2__Impl ) + // InternalRos1Parser.g:5762:2: rule__ServiceSpec__Group_7__2__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_7__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__2" + + + // $ANTLR start "rule__ServiceSpec__Group_7__2__Impl" + // InternalRos1Parser.g:5768:1: rule__ServiceSpec__Group_7__2__Impl : ( RULE_END ) ; + public final void rule__ServiceSpec__Group_7__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5772:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:5773:1: ( RULE_END ) + { + // InternalRos1Parser.g:5773:1: ( RULE_END ) + // InternalRos1Parser.g:5774:2: RULE_END + { + before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__2__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__0" + // InternalRos1Parser.g:5784:1: rule__ActionSpec__Group__0 : rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 ; + public final void rule__ActionSpec__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5788:1: ( rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 ) + // InternalRos1Parser.g:5789:2: rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 + { + pushFollow(FOLLOW_31); + rule__ActionSpec__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__0" + + + // $ANTLR start "rule__ActionSpec__Group__0__Impl" + // InternalRos1Parser.g:5796:1: rule__ActionSpec__Group__0__Impl : ( () ) ; + public final void rule__ActionSpec__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5800:1: ( ( () ) ) + // InternalRos1Parser.g:5801:1: ( () ) + { + // InternalRos1Parser.g:5801:1: ( () ) + // InternalRos1Parser.g:5802:2: () + { + before(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); + // InternalRos1Parser.g:5803:2: () + // InternalRos1Parser.g:5803:3: + { + } + + after(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__0__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__1" + // InternalRos1Parser.g:5811:1: rule__ActionSpec__Group__1 : rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 ; + public final void rule__ActionSpec__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5815:1: ( rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 ) + // InternalRos1Parser.g:5816:2: rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 + { + pushFollow(FOLLOW_7); + rule__ActionSpec__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__1" + + + // $ANTLR start "rule__ActionSpec__Group__1__Impl" + // InternalRos1Parser.g:5823:1: rule__ActionSpec__Group__1__Impl : ( Action_1 ) ; + public final void rule__ActionSpec__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5827:1: ( ( Action_1 ) ) + // InternalRos1Parser.g:5828:1: ( Action_1 ) + { + // InternalRos1Parser.g:5828:1: ( Action_1 ) + // InternalRos1Parser.g:5829:2: Action_1 + { + before(grammarAccess.getActionSpecAccess().getActionKeyword_1()); + match(input,Action_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getActionKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__1__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__2" + // InternalRos1Parser.g:5838:1: rule__ActionSpec__Group__2 : rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 ; + public final void rule__ActionSpec__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5842:1: ( rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 ) + // InternalRos1Parser.g:5843:2: rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 + { + pushFollow(FOLLOW_5); + rule__ActionSpec__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__2" + + + // $ANTLR start "rule__ActionSpec__Group__2__Impl" + // InternalRos1Parser.g:5850:1: rule__ActionSpec__Group__2__Impl : ( ( rule__ActionSpec__NameAssignment_2 ) ) ; + public final void rule__ActionSpec__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5854:1: ( ( ( rule__ActionSpec__NameAssignment_2 ) ) ) + // InternalRos1Parser.g:5855:1: ( ( rule__ActionSpec__NameAssignment_2 ) ) + { + // InternalRos1Parser.g:5855:1: ( ( rule__ActionSpec__NameAssignment_2 ) ) + // InternalRos1Parser.g:5856:2: ( rule__ActionSpec__NameAssignment_2 ) + { + before(grammarAccess.getActionSpecAccess().getNameAssignment_2()); + // InternalRos1Parser.g:5857:2: ( rule__ActionSpec__NameAssignment_2 ) + // InternalRos1Parser.g:5857:3: rule__ActionSpec__NameAssignment_2 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__NameAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getActionSpecAccess().getNameAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__2__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__3" + // InternalRos1Parser.g:5865:1: rule__ActionSpec__Group__3 : rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 ; + public final void rule__ActionSpec__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5869:1: ( rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 ) + // InternalRos1Parser.g:5870:2: rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 + { + pushFollow(FOLLOW_32); + rule__ActionSpec__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__3" + + + // $ANTLR start "rule__ActionSpec__Group__3__Impl" + // InternalRos1Parser.g:5877:1: rule__ActionSpec__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5881:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:5882:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:5882:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:5883:2: RULE_BEGIN + { + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__3__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__4" + // InternalRos1Parser.g:5892:1: rule__ActionSpec__Group__4 : rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 ; + public final void rule__ActionSpec__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5896:1: ( rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 ) + // InternalRos1Parser.g:5897:2: rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 + { + pushFollow(FOLLOW_33); + rule__ActionSpec__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__4" + + + // $ANTLR start "rule__ActionSpec__Group__4__Impl" + // InternalRos1Parser.g:5904:1: rule__ActionSpec__Group__4__Impl : ( Goal_1 ) ; + public final void rule__ActionSpec__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5908:1: ( ( Goal_1 ) ) + // InternalRos1Parser.g:5909:1: ( Goal_1 ) + { + // InternalRos1Parser.g:5909:1: ( Goal_1 ) + // InternalRos1Parser.g:5910:2: Goal_1 + { + before(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); + match(input,Goal_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__4__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__5" + // InternalRos1Parser.g:5919:1: rule__ActionSpec__Group__5 : rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 ; + public final void rule__ActionSpec__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5923:1: ( rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 ) + // InternalRos1Parser.g:5924:2: rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 + { + pushFollow(FOLLOW_33); + rule__ActionSpec__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__5" + + + // $ANTLR start "rule__ActionSpec__Group__5__Impl" + // InternalRos1Parser.g:5931:1: rule__ActionSpec__Group__5__Impl : ( ( rule__ActionSpec__Group_5__0 )? ) ; + public final void rule__ActionSpec__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5935:1: ( ( ( rule__ActionSpec__Group_5__0 )? ) ) + // InternalRos1Parser.g:5936:1: ( ( rule__ActionSpec__Group_5__0 )? ) + { + // InternalRos1Parser.g:5936:1: ( ( rule__ActionSpec__Group_5__0 )? ) + // InternalRos1Parser.g:5937:2: ( rule__ActionSpec__Group_5__0 )? + { + before(grammarAccess.getActionSpecAccess().getGroup_5()); + // InternalRos1Parser.g:5938:2: ( rule__ActionSpec__Group_5__0 )? + int alt35=2; + int LA35_0 = input.LA(1); + + if ( (LA35_0==RULE_BEGIN) ) { + alt35=1; + } + switch (alt35) { + case 1 : + // InternalRos1Parser.g:5938:3: rule__ActionSpec__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionSpecAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__5__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__6" + // InternalRos1Parser.g:5946:1: rule__ActionSpec__Group__6 : rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 ; + public final void rule__ActionSpec__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5950:1: ( rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 ) + // InternalRos1Parser.g:5951:2: rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 + { + pushFollow(FOLLOW_34); + rule__ActionSpec__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__6" + + + // $ANTLR start "rule__ActionSpec__Group__6__Impl" + // InternalRos1Parser.g:5958:1: rule__ActionSpec__Group__6__Impl : ( Result_1 ) ; + public final void rule__ActionSpec__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5962:1: ( ( Result_1 ) ) + // InternalRos1Parser.g:5963:1: ( Result_1 ) + { + // InternalRos1Parser.g:5963:1: ( Result_1 ) + // InternalRos1Parser.g:5964:2: Result_1 + { + before(grammarAccess.getActionSpecAccess().getResultKeyword_6()); + match(input,Result_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getResultKeyword_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__6__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__7" + // InternalRos1Parser.g:5973:1: rule__ActionSpec__Group__7 : rule__ActionSpec__Group__7__Impl rule__ActionSpec__Group__8 ; + public final void rule__ActionSpec__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5977:1: ( rule__ActionSpec__Group__7__Impl rule__ActionSpec__Group__8 ) + // InternalRos1Parser.g:5978:2: rule__ActionSpec__Group__7__Impl rule__ActionSpec__Group__8 + { + pushFollow(FOLLOW_34); + rule__ActionSpec__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__7" + + + // $ANTLR start "rule__ActionSpec__Group__7__Impl" + // InternalRos1Parser.g:5985:1: rule__ActionSpec__Group__7__Impl : ( ( rule__ActionSpec__Group_7__0 )? ) ; + public final void rule__ActionSpec__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:5989:1: ( ( ( rule__ActionSpec__Group_7__0 )? ) ) + // InternalRos1Parser.g:5990:1: ( ( rule__ActionSpec__Group_7__0 )? ) + { + // InternalRos1Parser.g:5990:1: ( ( rule__ActionSpec__Group_7__0 )? ) + // InternalRos1Parser.g:5991:2: ( rule__ActionSpec__Group_7__0 )? + { + before(grammarAccess.getActionSpecAccess().getGroup_7()); + // InternalRos1Parser.g:5992:2: ( rule__ActionSpec__Group_7__0 )? + int alt36=2; + int LA36_0 = input.LA(1); + + if ( (LA36_0==RULE_BEGIN) ) { + alt36=1; + } + switch (alt36) { + case 1 : + // InternalRos1Parser.g:5992:3: rule__ActionSpec__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionSpecAccess().getGroup_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__7__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__8" + // InternalRos1Parser.g:6000:1: rule__ActionSpec__Group__8 : rule__ActionSpec__Group__8__Impl rule__ActionSpec__Group__9 ; + public final void rule__ActionSpec__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6004:1: ( rule__ActionSpec__Group__8__Impl rule__ActionSpec__Group__9 ) + // InternalRos1Parser.g:6005:2: rule__ActionSpec__Group__8__Impl rule__ActionSpec__Group__9 + { + pushFollow(FOLLOW_25); + rule__ActionSpec__Group__8__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__9(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__8" + + + // $ANTLR start "rule__ActionSpec__Group__8__Impl" + // InternalRos1Parser.g:6012:1: rule__ActionSpec__Group__8__Impl : ( Feedback_1 ) ; + public final void rule__ActionSpec__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6016:1: ( ( Feedback_1 ) ) + // InternalRos1Parser.g:6017:1: ( Feedback_1 ) + { + // InternalRos1Parser.g:6017:1: ( Feedback_1 ) + // InternalRos1Parser.g:6018:2: Feedback_1 + { + before(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + match(input,Feedback_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__8__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__9" + // InternalRos1Parser.g:6027:1: rule__ActionSpec__Group__9 : rule__ActionSpec__Group__9__Impl rule__ActionSpec__Group__10 ; + public final void rule__ActionSpec__Group__9() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6031:1: ( rule__ActionSpec__Group__9__Impl rule__ActionSpec__Group__10 ) + // InternalRos1Parser.g:6032:2: rule__ActionSpec__Group__9__Impl rule__ActionSpec__Group__10 + { + pushFollow(FOLLOW_25); + rule__ActionSpec__Group__9__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__10(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__9" + + + // $ANTLR start "rule__ActionSpec__Group__9__Impl" + // InternalRos1Parser.g:6039:1: rule__ActionSpec__Group__9__Impl : ( ( rule__ActionSpec__Group_9__0 )? ) ; + public final void rule__ActionSpec__Group__9__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6043:1: ( ( ( rule__ActionSpec__Group_9__0 )? ) ) + // InternalRos1Parser.g:6044:1: ( ( rule__ActionSpec__Group_9__0 )? ) + { + // InternalRos1Parser.g:6044:1: ( ( rule__ActionSpec__Group_9__0 )? ) + // InternalRos1Parser.g:6045:2: ( rule__ActionSpec__Group_9__0 )? + { + before(grammarAccess.getActionSpecAccess().getGroup_9()); + // InternalRos1Parser.g:6046:2: ( rule__ActionSpec__Group_9__0 )? + int alt37=2; + int LA37_0 = input.LA(1); + + if ( (LA37_0==RULE_BEGIN) ) { + alt37=1; + } + switch (alt37) { + case 1 : + // InternalRos1Parser.g:6046:3: rule__ActionSpec__Group_9__0 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_9__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionSpecAccess().getGroup_9()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__9__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__10" + // InternalRos1Parser.g:6054:1: rule__ActionSpec__Group__10 : rule__ActionSpec__Group__10__Impl ; + public final void rule__ActionSpec__Group__10() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6058:1: ( rule__ActionSpec__Group__10__Impl ) + // InternalRos1Parser.g:6059:2: rule__ActionSpec__Group__10__Impl + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__10__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__10" + + + // $ANTLR start "rule__ActionSpec__Group__10__Impl" + // InternalRos1Parser.g:6065:1: rule__ActionSpec__Group__10__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group__10__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6069:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:6070:1: ( RULE_END ) + { + // InternalRos1Parser.g:6070:1: ( RULE_END ) + // InternalRos1Parser.g:6071:2: RULE_END + { + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__10__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_5__0" + // InternalRos1Parser.g:6081:1: rule__ActionSpec__Group_5__0 : rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 ; + public final void rule__ActionSpec__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6085:1: ( rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 ) + // InternalRos1Parser.g:6086:2: rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 + { + pushFollow(FOLLOW_26); + rule__ActionSpec__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__0" + + + // $ANTLR start "rule__ActionSpec__Group_5__0__Impl" + // InternalRos1Parser.g:6093:1: rule__ActionSpec__Group_5__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6097:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:6098:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:6098:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:6099:2: RULE_BEGIN + { + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__0__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_5__1" + // InternalRos1Parser.g:6108:1: rule__ActionSpec__Group_5__1 : rule__ActionSpec__Group_5__1__Impl rule__ActionSpec__Group_5__2 ; + public final void rule__ActionSpec__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6112:1: ( rule__ActionSpec__Group_5__1__Impl rule__ActionSpec__Group_5__2 ) + // InternalRos1Parser.g:6113:2: rule__ActionSpec__Group_5__1__Impl rule__ActionSpec__Group_5__2 + { + pushFollow(FOLLOW_27); + rule__ActionSpec__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__1" + + + // $ANTLR start "rule__ActionSpec__Group_5__1__Impl" + // InternalRos1Parser.g:6120:1: rule__ActionSpec__Group_5__1__Impl : ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) ; + public final void rule__ActionSpec__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6124:1: ( ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) ) + // InternalRos1Parser.g:6125:1: ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) + { + // InternalRos1Parser.g:6125:1: ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) + // InternalRos1Parser.g:6126:2: ( rule__ActionSpec__GoalAssignment_5_1 ) + { + before(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); + // InternalRos1Parser.g:6127:2: ( rule__ActionSpec__GoalAssignment_5_1 ) + // InternalRos1Parser.g:6127:3: rule__ActionSpec__GoalAssignment_5_1 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__GoalAssignment_5_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__1__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_5__2" + // InternalRos1Parser.g:6135:1: rule__ActionSpec__Group_5__2 : rule__ActionSpec__Group_5__2__Impl ; + public final void rule__ActionSpec__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6139:1: ( rule__ActionSpec__Group_5__2__Impl ) + // InternalRos1Parser.g:6140:2: rule__ActionSpec__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_5__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__2" + + + // $ANTLR start "rule__ActionSpec__Group_5__2__Impl" + // InternalRos1Parser.g:6146:1: rule__ActionSpec__Group_5__2__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6150:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:6151:1: ( RULE_END ) + { + // InternalRos1Parser.g:6151:1: ( RULE_END ) + // InternalRos1Parser.g:6152:2: RULE_END + { + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__2__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_7__0" + // InternalRos1Parser.g:6162:1: rule__ActionSpec__Group_7__0 : rule__ActionSpec__Group_7__0__Impl rule__ActionSpec__Group_7__1 ; + public final void rule__ActionSpec__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6166:1: ( rule__ActionSpec__Group_7__0__Impl rule__ActionSpec__Group_7__1 ) + // InternalRos1Parser.g:6167:2: rule__ActionSpec__Group_7__0__Impl rule__ActionSpec__Group_7__1 + { + pushFollow(FOLLOW_26); + rule__ActionSpec__Group_7__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_7__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__0" + + + // $ANTLR start "rule__ActionSpec__Group_7__0__Impl" + // InternalRos1Parser.g:6174:1: rule__ActionSpec__Group_7__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6178:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:6179:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:6179:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:6180:2: RULE_BEGIN + { + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__0__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_7__1" + // InternalRos1Parser.g:6189:1: rule__ActionSpec__Group_7__1 : rule__ActionSpec__Group_7__1__Impl rule__ActionSpec__Group_7__2 ; + public final void rule__ActionSpec__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6193:1: ( rule__ActionSpec__Group_7__1__Impl rule__ActionSpec__Group_7__2 ) + // InternalRos1Parser.g:6194:2: rule__ActionSpec__Group_7__1__Impl rule__ActionSpec__Group_7__2 + { + pushFollow(FOLLOW_27); + rule__ActionSpec__Group_7__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_7__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__1" + + + // $ANTLR start "rule__ActionSpec__Group_7__1__Impl" + // InternalRos1Parser.g:6201:1: rule__ActionSpec__Group_7__1__Impl : ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) ; + public final void rule__ActionSpec__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6205:1: ( ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) ) + // InternalRos1Parser.g:6206:1: ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) + { + // InternalRos1Parser.g:6206:1: ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) + // InternalRos1Parser.g:6207:2: ( rule__ActionSpec__ResultAssignment_7_1 ) + { + before(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); + // InternalRos1Parser.g:6208:2: ( rule__ActionSpec__ResultAssignment_7_1 ) + // InternalRos1Parser.g:6208:3: rule__ActionSpec__ResultAssignment_7_1 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__ResultAssignment_7_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__1__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_7__2" + // InternalRos1Parser.g:6216:1: rule__ActionSpec__Group_7__2 : rule__ActionSpec__Group_7__2__Impl ; + public final void rule__ActionSpec__Group_7__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6220:1: ( rule__ActionSpec__Group_7__2__Impl ) + // InternalRos1Parser.g:6221:2: rule__ActionSpec__Group_7__2__Impl + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_7__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__2" + + + // $ANTLR start "rule__ActionSpec__Group_7__2__Impl" + // InternalRos1Parser.g:6227:1: rule__ActionSpec__Group_7__2__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group_7__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6231:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:6232:1: ( RULE_END ) + { + // InternalRos1Parser.g:6232:1: ( RULE_END ) + // InternalRos1Parser.g:6233:2: RULE_END + { + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__2__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_9__0" + // InternalRos1Parser.g:6243:1: rule__ActionSpec__Group_9__0 : rule__ActionSpec__Group_9__0__Impl rule__ActionSpec__Group_9__1 ; + public final void rule__ActionSpec__Group_9__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6247:1: ( rule__ActionSpec__Group_9__0__Impl rule__ActionSpec__Group_9__1 ) + // InternalRos1Parser.g:6248:2: rule__ActionSpec__Group_9__0__Impl rule__ActionSpec__Group_9__1 + { + pushFollow(FOLLOW_26); + rule__ActionSpec__Group_9__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_9__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__0" + + + // $ANTLR start "rule__ActionSpec__Group_9__0__Impl" + // InternalRos1Parser.g:6255:1: rule__ActionSpec__Group_9__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group_9__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6259:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:6260:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:6260:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:6261:2: RULE_BEGIN + { + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__0__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_9__1" + // InternalRos1Parser.g:6270:1: rule__ActionSpec__Group_9__1 : rule__ActionSpec__Group_9__1__Impl rule__ActionSpec__Group_9__2 ; + public final void rule__ActionSpec__Group_9__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6274:1: ( rule__ActionSpec__Group_9__1__Impl rule__ActionSpec__Group_9__2 ) + // InternalRos1Parser.g:6275:2: rule__ActionSpec__Group_9__1__Impl rule__ActionSpec__Group_9__2 + { + pushFollow(FOLLOW_27); + rule__ActionSpec__Group_9__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_9__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__1" + + + // $ANTLR start "rule__ActionSpec__Group_9__1__Impl" + // InternalRos1Parser.g:6282:1: rule__ActionSpec__Group_9__1__Impl : ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) ; + public final void rule__ActionSpec__Group_9__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6286:1: ( ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) ) + // InternalRos1Parser.g:6287:1: ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) + { + // InternalRos1Parser.g:6287:1: ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) + // InternalRos1Parser.g:6288:2: ( rule__ActionSpec__FeedbackAssignment_9_1 ) + { + before(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); + // InternalRos1Parser.g:6289:2: ( rule__ActionSpec__FeedbackAssignment_9_1 ) + // InternalRos1Parser.g:6289:3: rule__ActionSpec__FeedbackAssignment_9_1 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__FeedbackAssignment_9_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__1__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_9__2" + // InternalRos1Parser.g:6297:1: rule__ActionSpec__Group_9__2 : rule__ActionSpec__Group_9__2__Impl ; + public final void rule__ActionSpec__Group_9__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6301:1: ( rule__ActionSpec__Group_9__2__Impl ) + // InternalRos1Parser.g:6302:2: rule__ActionSpec__Group_9__2__Impl + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_9__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__2" + + + // $ANTLR start "rule__ActionSpec__Group_9__2__Impl" + // InternalRos1Parser.g:6308:1: rule__ActionSpec__Group_9__2__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group_9__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6312:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:6313:1: ( RULE_END ) + { + // InternalRos1Parser.g:6313:1: ( RULE_END ) + // InternalRos1Parser.g:6314:2: RULE_END + { + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__2__Impl" + + + // $ANTLR start "rule__MessageDefinition__Group__0" + // InternalRos1Parser.g:6324:1: rule__MessageDefinition__Group__0 : rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 ; + public final void rule__MessageDefinition__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6328:1: ( rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 ) + // InternalRos1Parser.g:6329:2: rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 + { + pushFollow(FOLLOW_26); + rule__MessageDefinition__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__MessageDefinition__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessageDefinition__Group__0" + + + // $ANTLR start "rule__MessageDefinition__Group__0__Impl" + // InternalRos1Parser.g:6336:1: rule__MessageDefinition__Group__0__Impl : ( () ) ; + public final void rule__MessageDefinition__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6340:1: ( ( () ) ) + // InternalRos1Parser.g:6341:1: ( () ) + { + // InternalRos1Parser.g:6341:1: ( () ) + // InternalRos1Parser.g:6342:2: () + { + before(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); + // InternalRos1Parser.g:6343:2: () + // InternalRos1Parser.g:6343:3: + { + } + + after(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessageDefinition__Group__0__Impl" + + + // $ANTLR start "rule__MessageDefinition__Group__1" + // InternalRos1Parser.g:6351:1: rule__MessageDefinition__Group__1 : rule__MessageDefinition__Group__1__Impl ; + public final void rule__MessageDefinition__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6355:1: ( rule__MessageDefinition__Group__1__Impl ) + // InternalRos1Parser.g:6356:2: rule__MessageDefinition__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__MessageDefinition__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessageDefinition__Group__1" + + + // $ANTLR start "rule__MessageDefinition__Group__1__Impl" + // InternalRos1Parser.g:6362:1: rule__MessageDefinition__Group__1__Impl : ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) ; + public final void rule__MessageDefinition__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6366:1: ( ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) ) + // InternalRos1Parser.g:6367:1: ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) + { + // InternalRos1Parser.g:6367:1: ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) + // InternalRos1Parser.g:6368:2: ( rule__MessageDefinition__MessagePartAssignment_1 )* + { + before(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); + // InternalRos1Parser.g:6369:2: ( rule__MessageDefinition__MessagePartAssignment_1 )* + loop38: + do { + int alt38=2; + int LA38_0 = input.LA(1); + + if ( ((LA38_0>=Float32_1 && LA38_0<=Float64_1)||LA38_0==Duration||(LA38_0>=String_2 && LA38_0<=Uint64_1)||(LA38_0>=Float32 && LA38_0<=Int64_1)||LA38_0==Uint8_1||LA38_0==Header||(LA38_0>=Bool_1 && LA38_0<=Int8_1)||(LA38_0>=String_1 && LA38_0<=Uint64)||(LA38_0>=Int16 && LA38_0<=Int64)||LA38_0==Uint8||(LA38_0>=Bool && LA38_0<=Byte)||LA38_0==Int8||LA38_0==Time||LA38_0==RULE_ID||LA38_0==RULE_STRING) ) { + alt38=1; + } + + + switch (alt38) { + case 1 : + // InternalRos1Parser.g:6369:3: rule__MessageDefinition__MessagePartAssignment_1 + { + pushFollow(FOLLOW_35); + rule__MessageDefinition__MessagePartAssignment_1(); + + state._fsp--; + + + } + break; + + default : + break loop38; + } + } while (true); + + after(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessageDefinition__Group__1__Impl" + + + // $ANTLR start "rule__Publisher__Group__0" + // InternalRos1Parser.g:6378: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:6382:1: ( rule__Publisher__Group__0__Impl rule__Publisher__Group__1 ) + // InternalRos1Parser.g:6383: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:6390:1: rule__Publisher__Group__0__Impl : ( () ) ; + public final void rule__Publisher__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6394:1: ( ( () ) ) + // InternalRos1Parser.g:6395:1: ( () ) + { + // InternalRos1Parser.g:6395:1: ( () ) + // InternalRos1Parser.g:6396:2: () + { + before(grammarAccess.getPublisherAccess().getPublisherAction_0()); + // InternalRos1Parser.g:6397:2: () + // InternalRos1Parser.g:6397: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:6405: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:6409:1: ( rule__Publisher__Group__1__Impl rule__Publisher__Group__2 ) + // InternalRos1Parser.g:6410: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:6417: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:6421:1: ( ( ( rule__Publisher__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:6422:1: ( ( rule__Publisher__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:6422:1: ( ( rule__Publisher__NameAssignment_1 ) ) + // InternalRos1Parser.g:6423:2: ( rule__Publisher__NameAssignment_1 ) + { + before(grammarAccess.getPublisherAccess().getNameAssignment_1()); + // InternalRos1Parser.g:6424:2: ( rule__Publisher__NameAssignment_1 ) + // InternalRos1Parser.g:6424: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:6432: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:6436:1: ( rule__Publisher__Group__2__Impl rule__Publisher__Group__3 ) + // InternalRos1Parser.g:6437: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:6444:1: rule__Publisher__Group__2__Impl : ( Colon ) ; + public final void rule__Publisher__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6448:1: ( ( Colon ) ) + // InternalRos1Parser.g:6449:1: ( Colon ) + { + // InternalRos1Parser.g:6449:1: ( Colon ) + // InternalRos1Parser.g:6450: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:6459: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:6463:1: ( rule__Publisher__Group__3__Impl rule__Publisher__Group__4 ) + // InternalRos1Parser.g:6464:2: rule__Publisher__Group__3__Impl rule__Publisher__Group__4 + { + pushFollow(FOLLOW_36); + 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:6471:1: rule__Publisher__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Publisher__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6475:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:6476:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:6476:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:6477: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:6486: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:6490:1: ( rule__Publisher__Group__4__Impl rule__Publisher__Group__5 ) + // InternalRos1Parser.g:6491: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:6498:1: rule__Publisher__Group__4__Impl : ( Type_1 ) ; + public final void rule__Publisher__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6502:1: ( ( Type_1 ) ) + // InternalRos1Parser.g:6503:1: ( Type_1 ) + { + // InternalRos1Parser.g:6503:1: ( Type_1 ) + // InternalRos1Parser.g:6504:2: Type_1 + { + before(grammarAccess.getPublisherAccess().getTypeKeyword_4()); + match(input,Type_1,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:6513: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:6517:1: ( rule__Publisher__Group__5__Impl rule__Publisher__Group__6 ) + // InternalRos1Parser.g:6518:2: rule__Publisher__Group__5__Impl rule__Publisher__Group__6 + { + pushFollow(FOLLOW_37); + 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:6525: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:6529:1: ( ( ( rule__Publisher__MessageAssignment_5 ) ) ) + // InternalRos1Parser.g:6530:1: ( ( rule__Publisher__MessageAssignment_5 ) ) + { + // InternalRos1Parser.g:6530:1: ( ( rule__Publisher__MessageAssignment_5 ) ) + // InternalRos1Parser.g:6531:2: ( rule__Publisher__MessageAssignment_5 ) + { + before(grammarAccess.getPublisherAccess().getMessageAssignment_5()); + // InternalRos1Parser.g:6532:2: ( rule__Publisher__MessageAssignment_5 ) + // InternalRos1Parser.g:6532: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:6540:1: rule__Publisher__Group__6 : rule__Publisher__Group__6__Impl rule__Publisher__Group__7 ; + public final void rule__Publisher__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6544:1: ( rule__Publisher__Group__6__Impl rule__Publisher__Group__7 ) + // InternalRos1Parser.g:6545:2: rule__Publisher__Group__6__Impl rule__Publisher__Group__7 + { + pushFollow(FOLLOW_37); + rule__Publisher__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group__7(); + + 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:6552:1: rule__Publisher__Group__6__Impl : ( ( rule__Publisher__Group_6__0 )? ) ; + public final void rule__Publisher__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6556:1: ( ( ( rule__Publisher__Group_6__0 )? ) ) + // InternalRos1Parser.g:6557:1: ( ( rule__Publisher__Group_6__0 )? ) + { + // InternalRos1Parser.g:6557:1: ( ( rule__Publisher__Group_6__0 )? ) + // InternalRos1Parser.g:6558:2: ( rule__Publisher__Group_6__0 )? + { + before(grammarAccess.getPublisherAccess().getGroup_6()); + // InternalRos1Parser.g:6559:2: ( rule__Publisher__Group_6__0 )? + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0==Ns) ) { + alt39=1; + } + switch (alt39) { + case 1 : + // InternalRos1Parser.g:6559:3: rule__Publisher__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Publisher__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPublisherAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__6__Impl" + + + // $ANTLR start "rule__Publisher__Group__7" + // InternalRos1Parser.g:6567:1: rule__Publisher__Group__7 : rule__Publisher__Group__7__Impl ; + public final void rule__Publisher__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6571:1: ( rule__Publisher__Group__7__Impl ) + // InternalRos1Parser.g:6572:2: rule__Publisher__Group__7__Impl + { + pushFollow(FOLLOW_2); + rule__Publisher__Group__7__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__7" + + + // $ANTLR start "rule__Publisher__Group__7__Impl" + // InternalRos1Parser.g:6578:1: rule__Publisher__Group__7__Impl : ( RULE_END ) ; + public final void rule__Publisher__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6582:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:6583:1: ( RULE_END ) + { + // InternalRos1Parser.g:6583:1: ( RULE_END ) + // InternalRos1Parser.g:6584:2: RULE_END + { + before(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__7__Impl" + + + // $ANTLR start "rule__Publisher__Group_6__0" + // InternalRos1Parser.g:6594:1: rule__Publisher__Group_6__0 : rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 ; + public final void rule__Publisher__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6598:1: ( rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 ) + // InternalRos1Parser.g:6599:2: rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 + { + pushFollow(FOLLOW_38); + rule__Publisher__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_6__0" + + + // $ANTLR start "rule__Publisher__Group_6__0__Impl" + // InternalRos1Parser.g:6606:1: rule__Publisher__Group_6__0__Impl : ( Ns ) ; + public final void rule__Publisher__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6610:1: ( ( Ns ) ) + // InternalRos1Parser.g:6611:1: ( Ns ) + { + // InternalRos1Parser.g:6611:1: ( Ns ) + // InternalRos1Parser.g:6612:2: Ns + { + before(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_6__0__Impl" + + + // $ANTLR start "rule__Publisher__Group_6__1" + // InternalRos1Parser.g:6621:1: rule__Publisher__Group_6__1 : rule__Publisher__Group_6__1__Impl ; + public final void rule__Publisher__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6625:1: ( rule__Publisher__Group_6__1__Impl ) + // InternalRos1Parser.g:6626:2: rule__Publisher__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__Publisher__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_6__1" + + + // $ANTLR start "rule__Publisher__Group_6__1__Impl" + // InternalRos1Parser.g:6632:1: rule__Publisher__Group_6__1__Impl : ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) ; + public final void rule__Publisher__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6636:1: ( ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) ) + // InternalRos1Parser.g:6637:1: ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) + { + // InternalRos1Parser.g:6637:1: ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) + // InternalRos1Parser.g:6638:2: ( rule__Publisher__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); + // InternalRos1Parser.g:6639:2: ( rule__Publisher__NamespaceAssignment_6_1 ) + // InternalRos1Parser.g:6639:3: rule__Publisher__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__Publisher__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_6__1__Impl" + + + // $ANTLR start "rule__Subscriber__Group__0" + // InternalRos1Parser.g:6648: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:6652:1: ( rule__Subscriber__Group__0__Impl rule__Subscriber__Group__1 ) + // InternalRos1Parser.g:6653: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:6660:1: rule__Subscriber__Group__0__Impl : ( () ) ; + public final void rule__Subscriber__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6664:1: ( ( () ) ) + // InternalRos1Parser.g:6665:1: ( () ) + { + // InternalRos1Parser.g:6665:1: ( () ) + // InternalRos1Parser.g:6666:2: () + { + before(grammarAccess.getSubscriberAccess().getSubscriberAction_0()); + // InternalRos1Parser.g:6667:2: () + // InternalRos1Parser.g:6667: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:6675: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:6679:1: ( rule__Subscriber__Group__1__Impl rule__Subscriber__Group__2 ) + // InternalRos1Parser.g:6680: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:6687: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:6691:1: ( ( ( rule__Subscriber__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:6692:1: ( ( rule__Subscriber__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:6692:1: ( ( rule__Subscriber__NameAssignment_1 ) ) + // InternalRos1Parser.g:6693:2: ( rule__Subscriber__NameAssignment_1 ) + { + before(grammarAccess.getSubscriberAccess().getNameAssignment_1()); + // InternalRos1Parser.g:6694:2: ( rule__Subscriber__NameAssignment_1 ) + // InternalRos1Parser.g:6694: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:6702: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:6706:1: ( rule__Subscriber__Group__2__Impl rule__Subscriber__Group__3 ) + // InternalRos1Parser.g:6707: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:6714:1: rule__Subscriber__Group__2__Impl : ( Colon ) ; + public final void rule__Subscriber__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6718:1: ( ( Colon ) ) + // InternalRos1Parser.g:6719:1: ( Colon ) + { + // InternalRos1Parser.g:6719:1: ( Colon ) + // InternalRos1Parser.g:6720: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:6729: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:6733:1: ( rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 ) + // InternalRos1Parser.g:6734:2: rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 + { + pushFollow(FOLLOW_36); + 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:6741:1: rule__Subscriber__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Subscriber__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6745:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:6746:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:6746:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:6747: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:6756: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:6760:1: ( rule__Subscriber__Group__4__Impl rule__Subscriber__Group__5 ) + // InternalRos1Parser.g:6761: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:6768:1: rule__Subscriber__Group__4__Impl : ( Type_1 ) ; + public final void rule__Subscriber__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6772:1: ( ( Type_1 ) ) + // InternalRos1Parser.g:6773:1: ( Type_1 ) + { + // InternalRos1Parser.g:6773:1: ( Type_1 ) + // InternalRos1Parser.g:6774:2: Type_1 + { + before(grammarAccess.getSubscriberAccess().getTypeKeyword_4()); + match(input,Type_1,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:6783: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:6787:1: ( rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 ) + // InternalRos1Parser.g:6788:2: rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 + { + pushFollow(FOLLOW_37); + 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:6795: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:6799:1: ( ( ( rule__Subscriber__MessageAssignment_5 ) ) ) + // InternalRos1Parser.g:6800:1: ( ( rule__Subscriber__MessageAssignment_5 ) ) + { + // InternalRos1Parser.g:6800:1: ( ( rule__Subscriber__MessageAssignment_5 ) ) + // InternalRos1Parser.g:6801:2: ( rule__Subscriber__MessageAssignment_5 ) + { + before(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); + // InternalRos1Parser.g:6802:2: ( rule__Subscriber__MessageAssignment_5 ) + // InternalRos1Parser.g:6802: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:6810:1: rule__Subscriber__Group__6 : rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 ; + public final void rule__Subscriber__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6814:1: ( rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 ) + // InternalRos1Parser.g:6815:2: rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 + { + pushFollow(FOLLOW_37); + rule__Subscriber__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group__7(); + + 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:6822:1: rule__Subscriber__Group__6__Impl : ( ( rule__Subscriber__Group_6__0 )? ) ; + public final void rule__Subscriber__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6826:1: ( ( ( rule__Subscriber__Group_6__0 )? ) ) + // InternalRos1Parser.g:6827:1: ( ( rule__Subscriber__Group_6__0 )? ) + { + // InternalRos1Parser.g:6827:1: ( ( rule__Subscriber__Group_6__0 )? ) + // InternalRos1Parser.g:6828:2: ( rule__Subscriber__Group_6__0 )? + { + before(grammarAccess.getSubscriberAccess().getGroup_6()); + // InternalRos1Parser.g:6829:2: ( rule__Subscriber__Group_6__0 )? + int alt40=2; + int LA40_0 = input.LA(1); + + if ( (LA40_0==Ns) ) { + alt40=1; + } + switch (alt40) { + case 1 : + // InternalRos1Parser.g:6829:3: rule__Subscriber__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Subscriber__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getSubscriberAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__6__Impl" + + + // $ANTLR start "rule__Subscriber__Group__7" + // InternalRos1Parser.g:6837:1: rule__Subscriber__Group__7 : rule__Subscriber__Group__7__Impl ; + public final void rule__Subscriber__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6841:1: ( rule__Subscriber__Group__7__Impl ) + // InternalRos1Parser.g:6842:2: rule__Subscriber__Group__7__Impl + { + pushFollow(FOLLOW_2); + rule__Subscriber__Group__7__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__7" + + + // $ANTLR start "rule__Subscriber__Group__7__Impl" + // InternalRos1Parser.g:6848:1: rule__Subscriber__Group__7__Impl : ( RULE_END ) ; + public final void rule__Subscriber__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6852:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:6853:1: ( RULE_END ) + { + // InternalRos1Parser.g:6853:1: ( RULE_END ) + // InternalRos1Parser.g:6854:2: RULE_END + { + before(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__7__Impl" + + + // $ANTLR start "rule__Subscriber__Group_6__0" + // InternalRos1Parser.g:6864:1: rule__Subscriber__Group_6__0 : rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 ; + public final void rule__Subscriber__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6868:1: ( rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 ) + // InternalRos1Parser.g:6869:2: rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 + { + pushFollow(FOLLOW_38); + rule__Subscriber__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_6__0" + + + // $ANTLR start "rule__Subscriber__Group_6__0__Impl" + // InternalRos1Parser.g:6876:1: rule__Subscriber__Group_6__0__Impl : ( Ns ) ; + public final void rule__Subscriber__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6880:1: ( ( Ns ) ) + // InternalRos1Parser.g:6881:1: ( Ns ) + { + // InternalRos1Parser.g:6881:1: ( Ns ) + // InternalRos1Parser.g:6882:2: Ns + { + before(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_6__0__Impl" + + + // $ANTLR start "rule__Subscriber__Group_6__1" + // InternalRos1Parser.g:6891:1: rule__Subscriber__Group_6__1 : rule__Subscriber__Group_6__1__Impl ; + public final void rule__Subscriber__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6895:1: ( rule__Subscriber__Group_6__1__Impl ) + // InternalRos1Parser.g:6896:2: rule__Subscriber__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__Subscriber__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_6__1" + + + // $ANTLR start "rule__Subscriber__Group_6__1__Impl" + // InternalRos1Parser.g:6902:1: rule__Subscriber__Group_6__1__Impl : ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) ; + public final void rule__Subscriber__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6906:1: ( ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) ) + // InternalRos1Parser.g:6907:1: ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) + { + // InternalRos1Parser.g:6907:1: ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) + // InternalRos1Parser.g:6908:2: ( rule__Subscriber__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); + // InternalRos1Parser.g:6909:2: ( rule__Subscriber__NamespaceAssignment_6_1 ) + // InternalRos1Parser.g:6909:3: rule__Subscriber__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__Subscriber__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_6__1__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__0" + // InternalRos1Parser.g:6918:1: rule__ServiceServer__Group__0 : rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 ; + public final void rule__ServiceServer__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6922:1: ( rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 ) + // InternalRos1Parser.g:6923:2: rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 + { + pushFollow(FOLLOW_7); + rule__ServiceServer__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__0" + + + // $ANTLR start "rule__ServiceServer__Group__0__Impl" + // InternalRos1Parser.g:6930:1: rule__ServiceServer__Group__0__Impl : ( () ) ; + public final void rule__ServiceServer__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6934:1: ( ( () ) ) + // InternalRos1Parser.g:6935:1: ( () ) + { + // InternalRos1Parser.g:6935:1: ( () ) + // InternalRos1Parser.g:6936:2: () + { + before(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); + // InternalRos1Parser.g:6937:2: () + // InternalRos1Parser.g:6937:3: + { + } + + after(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__0__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__1" + // InternalRos1Parser.g:6945:1: rule__ServiceServer__Group__1 : rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 ; + public final void rule__ServiceServer__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6949:1: ( rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 ) + // InternalRos1Parser.g:6950:2: rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 + { + pushFollow(FOLLOW_4); + rule__ServiceServer__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__1" + + + // $ANTLR start "rule__ServiceServer__Group__1__Impl" + // InternalRos1Parser.g:6957:1: rule__ServiceServer__Group__1__Impl : ( ( rule__ServiceServer__NameAssignment_1 ) ) ; + public final void rule__ServiceServer__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6961:1: ( ( ( rule__ServiceServer__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:6962:1: ( ( rule__ServiceServer__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:6962:1: ( ( rule__ServiceServer__NameAssignment_1 ) ) + // InternalRos1Parser.g:6963:2: ( rule__ServiceServer__NameAssignment_1 ) + { + before(grammarAccess.getServiceServerAccess().getNameAssignment_1()); + // InternalRos1Parser.g:6964:2: ( rule__ServiceServer__NameAssignment_1 ) + // InternalRos1Parser.g:6964:3: rule__ServiceServer__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceServerAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__1__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__2" + // InternalRos1Parser.g:6972:1: rule__ServiceServer__Group__2 : rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 ; + public final void rule__ServiceServer__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6976:1: ( rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 ) + // InternalRos1Parser.g:6977:2: rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 + { + pushFollow(FOLLOW_5); + rule__ServiceServer__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__2" + + + // $ANTLR start "rule__ServiceServer__Group__2__Impl" + // InternalRos1Parser.g:6984:1: rule__ServiceServer__Group__2__Impl : ( Colon ) ; + public final void rule__ServiceServer__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:6988:1: ( ( Colon ) ) + // InternalRos1Parser.g:6989:1: ( Colon ) + { + // InternalRos1Parser.g:6989:1: ( Colon ) + // InternalRos1Parser.g:6990:2: Colon + { + before(grammarAccess.getServiceServerAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__2__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__3" + // InternalRos1Parser.g:6999:1: rule__ServiceServer__Group__3 : rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 ; + public final void rule__ServiceServer__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7003:1: ( rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 ) + // InternalRos1Parser.g:7004:2: rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 + { + pushFollow(FOLLOW_36); + rule__ServiceServer__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__3" + + + // $ANTLR start "rule__ServiceServer__Group__3__Impl" + // InternalRos1Parser.g:7011:1: rule__ServiceServer__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceServer__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7015:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:7016:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:7016:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:7017:2: RULE_BEGIN + { + before(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__3__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__4" + // InternalRos1Parser.g:7026:1: rule__ServiceServer__Group__4 : rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 ; + public final void rule__ServiceServer__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7030:1: ( rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 ) + // InternalRos1Parser.g:7031:2: rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 + { + pushFollow(FOLLOW_7); + rule__ServiceServer__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__4" + + + // $ANTLR start "rule__ServiceServer__Group__4__Impl" + // InternalRos1Parser.g:7038:1: rule__ServiceServer__Group__4__Impl : ( Type_1 ) ; + public final void rule__ServiceServer__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7042:1: ( ( Type_1 ) ) + // InternalRos1Parser.g:7043:1: ( Type_1 ) + { + // InternalRos1Parser.g:7043:1: ( Type_1 ) + // InternalRos1Parser.g:7044:2: Type_1 + { + before(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__4__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__5" + // InternalRos1Parser.g:7053:1: rule__ServiceServer__Group__5 : rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 ; + public final void rule__ServiceServer__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7057:1: ( rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 ) + // InternalRos1Parser.g:7058:2: rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 + { + pushFollow(FOLLOW_37); + rule__ServiceServer__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__5" + + + // $ANTLR start "rule__ServiceServer__Group__5__Impl" + // InternalRos1Parser.g:7065:1: rule__ServiceServer__Group__5__Impl : ( ( rule__ServiceServer__ServiceAssignment_5 ) ) ; + public final void rule__ServiceServer__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7069:1: ( ( ( rule__ServiceServer__ServiceAssignment_5 ) ) ) + // InternalRos1Parser.g:7070:1: ( ( rule__ServiceServer__ServiceAssignment_5 ) ) + { + // InternalRos1Parser.g:7070:1: ( ( rule__ServiceServer__ServiceAssignment_5 ) ) + // InternalRos1Parser.g:7071:2: ( rule__ServiceServer__ServiceAssignment_5 ) + { + before(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); + // InternalRos1Parser.g:7072:2: ( rule__ServiceServer__ServiceAssignment_5 ) + // InternalRos1Parser.g:7072:3: rule__ServiceServer__ServiceAssignment_5 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__ServiceAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__5__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__6" + // InternalRos1Parser.g:7080:1: rule__ServiceServer__Group__6 : rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 ; + public final void rule__ServiceServer__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7084:1: ( rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 ) + // InternalRos1Parser.g:7085:2: rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 + { + pushFollow(FOLLOW_37); + rule__ServiceServer__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__6" + + + // $ANTLR start "rule__ServiceServer__Group__6__Impl" + // InternalRos1Parser.g:7092:1: rule__ServiceServer__Group__6__Impl : ( ( rule__ServiceServer__Group_6__0 )? ) ; + public final void rule__ServiceServer__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7096:1: ( ( ( rule__ServiceServer__Group_6__0 )? ) ) + // InternalRos1Parser.g:7097:1: ( ( rule__ServiceServer__Group_6__0 )? ) + { + // InternalRos1Parser.g:7097:1: ( ( rule__ServiceServer__Group_6__0 )? ) + // InternalRos1Parser.g:7098:2: ( rule__ServiceServer__Group_6__0 )? + { + before(grammarAccess.getServiceServerAccess().getGroup_6()); + // InternalRos1Parser.g:7099:2: ( rule__ServiceServer__Group_6__0 )? + int alt41=2; + int LA41_0 = input.LA(1); + + if ( (LA41_0==Ns) ) { + alt41=1; + } + switch (alt41) { + case 1 : + // InternalRos1Parser.g:7099:3: rule__ServiceServer__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceServerAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__6__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__7" + // InternalRos1Parser.g:7107:1: rule__ServiceServer__Group__7 : rule__ServiceServer__Group__7__Impl ; + public final void rule__ServiceServer__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7111:1: ( rule__ServiceServer__Group__7__Impl ) + // InternalRos1Parser.g:7112:2: rule__ServiceServer__Group__7__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__7__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__7" + + + // $ANTLR start "rule__ServiceServer__Group__7__Impl" + // InternalRos1Parser.g:7118:1: rule__ServiceServer__Group__7__Impl : ( RULE_END ) ; + public final void rule__ServiceServer__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7122:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:7123:1: ( RULE_END ) + { + // InternalRos1Parser.g:7123:1: ( RULE_END ) + // InternalRos1Parser.g:7124:2: RULE_END + { + before(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__7__Impl" + + + // $ANTLR start "rule__ServiceServer__Group_6__0" + // InternalRos1Parser.g:7134:1: rule__ServiceServer__Group_6__0 : rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 ; + public final void rule__ServiceServer__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7138:1: ( rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 ) + // InternalRos1Parser.g:7139:2: rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 + { + pushFollow(FOLLOW_38); + rule__ServiceServer__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_6__0" + + + // $ANTLR start "rule__ServiceServer__Group_6__0__Impl" + // InternalRos1Parser.g:7146:1: rule__ServiceServer__Group_6__0__Impl : ( Ns ) ; + public final void rule__ServiceServer__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7150:1: ( ( Ns ) ) + // InternalRos1Parser.g:7151:1: ( Ns ) + { + // InternalRos1Parser.g:7151:1: ( Ns ) + // InternalRos1Parser.g:7152:2: Ns + { + before(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_6__0__Impl" + + + // $ANTLR start "rule__ServiceServer__Group_6__1" + // InternalRos1Parser.g:7161:1: rule__ServiceServer__Group_6__1 : rule__ServiceServer__Group_6__1__Impl ; + public final void rule__ServiceServer__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7165:1: ( rule__ServiceServer__Group_6__1__Impl ) + // InternalRos1Parser.g:7166:2: rule__ServiceServer__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceServer__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_6__1" + + + // $ANTLR start "rule__ServiceServer__Group_6__1__Impl" + // InternalRos1Parser.g:7172:1: rule__ServiceServer__Group_6__1__Impl : ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) ; + public final void rule__ServiceServer__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7176:1: ( ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) ) + // InternalRos1Parser.g:7177:1: ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) + { + // InternalRos1Parser.g:7177:1: ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) + // InternalRos1Parser.g:7178:2: ( rule__ServiceServer__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); + // InternalRos1Parser.g:7179:2: ( rule__ServiceServer__NamespaceAssignment_6_1 ) + // InternalRos1Parser.g:7179:3: rule__ServiceServer__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_6__1__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__0" + // InternalRos1Parser.g:7188:1: rule__ServiceClient__Group__0 : rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 ; + public final void rule__ServiceClient__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7192:1: ( rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 ) + // InternalRos1Parser.g:7193:2: rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 + { + pushFollow(FOLLOW_7); + rule__ServiceClient__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__0" + + + // $ANTLR start "rule__ServiceClient__Group__0__Impl" + // InternalRos1Parser.g:7200:1: rule__ServiceClient__Group__0__Impl : ( () ) ; + public final void rule__ServiceClient__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7204:1: ( ( () ) ) + // InternalRos1Parser.g:7205:1: ( () ) + { + // InternalRos1Parser.g:7205:1: ( () ) + // InternalRos1Parser.g:7206:2: () + { + before(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); + // InternalRos1Parser.g:7207:2: () + // InternalRos1Parser.g:7207:3: + { + } + + after(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__0__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__1" + // InternalRos1Parser.g:7215:1: rule__ServiceClient__Group__1 : rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 ; + public final void rule__ServiceClient__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7219:1: ( rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 ) + // InternalRos1Parser.g:7220:2: rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 + { + pushFollow(FOLLOW_4); + rule__ServiceClient__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__1" + + + // $ANTLR start "rule__ServiceClient__Group__1__Impl" + // InternalRos1Parser.g:7227:1: rule__ServiceClient__Group__1__Impl : ( ( rule__ServiceClient__NameAssignment_1 ) ) ; + public final void rule__ServiceClient__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7231:1: ( ( ( rule__ServiceClient__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:7232:1: ( ( rule__ServiceClient__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:7232:1: ( ( rule__ServiceClient__NameAssignment_1 ) ) + // InternalRos1Parser.g:7233:2: ( rule__ServiceClient__NameAssignment_1 ) + { + before(grammarAccess.getServiceClientAccess().getNameAssignment_1()); + // InternalRos1Parser.g:7234:2: ( rule__ServiceClient__NameAssignment_1 ) + // InternalRos1Parser.g:7234:3: rule__ServiceClient__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceClientAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__1__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__2" + // InternalRos1Parser.g:7242:1: rule__ServiceClient__Group__2 : rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 ; + public final void rule__ServiceClient__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7246:1: ( rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 ) + // InternalRos1Parser.g:7247:2: rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 + { + pushFollow(FOLLOW_5); + rule__ServiceClient__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__2" + + + // $ANTLR start "rule__ServiceClient__Group__2__Impl" + // InternalRos1Parser.g:7254:1: rule__ServiceClient__Group__2__Impl : ( Colon ) ; + public final void rule__ServiceClient__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7258:1: ( ( Colon ) ) + // InternalRos1Parser.g:7259:1: ( Colon ) + { + // InternalRos1Parser.g:7259:1: ( Colon ) + // InternalRos1Parser.g:7260:2: Colon + { + before(grammarAccess.getServiceClientAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__2__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__3" + // InternalRos1Parser.g:7269:1: rule__ServiceClient__Group__3 : rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 ; + public final void rule__ServiceClient__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7273:1: ( rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 ) + // InternalRos1Parser.g:7274:2: rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 + { + pushFollow(FOLLOW_36); + rule__ServiceClient__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__3" + + + // $ANTLR start "rule__ServiceClient__Group__3__Impl" + // InternalRos1Parser.g:7281:1: rule__ServiceClient__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceClient__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7285:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:7286:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:7286:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:7287:2: RULE_BEGIN + { + before(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__3__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__4" + // InternalRos1Parser.g:7296:1: rule__ServiceClient__Group__4 : rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 ; + public final void rule__ServiceClient__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7300:1: ( rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 ) + // InternalRos1Parser.g:7301:2: rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 + { + pushFollow(FOLLOW_7); + rule__ServiceClient__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__4" + + + // $ANTLR start "rule__ServiceClient__Group__4__Impl" + // InternalRos1Parser.g:7308:1: rule__ServiceClient__Group__4__Impl : ( Type_1 ) ; + public final void rule__ServiceClient__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7312:1: ( ( Type_1 ) ) + // InternalRos1Parser.g:7313:1: ( Type_1 ) + { + // InternalRos1Parser.g:7313:1: ( Type_1 ) + // InternalRos1Parser.g:7314:2: Type_1 + { + before(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__4__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__5" + // InternalRos1Parser.g:7323:1: rule__ServiceClient__Group__5 : rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 ; + public final void rule__ServiceClient__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7327:1: ( rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 ) + // InternalRos1Parser.g:7328:2: rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 + { + pushFollow(FOLLOW_37); + rule__ServiceClient__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__5" + + + // $ANTLR start "rule__ServiceClient__Group__5__Impl" + // InternalRos1Parser.g:7335:1: rule__ServiceClient__Group__5__Impl : ( ( rule__ServiceClient__ServiceAssignment_5 ) ) ; + public final void rule__ServiceClient__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7339:1: ( ( ( rule__ServiceClient__ServiceAssignment_5 ) ) ) + // InternalRos1Parser.g:7340:1: ( ( rule__ServiceClient__ServiceAssignment_5 ) ) + { + // InternalRos1Parser.g:7340:1: ( ( rule__ServiceClient__ServiceAssignment_5 ) ) + // InternalRos1Parser.g:7341:2: ( rule__ServiceClient__ServiceAssignment_5 ) + { + before(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); + // InternalRos1Parser.g:7342:2: ( rule__ServiceClient__ServiceAssignment_5 ) + // InternalRos1Parser.g:7342:3: rule__ServiceClient__ServiceAssignment_5 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__ServiceAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__5__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__6" + // InternalRos1Parser.g:7350:1: rule__ServiceClient__Group__6 : rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 ; + public final void rule__ServiceClient__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7354:1: ( rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 ) + // InternalRos1Parser.g:7355:2: rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 + { + pushFollow(FOLLOW_37); + rule__ServiceClient__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__6" + + + // $ANTLR start "rule__ServiceClient__Group__6__Impl" + // InternalRos1Parser.g:7362:1: rule__ServiceClient__Group__6__Impl : ( ( rule__ServiceClient__Group_6__0 )? ) ; + public final void rule__ServiceClient__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7366:1: ( ( ( rule__ServiceClient__Group_6__0 )? ) ) + // InternalRos1Parser.g:7367:1: ( ( rule__ServiceClient__Group_6__0 )? ) + { + // InternalRos1Parser.g:7367:1: ( ( rule__ServiceClient__Group_6__0 )? ) + // InternalRos1Parser.g:7368:2: ( rule__ServiceClient__Group_6__0 )? + { + before(grammarAccess.getServiceClientAccess().getGroup_6()); + // InternalRos1Parser.g:7369:2: ( rule__ServiceClient__Group_6__0 )? + int alt42=2; + int LA42_0 = input.LA(1); + + if ( (LA42_0==Ns) ) { + alt42=1; + } + switch (alt42) { + case 1 : + // InternalRos1Parser.g:7369:3: rule__ServiceClient__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceClientAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__6__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__7" + // InternalRos1Parser.g:7377:1: rule__ServiceClient__Group__7 : rule__ServiceClient__Group__7__Impl ; + public final void rule__ServiceClient__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7381:1: ( rule__ServiceClient__Group__7__Impl ) + // InternalRos1Parser.g:7382:2: rule__ServiceClient__Group__7__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__7__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__7" + + + // $ANTLR start "rule__ServiceClient__Group__7__Impl" + // InternalRos1Parser.g:7388:1: rule__ServiceClient__Group__7__Impl : ( RULE_END ) ; + public final void rule__ServiceClient__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7392:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:7393:1: ( RULE_END ) + { + // InternalRos1Parser.g:7393:1: ( RULE_END ) + // InternalRos1Parser.g:7394:2: RULE_END + { + before(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__7__Impl" + + + // $ANTLR start "rule__ServiceClient__Group_6__0" + // InternalRos1Parser.g:7404:1: rule__ServiceClient__Group_6__0 : rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 ; + public final void rule__ServiceClient__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7408:1: ( rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 ) + // InternalRos1Parser.g:7409:2: rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 + { + pushFollow(FOLLOW_38); + rule__ServiceClient__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_6__0" + + + // $ANTLR start "rule__ServiceClient__Group_6__0__Impl" + // InternalRos1Parser.g:7416:1: rule__ServiceClient__Group_6__0__Impl : ( Ns ) ; + public final void rule__ServiceClient__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7420:1: ( ( Ns ) ) + // InternalRos1Parser.g:7421:1: ( Ns ) + { + // InternalRos1Parser.g:7421:1: ( Ns ) + // InternalRos1Parser.g:7422:2: Ns + { + before(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_6__0__Impl" + + + // $ANTLR start "rule__ServiceClient__Group_6__1" + // InternalRos1Parser.g:7431:1: rule__ServiceClient__Group_6__1 : rule__ServiceClient__Group_6__1__Impl ; + public final void rule__ServiceClient__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7435:1: ( rule__ServiceClient__Group_6__1__Impl ) + // InternalRos1Parser.g:7436:2: rule__ServiceClient__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceClient__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_6__1" + + + // $ANTLR start "rule__ServiceClient__Group_6__1__Impl" + // InternalRos1Parser.g:7442:1: rule__ServiceClient__Group_6__1__Impl : ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) ; + public final void rule__ServiceClient__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7446:1: ( ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) ) + // InternalRos1Parser.g:7447:1: ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) + { + // InternalRos1Parser.g:7447:1: ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) + // InternalRos1Parser.g:7448:2: ( rule__ServiceClient__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); + // InternalRos1Parser.g:7449:2: ( rule__ServiceClient__NamespaceAssignment_6_1 ) + // InternalRos1Parser.g:7449:3: rule__ServiceClient__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_6__1__Impl" + + + // $ANTLR start "rule__ActionServer__Group__0" + // InternalRos1Parser.g:7458:1: rule__ActionServer__Group__0 : rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 ; + public final void rule__ActionServer__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7462:1: ( rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 ) + // InternalRos1Parser.g:7463:2: rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 + { + pushFollow(FOLLOW_7); + rule__ActionServer__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__0" + + + // $ANTLR start "rule__ActionServer__Group__0__Impl" + // InternalRos1Parser.g:7470:1: rule__ActionServer__Group__0__Impl : ( () ) ; + public final void rule__ActionServer__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7474:1: ( ( () ) ) + // InternalRos1Parser.g:7475:1: ( () ) + { + // InternalRos1Parser.g:7475:1: ( () ) + // InternalRos1Parser.g:7476:2: () + { + before(grammarAccess.getActionServerAccess().getActionServerAction_0()); + // InternalRos1Parser.g:7477:2: () + // InternalRos1Parser.g:7477:3: + { + } + + after(grammarAccess.getActionServerAccess().getActionServerAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__0__Impl" + + + // $ANTLR start "rule__ActionServer__Group__1" + // InternalRos1Parser.g:7485:1: rule__ActionServer__Group__1 : rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 ; + public final void rule__ActionServer__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7489:1: ( rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 ) + // InternalRos1Parser.g:7490:2: rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 + { + pushFollow(FOLLOW_4); + rule__ActionServer__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__1" + + + // $ANTLR start "rule__ActionServer__Group__1__Impl" + // InternalRos1Parser.g:7497:1: rule__ActionServer__Group__1__Impl : ( ( rule__ActionServer__NameAssignment_1 ) ) ; + public final void rule__ActionServer__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7501:1: ( ( ( rule__ActionServer__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:7502:1: ( ( rule__ActionServer__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:7502:1: ( ( rule__ActionServer__NameAssignment_1 ) ) + // InternalRos1Parser.g:7503:2: ( rule__ActionServer__NameAssignment_1 ) + { + before(grammarAccess.getActionServerAccess().getNameAssignment_1()); + // InternalRos1Parser.g:7504:2: ( rule__ActionServer__NameAssignment_1 ) + // InternalRos1Parser.g:7504:3: rule__ActionServer__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ActionServer__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionServerAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__1__Impl" + + + // $ANTLR start "rule__ActionServer__Group__2" + // InternalRos1Parser.g:7512:1: rule__ActionServer__Group__2 : rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 ; + public final void rule__ActionServer__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7516:1: ( rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 ) + // InternalRos1Parser.g:7517:2: rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 + { + pushFollow(FOLLOW_5); + rule__ActionServer__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__2" + + + // $ANTLR start "rule__ActionServer__Group__2__Impl" + // InternalRos1Parser.g:7524:1: rule__ActionServer__Group__2__Impl : ( Colon ) ; + public final void rule__ActionServer__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7528:1: ( ( Colon ) ) + // InternalRos1Parser.g:7529:1: ( Colon ) + { + // InternalRos1Parser.g:7529:1: ( Colon ) + // InternalRos1Parser.g:7530:2: Colon + { + before(grammarAccess.getActionServerAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__2__Impl" + + + // $ANTLR start "rule__ActionServer__Group__3" + // InternalRos1Parser.g:7539:1: rule__ActionServer__Group__3 : rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 ; + public final void rule__ActionServer__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7543:1: ( rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 ) + // InternalRos1Parser.g:7544:2: rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 + { + pushFollow(FOLLOW_36); + rule__ActionServer__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__3" + + + // $ANTLR start "rule__ActionServer__Group__3__Impl" + // InternalRos1Parser.g:7551:1: rule__ActionServer__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionServer__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7555:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:7556:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:7556:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:7557:2: RULE_BEGIN + { + before(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__3__Impl" + + + // $ANTLR start "rule__ActionServer__Group__4" + // InternalRos1Parser.g:7566:1: rule__ActionServer__Group__4 : rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 ; + public final void rule__ActionServer__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7570:1: ( rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 ) + // InternalRos1Parser.g:7571:2: rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 + { + pushFollow(FOLLOW_7); + rule__ActionServer__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__4" + + + // $ANTLR start "rule__ActionServer__Group__4__Impl" + // InternalRos1Parser.g:7578:1: rule__ActionServer__Group__4__Impl : ( Type_1 ) ; + public final void rule__ActionServer__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7582:1: ( ( Type_1 ) ) + // InternalRos1Parser.g:7583:1: ( Type_1 ) + { + // InternalRos1Parser.g:7583:1: ( Type_1 ) + // InternalRos1Parser.g:7584:2: Type_1 + { + before(grammarAccess.getActionServerAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getTypeKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__4__Impl" + + + // $ANTLR start "rule__ActionServer__Group__5" + // InternalRos1Parser.g:7593:1: rule__ActionServer__Group__5 : rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 ; + public final void rule__ActionServer__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7597:1: ( rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 ) + // InternalRos1Parser.g:7598:2: rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 + { + pushFollow(FOLLOW_37); + rule__ActionServer__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__5" + + + // $ANTLR start "rule__ActionServer__Group__5__Impl" + // InternalRos1Parser.g:7605:1: rule__ActionServer__Group__5__Impl : ( ( rule__ActionServer__ActionAssignment_5 ) ) ; + public final void rule__ActionServer__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7609:1: ( ( ( rule__ActionServer__ActionAssignment_5 ) ) ) + // InternalRos1Parser.g:7610:1: ( ( rule__ActionServer__ActionAssignment_5 ) ) + { + // InternalRos1Parser.g:7610:1: ( ( rule__ActionServer__ActionAssignment_5 ) ) + // InternalRos1Parser.g:7611:2: ( rule__ActionServer__ActionAssignment_5 ) + { + before(grammarAccess.getActionServerAccess().getActionAssignment_5()); + // InternalRos1Parser.g:7612:2: ( rule__ActionServer__ActionAssignment_5 ) + // InternalRos1Parser.g:7612:3: rule__ActionServer__ActionAssignment_5 + { + pushFollow(FOLLOW_2); + rule__ActionServer__ActionAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getActionServerAccess().getActionAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__5__Impl" + + + // $ANTLR start "rule__ActionServer__Group__6" + // InternalRos1Parser.g:7620:1: rule__ActionServer__Group__6 : rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 ; + public final void rule__ActionServer__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7624:1: ( rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 ) + // InternalRos1Parser.g:7625:2: rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 + { + pushFollow(FOLLOW_37); + rule__ActionServer__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__6" + + + // $ANTLR start "rule__ActionServer__Group__6__Impl" + // InternalRos1Parser.g:7632:1: rule__ActionServer__Group__6__Impl : ( ( rule__ActionServer__Group_6__0 )? ) ; + public final void rule__ActionServer__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7636:1: ( ( ( rule__ActionServer__Group_6__0 )? ) ) + // InternalRos1Parser.g:7637:1: ( ( rule__ActionServer__Group_6__0 )? ) + { + // InternalRos1Parser.g:7637:1: ( ( rule__ActionServer__Group_6__0 )? ) + // InternalRos1Parser.g:7638:2: ( rule__ActionServer__Group_6__0 )? + { + before(grammarAccess.getActionServerAccess().getGroup_6()); + // InternalRos1Parser.g:7639:2: ( rule__ActionServer__Group_6__0 )? + int alt43=2; + int LA43_0 = input.LA(1); + + if ( (LA43_0==Ns) ) { + alt43=1; + } + switch (alt43) { + case 1 : + // InternalRos1Parser.g:7639:3: rule__ActionServer__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__ActionServer__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionServerAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__6__Impl" + + + // $ANTLR start "rule__ActionServer__Group__7" + // InternalRos1Parser.g:7647:1: rule__ActionServer__Group__7 : rule__ActionServer__Group__7__Impl ; + public final void rule__ActionServer__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7651:1: ( rule__ActionServer__Group__7__Impl ) + // InternalRos1Parser.g:7652:2: rule__ActionServer__Group__7__Impl + { + pushFollow(FOLLOW_2); + rule__ActionServer__Group__7__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__7" + + + // $ANTLR start "rule__ActionServer__Group__7__Impl" + // InternalRos1Parser.g:7658:1: rule__ActionServer__Group__7__Impl : ( RULE_END ) ; + public final void rule__ActionServer__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7662:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:7663:1: ( RULE_END ) + { + // InternalRos1Parser.g:7663:1: ( RULE_END ) + // InternalRos1Parser.g:7664:2: RULE_END + { + before(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__7__Impl" + + + // $ANTLR start "rule__ActionServer__Group_6__0" + // InternalRos1Parser.g:7674:1: rule__ActionServer__Group_6__0 : rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 ; + public final void rule__ActionServer__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7678:1: ( rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 ) + // InternalRos1Parser.g:7679:2: rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 + { + pushFollow(FOLLOW_38); + rule__ActionServer__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_6__0" + + + // $ANTLR start "rule__ActionServer__Group_6__0__Impl" + // InternalRos1Parser.g:7686:1: rule__ActionServer__Group_6__0__Impl : ( Ns ) ; + public final void rule__ActionServer__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7690:1: ( ( Ns ) ) + // InternalRos1Parser.g:7691:1: ( Ns ) + { + // InternalRos1Parser.g:7691:1: ( Ns ) + // InternalRos1Parser.g:7692:2: Ns + { + before(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_6__0__Impl" + + + // $ANTLR start "rule__ActionServer__Group_6__1" + // InternalRos1Parser.g:7701:1: rule__ActionServer__Group_6__1 : rule__ActionServer__Group_6__1__Impl ; + public final void rule__ActionServer__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7705:1: ( rule__ActionServer__Group_6__1__Impl ) + // InternalRos1Parser.g:7706:2: rule__ActionServer__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__ActionServer__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_6__1" + + + // $ANTLR start "rule__ActionServer__Group_6__1__Impl" + // InternalRos1Parser.g:7712:1: rule__ActionServer__Group_6__1__Impl : ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) ; + public final void rule__ActionServer__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7716:1: ( ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) ) + // InternalRos1Parser.g:7717:1: ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) + { + // InternalRos1Parser.g:7717:1: ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) + // InternalRos1Parser.g:7718:2: ( rule__ActionServer__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); + // InternalRos1Parser.g:7719:2: ( rule__ActionServer__NamespaceAssignment_6_1 ) + // InternalRos1Parser.g:7719:3: rule__ActionServer__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__ActionServer__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_6__1__Impl" + + + // $ANTLR start "rule__ActionClient__Group__0" + // InternalRos1Parser.g:7728:1: rule__ActionClient__Group__0 : rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 ; + public final void rule__ActionClient__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7732:1: ( rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 ) + // InternalRos1Parser.g:7733:2: rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 + { + pushFollow(FOLLOW_7); + rule__ActionClient__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__0" + + + // $ANTLR start "rule__ActionClient__Group__0__Impl" + // InternalRos1Parser.g:7740:1: rule__ActionClient__Group__0__Impl : ( () ) ; + public final void rule__ActionClient__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7744:1: ( ( () ) ) + // InternalRos1Parser.g:7745:1: ( () ) + { + // InternalRos1Parser.g:7745:1: ( () ) + // InternalRos1Parser.g:7746:2: () + { + before(grammarAccess.getActionClientAccess().getActionClientAction_0()); + // InternalRos1Parser.g:7747:2: () + // InternalRos1Parser.g:7747:3: + { + } + + after(grammarAccess.getActionClientAccess().getActionClientAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__0__Impl" + + + // $ANTLR start "rule__ActionClient__Group__1" + // InternalRos1Parser.g:7755:1: rule__ActionClient__Group__1 : rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 ; + public final void rule__ActionClient__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7759:1: ( rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 ) + // InternalRos1Parser.g:7760:2: rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 + { + pushFollow(FOLLOW_4); + rule__ActionClient__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__1" + + + // $ANTLR start "rule__ActionClient__Group__1__Impl" + // InternalRos1Parser.g:7767:1: rule__ActionClient__Group__1__Impl : ( ( rule__ActionClient__NameAssignment_1 ) ) ; + public final void rule__ActionClient__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7771:1: ( ( ( rule__ActionClient__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:7772:1: ( ( rule__ActionClient__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:7772:1: ( ( rule__ActionClient__NameAssignment_1 ) ) + // InternalRos1Parser.g:7773:2: ( rule__ActionClient__NameAssignment_1 ) + { + before(grammarAccess.getActionClientAccess().getNameAssignment_1()); + // InternalRos1Parser.g:7774:2: ( rule__ActionClient__NameAssignment_1 ) + // InternalRos1Parser.g:7774:3: rule__ActionClient__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ActionClient__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionClientAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__1__Impl" + + + // $ANTLR start "rule__ActionClient__Group__2" + // InternalRos1Parser.g:7782:1: rule__ActionClient__Group__2 : rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 ; + public final void rule__ActionClient__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7786:1: ( rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 ) + // InternalRos1Parser.g:7787:2: rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 + { + pushFollow(FOLLOW_5); + rule__ActionClient__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__2" + + + // $ANTLR start "rule__ActionClient__Group__2__Impl" + // InternalRos1Parser.g:7794:1: rule__ActionClient__Group__2__Impl : ( Colon ) ; + public final void rule__ActionClient__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7798:1: ( ( Colon ) ) + // InternalRos1Parser.g:7799:1: ( Colon ) + { + // InternalRos1Parser.g:7799:1: ( Colon ) + // InternalRos1Parser.g:7800:2: Colon + { + before(grammarAccess.getActionClientAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__2__Impl" + + + // $ANTLR start "rule__ActionClient__Group__3" + // InternalRos1Parser.g:7809:1: rule__ActionClient__Group__3 : rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 ; + public final void rule__ActionClient__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7813:1: ( rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 ) + // InternalRos1Parser.g:7814:2: rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 + { + pushFollow(FOLLOW_36); + rule__ActionClient__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__3" + + + // $ANTLR start "rule__ActionClient__Group__3__Impl" + // InternalRos1Parser.g:7821:1: rule__ActionClient__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionClient__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7825:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:7826:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:7826:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:7827:2: RULE_BEGIN + { + before(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__3__Impl" + + + // $ANTLR start "rule__ActionClient__Group__4" + // InternalRos1Parser.g:7836:1: rule__ActionClient__Group__4 : rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 ; + public final void rule__ActionClient__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7840:1: ( rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 ) + // InternalRos1Parser.g:7841:2: rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 + { + pushFollow(FOLLOW_7); + rule__ActionClient__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__4" + + + // $ANTLR start "rule__ActionClient__Group__4__Impl" + // InternalRos1Parser.g:7848:1: rule__ActionClient__Group__4__Impl : ( Type_1 ) ; + public final void rule__ActionClient__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7852:1: ( ( Type_1 ) ) + // InternalRos1Parser.g:7853:1: ( Type_1 ) + { + // InternalRos1Parser.g:7853:1: ( Type_1 ) + // InternalRos1Parser.g:7854:2: Type_1 + { + before(grammarAccess.getActionClientAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getTypeKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__4__Impl" + + + // $ANTLR start "rule__ActionClient__Group__5" + // InternalRos1Parser.g:7863:1: rule__ActionClient__Group__5 : rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 ; + public final void rule__ActionClient__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7867:1: ( rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 ) + // InternalRos1Parser.g:7868:2: rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 + { + pushFollow(FOLLOW_37); + rule__ActionClient__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__5" + + + // $ANTLR start "rule__ActionClient__Group__5__Impl" + // InternalRos1Parser.g:7875:1: rule__ActionClient__Group__5__Impl : ( ( rule__ActionClient__ActionAssignment_5 ) ) ; + public final void rule__ActionClient__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7879:1: ( ( ( rule__ActionClient__ActionAssignment_5 ) ) ) + // InternalRos1Parser.g:7880:1: ( ( rule__ActionClient__ActionAssignment_5 ) ) + { + // InternalRos1Parser.g:7880:1: ( ( rule__ActionClient__ActionAssignment_5 ) ) + // InternalRos1Parser.g:7881:2: ( rule__ActionClient__ActionAssignment_5 ) + { + before(grammarAccess.getActionClientAccess().getActionAssignment_5()); + // InternalRos1Parser.g:7882:2: ( rule__ActionClient__ActionAssignment_5 ) + // InternalRos1Parser.g:7882:3: rule__ActionClient__ActionAssignment_5 + { + pushFollow(FOLLOW_2); + rule__ActionClient__ActionAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getActionClientAccess().getActionAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__5__Impl" + + + // $ANTLR start "rule__ActionClient__Group__6" + // InternalRos1Parser.g:7890:1: rule__ActionClient__Group__6 : rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 ; + public final void rule__ActionClient__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7894:1: ( rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 ) + // InternalRos1Parser.g:7895:2: rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 + { + pushFollow(FOLLOW_37); + rule__ActionClient__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__6" + + + // $ANTLR start "rule__ActionClient__Group__6__Impl" + // InternalRos1Parser.g:7902:1: rule__ActionClient__Group__6__Impl : ( ( rule__ActionClient__Group_6__0 )? ) ; + public final void rule__ActionClient__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7906:1: ( ( ( rule__ActionClient__Group_6__0 )? ) ) + // InternalRos1Parser.g:7907:1: ( ( rule__ActionClient__Group_6__0 )? ) + { + // InternalRos1Parser.g:7907:1: ( ( rule__ActionClient__Group_6__0 )? ) + // InternalRos1Parser.g:7908:2: ( rule__ActionClient__Group_6__0 )? + { + before(grammarAccess.getActionClientAccess().getGroup_6()); + // InternalRos1Parser.g:7909:2: ( rule__ActionClient__Group_6__0 )? + int alt44=2; + int LA44_0 = input.LA(1); + + if ( (LA44_0==Ns) ) { + alt44=1; + } + switch (alt44) { + case 1 : + // InternalRos1Parser.g:7909:3: rule__ActionClient__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__ActionClient__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionClientAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__6__Impl" + + + // $ANTLR start "rule__ActionClient__Group__7" + // InternalRos1Parser.g:7917:1: rule__ActionClient__Group__7 : rule__ActionClient__Group__7__Impl ; + public final void rule__ActionClient__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7921:1: ( rule__ActionClient__Group__7__Impl ) + // InternalRos1Parser.g:7922:2: rule__ActionClient__Group__7__Impl + { + pushFollow(FOLLOW_2); + rule__ActionClient__Group__7__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__7" + + + // $ANTLR start "rule__ActionClient__Group__7__Impl" + // InternalRos1Parser.g:7928:1: rule__ActionClient__Group__7__Impl : ( RULE_END ) ; + public final void rule__ActionClient__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7932:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:7933:1: ( RULE_END ) + { + // InternalRos1Parser.g:7933:1: ( RULE_END ) + // InternalRos1Parser.g:7934:2: RULE_END + { + before(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__7__Impl" + + + // $ANTLR start "rule__ActionClient__Group_6__0" + // InternalRos1Parser.g:7944:1: rule__ActionClient__Group_6__0 : rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 ; + public final void rule__ActionClient__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7948:1: ( rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 ) + // InternalRos1Parser.g:7949:2: rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 + { + pushFollow(FOLLOW_38); + rule__ActionClient__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_6__0" + + + // $ANTLR start "rule__ActionClient__Group_6__0__Impl" + // InternalRos1Parser.g:7956:1: rule__ActionClient__Group_6__0__Impl : ( Ns ) ; + public final void rule__ActionClient__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7960:1: ( ( Ns ) ) + // InternalRos1Parser.g:7961:1: ( Ns ) + { + // InternalRos1Parser.g:7961:1: ( Ns ) + // InternalRos1Parser.g:7962:2: Ns + { + before(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_6__0__Impl" + + + // $ANTLR start "rule__ActionClient__Group_6__1" + // InternalRos1Parser.g:7971:1: rule__ActionClient__Group_6__1 : rule__ActionClient__Group_6__1__Impl ; + public final void rule__ActionClient__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7975:1: ( rule__ActionClient__Group_6__1__Impl ) + // InternalRos1Parser.g:7976:2: rule__ActionClient__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__ActionClient__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_6__1" + + + // $ANTLR start "rule__ActionClient__Group_6__1__Impl" + // InternalRos1Parser.g:7982:1: rule__ActionClient__Group_6__1__Impl : ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) ; + public final void rule__ActionClient__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:7986:1: ( ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) ) + // InternalRos1Parser.g:7987:1: ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) + { + // InternalRos1Parser.g:7987:1: ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) + // InternalRos1Parser.g:7988:2: ( rule__ActionClient__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); + // InternalRos1Parser.g:7989:2: ( rule__ActionClient__NamespaceAssignment_6_1 ) + // InternalRos1Parser.g:7989:3: rule__ActionClient__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__ActionClient__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_6__1__Impl" + + + // $ANTLR start "rule__ExternalDependency__Group__0" + // InternalRos1Parser.g:7998: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:8002:1: ( rule__ExternalDependency__Group__0__Impl rule__ExternalDependency__Group__1 ) + // InternalRos1Parser.g:8003: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:8010:1: rule__ExternalDependency__Group__0__Impl : ( () ) ; + public final void rule__ExternalDependency__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8014:1: ( ( () ) ) + // InternalRos1Parser.g:8015:1: ( () ) + { + // InternalRos1Parser.g:8015:1: ( () ) + // InternalRos1Parser.g:8016:2: () + { + before(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); + // InternalRos1Parser.g:8017:2: () + // InternalRos1Parser.g:8017: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:8025: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:8029:1: ( rule__ExternalDependency__Group__1__Impl rule__ExternalDependency__Group__2 ) + // InternalRos1Parser.g:8030: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:8037:1: rule__ExternalDependency__Group__1__Impl : ( ExternalDependency ) ; + public final void rule__ExternalDependency__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8041:1: ( ( ExternalDependency ) ) + // InternalRos1Parser.g:8042:1: ( ExternalDependency ) + { + // InternalRos1Parser.g:8042:1: ( ExternalDependency ) + // InternalRos1Parser.g:8043: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:8052: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:8056:1: ( rule__ExternalDependency__Group__2__Impl ) + // InternalRos1Parser.g:8057: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:8063: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:8067:1: ( ( ( rule__ExternalDependency__NameAssignment_2 ) ) ) + // InternalRos1Parser.g:8068:1: ( ( rule__ExternalDependency__NameAssignment_2 ) ) + { + // InternalRos1Parser.g:8068:1: ( ( rule__ExternalDependency__NameAssignment_2 ) ) + // InternalRos1Parser.g:8069:2: ( rule__ExternalDependency__NameAssignment_2 ) + { + before(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); + // InternalRos1Parser.g:8070:2: ( rule__ExternalDependency__NameAssignment_2 ) + // InternalRos1Parser.g:8070: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__GlobalNamespace__Group__0" + // InternalRos1Parser.g:8079:1: rule__GlobalNamespace__Group__0 : rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 ; + public final void rule__GlobalNamespace__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8083:1: ( rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 ) + // InternalRos1Parser.g:8084:2: rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 + { + pushFollow(FOLLOW_39); + rule__GlobalNamespace__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__0" + + + // $ANTLR start "rule__GlobalNamespace__Group__0__Impl" + // InternalRos1Parser.g:8091:1: rule__GlobalNamespace__Group__0__Impl : ( () ) ; + public final void rule__GlobalNamespace__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8095:1: ( ( () ) ) + // InternalRos1Parser.g:8096:1: ( () ) + { + // InternalRos1Parser.g:8096:1: ( () ) + // InternalRos1Parser.g:8097:2: () + { + before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); + // InternalRos1Parser.g:8098:2: () + // InternalRos1Parser.g:8098:3: + { + } + + after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__0__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group__1" + // InternalRos1Parser.g:8106:1: rule__GlobalNamespace__Group__1 : rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 ; + public final void rule__GlobalNamespace__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8110:1: ( rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 ) + // InternalRos1Parser.g:8111:2: rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 + { + pushFollow(FOLLOW_10); + rule__GlobalNamespace__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__1" + + + // $ANTLR start "rule__GlobalNamespace__Group__1__Impl" + // InternalRos1Parser.g:8118:1: rule__GlobalNamespace__Group__1__Impl : ( GlobalNamespace ) ; + public final void rule__GlobalNamespace__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8122:1: ( ( GlobalNamespace ) ) + // InternalRos1Parser.g:8123:1: ( GlobalNamespace ) + { + // InternalRos1Parser.g:8123:1: ( GlobalNamespace ) + // InternalRos1Parser.g:8124:2: GlobalNamespace + { + before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); + match(input,GlobalNamespace,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__1__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group__2" + // InternalRos1Parser.g:8133:1: rule__GlobalNamespace__Group__2 : rule__GlobalNamespace__Group__2__Impl ; + public final void rule__GlobalNamespace__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8137:1: ( rule__GlobalNamespace__Group__2__Impl ) + // InternalRos1Parser.g:8138:2: rule__GlobalNamespace__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__2" + + + // $ANTLR start "rule__GlobalNamespace__Group__2__Impl" + // InternalRos1Parser.g:8144:1: rule__GlobalNamespace__Group__2__Impl : ( ( rule__GlobalNamespace__Group_2__0 )? ) ; + public final void rule__GlobalNamespace__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8148:1: ( ( ( rule__GlobalNamespace__Group_2__0 )? ) ) + // InternalRos1Parser.g:8149:1: ( ( rule__GlobalNamespace__Group_2__0 )? ) + { + // InternalRos1Parser.g:8149:1: ( ( rule__GlobalNamespace__Group_2__0 )? ) + // InternalRos1Parser.g:8150:2: ( rule__GlobalNamespace__Group_2__0 )? + { + before(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); + // InternalRos1Parser.g:8151:2: ( rule__GlobalNamespace__Group_2__0 )? + int alt45=2; + int LA45_0 = input.LA(1); + + if ( (LA45_0==LeftSquareBracket) ) { + alt45=1; + } + switch (alt45) { + case 1 : + // InternalRos1Parser.g:8151:3: rule__GlobalNamespace__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__2__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__0" + // InternalRos1Parser.g:8160:1: rule__GlobalNamespace__Group_2__0 : rule__GlobalNamespace__Group_2__0__Impl rule__GlobalNamespace__Group_2__1 ; + public final void rule__GlobalNamespace__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8164:1: ( rule__GlobalNamespace__Group_2__0__Impl rule__GlobalNamespace__Group_2__1 ) + // InternalRos1Parser.g:8165:2: rule__GlobalNamespace__Group_2__0__Impl rule__GlobalNamespace__Group_2__1 + { + pushFollow(FOLLOW_40); + rule__GlobalNamespace__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__0" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__0__Impl" + // InternalRos1Parser.g:8172:1: rule__GlobalNamespace__Group_2__0__Impl : ( LeftSquareBracket ) ; + public final void rule__GlobalNamespace__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8176:1: ( ( LeftSquareBracket ) ) + // InternalRos1Parser.g:8177:1: ( LeftSquareBracket ) + { + // InternalRos1Parser.g:8177:1: ( LeftSquareBracket ) + // InternalRos1Parser.g:8178:2: LeftSquareBracket + { + before(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__0__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__1" + // InternalRos1Parser.g:8187:1: rule__GlobalNamespace__Group_2__1 : rule__GlobalNamespace__Group_2__1__Impl rule__GlobalNamespace__Group_2__2 ; + public final void rule__GlobalNamespace__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8191:1: ( rule__GlobalNamespace__Group_2__1__Impl rule__GlobalNamespace__Group_2__2 ) + // InternalRos1Parser.g:8192:2: rule__GlobalNamespace__Group_2__1__Impl rule__GlobalNamespace__Group_2__2 + { + pushFollow(FOLLOW_12); + rule__GlobalNamespace__Group_2__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__1" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__1__Impl" + // InternalRos1Parser.g:8199:1: rule__GlobalNamespace__Group_2__1__Impl : ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) ; + public final void rule__GlobalNamespace__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8203:1: ( ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) ) + // InternalRos1Parser.g:8204:1: ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) + { + // InternalRos1Parser.g:8204:1: ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) + // InternalRos1Parser.g:8205:2: ( rule__GlobalNamespace__PartsAssignment_2_1 ) + { + before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); + // InternalRos1Parser.g:8206:2: ( rule__GlobalNamespace__PartsAssignment_2_1 ) + // InternalRos1Parser.g:8206:3: rule__GlobalNamespace__PartsAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__PartsAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__1__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__2" + // InternalRos1Parser.g:8214:1: rule__GlobalNamespace__Group_2__2 : rule__GlobalNamespace__Group_2__2__Impl rule__GlobalNamespace__Group_2__3 ; + public final void rule__GlobalNamespace__Group_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8218:1: ( rule__GlobalNamespace__Group_2__2__Impl rule__GlobalNamespace__Group_2__3 ) + // InternalRos1Parser.g:8219:2: rule__GlobalNamespace__Group_2__2__Impl rule__GlobalNamespace__Group_2__3 + { + pushFollow(FOLLOW_12); + rule__GlobalNamespace__Group_2__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__2" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__2__Impl" + // InternalRos1Parser.g:8226:1: rule__GlobalNamespace__Group_2__2__Impl : ( ( rule__GlobalNamespace__Group_2_2__0 )* ) ; + public final void rule__GlobalNamespace__Group_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8230:1: ( ( ( rule__GlobalNamespace__Group_2_2__0 )* ) ) + // InternalRos1Parser.g:8231:1: ( ( rule__GlobalNamespace__Group_2_2__0 )* ) + { + // InternalRos1Parser.g:8231:1: ( ( rule__GlobalNamespace__Group_2_2__0 )* ) + // InternalRos1Parser.g:8232:2: ( rule__GlobalNamespace__Group_2_2__0 )* + { + before(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); + // InternalRos1Parser.g:8233:2: ( rule__GlobalNamespace__Group_2_2__0 )* + loop46: + do { + int alt46=2; + int LA46_0 = input.LA(1); + + if ( (LA46_0==Comma) ) { + alt46=1; + } + + + switch (alt46) { + case 1 : + // InternalRos1Parser.g:8233:3: rule__GlobalNamespace__Group_2_2__0 + { + pushFollow(FOLLOW_13); + rule__GlobalNamespace__Group_2_2__0(); + + state._fsp--; + + + } + break; + + default : + break loop46; + } + } while (true); + + after(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__2__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__3" + // InternalRos1Parser.g:8241:1: rule__GlobalNamespace__Group_2__3 : rule__GlobalNamespace__Group_2__3__Impl ; + public final void rule__GlobalNamespace__Group_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8245:1: ( rule__GlobalNamespace__Group_2__3__Impl ) + // InternalRos1Parser.g:8246:2: rule__GlobalNamespace__Group_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__3" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__3__Impl" + // InternalRos1Parser.g:8252:1: rule__GlobalNamespace__Group_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__GlobalNamespace__Group_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8256:1: ( ( RightSquareBracket ) ) + // InternalRos1Parser.g:8257:1: ( RightSquareBracket ) + { + // InternalRos1Parser.g:8257:1: ( RightSquareBracket ) + // InternalRos1Parser.g:8258:2: RightSquareBracket + { + before(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__3__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2_2__0" + // InternalRos1Parser.g:8268:1: rule__GlobalNamespace__Group_2_2__0 : rule__GlobalNamespace__Group_2_2__0__Impl rule__GlobalNamespace__Group_2_2__1 ; + public final void rule__GlobalNamespace__Group_2_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8272:1: ( rule__GlobalNamespace__Group_2_2__0__Impl rule__GlobalNamespace__Group_2_2__1 ) + // InternalRos1Parser.g:8273:2: rule__GlobalNamespace__Group_2_2__0__Impl rule__GlobalNamespace__Group_2_2__1 + { + pushFollow(FOLLOW_40); + rule__GlobalNamespace__Group_2_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2_2__0" + + + // $ANTLR start "rule__GlobalNamespace__Group_2_2__0__Impl" + // InternalRos1Parser.g:8280:1: rule__GlobalNamespace__Group_2_2__0__Impl : ( Comma ) ; + public final void rule__GlobalNamespace__Group_2_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8284:1: ( ( Comma ) ) + // InternalRos1Parser.g:8285:1: ( Comma ) + { + // InternalRos1Parser.g:8285:1: ( Comma ) + // InternalRos1Parser.g:8286:2: Comma + { + before(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2_2__0__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2_2__1" + // InternalRos1Parser.g:8295:1: rule__GlobalNamespace__Group_2_2__1 : rule__GlobalNamespace__Group_2_2__1__Impl ; + public final void rule__GlobalNamespace__Group_2_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8299:1: ( rule__GlobalNamespace__Group_2_2__1__Impl ) + // InternalRos1Parser.g:8300:2: rule__GlobalNamespace__Group_2_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2_2__1" + + + // $ANTLR start "rule__GlobalNamespace__Group_2_2__1__Impl" + // InternalRos1Parser.g:8306:1: rule__GlobalNamespace__Group_2_2__1__Impl : ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) ; + public final void rule__GlobalNamespace__Group_2_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8310:1: ( ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) ) + // InternalRos1Parser.g:8311:1: ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) + { + // InternalRos1Parser.g:8311:1: ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) + // InternalRos1Parser.g:8312:2: ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) + { + before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); + // InternalRos1Parser.g:8313:2: ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) + // InternalRos1Parser.g:8313:3: rule__GlobalNamespace__PartsAssignment_2_2_1 + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__PartsAssignment_2_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2_2__1__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__0" + // InternalRos1Parser.g:8322:1: rule__RelativeNamespace_Impl__Group__0 : rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 ; + public final void rule__RelativeNamespace_Impl__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8326:1: ( rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 ) + // InternalRos1Parser.g:8327:2: rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 + { + pushFollow(FOLLOW_41); + rule__RelativeNamespace_Impl__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__0" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__0__Impl" + // InternalRos1Parser.g:8334:1: rule__RelativeNamespace_Impl__Group__0__Impl : ( () ) ; + public final void rule__RelativeNamespace_Impl__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8338:1: ( ( () ) ) + // InternalRos1Parser.g:8339:1: ( () ) + { + // InternalRos1Parser.g:8339:1: ( () ) + // InternalRos1Parser.g:8340:2: () + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); + // InternalRos1Parser.g:8341:2: () + // InternalRos1Parser.g:8341:3: + { + } + + after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__0__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__1" + // InternalRos1Parser.g:8349:1: rule__RelativeNamespace_Impl__Group__1 : rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 ; + public final void rule__RelativeNamespace_Impl__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8353:1: ( rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 ) + // InternalRos1Parser.g:8354:2: rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 + { + pushFollow(FOLLOW_10); + rule__RelativeNamespace_Impl__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__1" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__1__Impl" + // InternalRos1Parser.g:8361:1: rule__RelativeNamespace_Impl__Group__1__Impl : ( RelativeNamespace ) ; + public final void rule__RelativeNamespace_Impl__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8365:1: ( ( RelativeNamespace ) ) + // InternalRos1Parser.g:8366:1: ( RelativeNamespace ) + { + // InternalRos1Parser.g:8366:1: ( RelativeNamespace ) + // InternalRos1Parser.g:8367:2: RelativeNamespace + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); + match(input,RelativeNamespace,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__1__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__2" + // InternalRos1Parser.g:8376:1: rule__RelativeNamespace_Impl__Group__2 : rule__RelativeNamespace_Impl__Group__2__Impl ; + public final void rule__RelativeNamespace_Impl__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8380:1: ( rule__RelativeNamespace_Impl__Group__2__Impl ) + // InternalRos1Parser.g:8381:2: rule__RelativeNamespace_Impl__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__2" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__2__Impl" + // InternalRos1Parser.g:8387:1: rule__RelativeNamespace_Impl__Group__2__Impl : ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) ; + public final void rule__RelativeNamespace_Impl__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8391:1: ( ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) ) + // InternalRos1Parser.g:8392:1: ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) + { + // InternalRos1Parser.g:8392:1: ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) + // InternalRos1Parser.g:8393:2: ( rule__RelativeNamespace_Impl__Group_2__0 )? + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); + // InternalRos1Parser.g:8394:2: ( rule__RelativeNamespace_Impl__Group_2__0 )? + int alt47=2; + int LA47_0 = input.LA(1); + + if ( (LA47_0==LeftSquareBracket) ) { + alt47=1; + } + switch (alt47) { + case 1 : + // InternalRos1Parser.g:8394:3: rule__RelativeNamespace_Impl__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__2__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__0" + // InternalRos1Parser.g:8403:1: rule__RelativeNamespace_Impl__Group_2__0 : rule__RelativeNamespace_Impl__Group_2__0__Impl rule__RelativeNamespace_Impl__Group_2__1 ; + public final void rule__RelativeNamespace_Impl__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8407:1: ( rule__RelativeNamespace_Impl__Group_2__0__Impl rule__RelativeNamespace_Impl__Group_2__1 ) + // InternalRos1Parser.g:8408:2: rule__RelativeNamespace_Impl__Group_2__0__Impl rule__RelativeNamespace_Impl__Group_2__1 + { + pushFollow(FOLLOW_40); + rule__RelativeNamespace_Impl__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__0" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__0__Impl" + // InternalRos1Parser.g:8415:1: rule__RelativeNamespace_Impl__Group_2__0__Impl : ( LeftSquareBracket ) ; + public final void rule__RelativeNamespace_Impl__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8419:1: ( ( LeftSquareBracket ) ) + // InternalRos1Parser.g:8420:1: ( LeftSquareBracket ) + { + // InternalRos1Parser.g:8420:1: ( LeftSquareBracket ) + // InternalRos1Parser.g:8421:2: LeftSquareBracket + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__0__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__1" + // InternalRos1Parser.g:8430:1: rule__RelativeNamespace_Impl__Group_2__1 : rule__RelativeNamespace_Impl__Group_2__1__Impl rule__RelativeNamespace_Impl__Group_2__2 ; + public final void rule__RelativeNamespace_Impl__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8434:1: ( rule__RelativeNamespace_Impl__Group_2__1__Impl rule__RelativeNamespace_Impl__Group_2__2 ) + // InternalRos1Parser.g:8435:2: rule__RelativeNamespace_Impl__Group_2__1__Impl rule__RelativeNamespace_Impl__Group_2__2 + { + pushFollow(FOLLOW_12); + rule__RelativeNamespace_Impl__Group_2__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__1" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__1__Impl" + // InternalRos1Parser.g:8442:1: rule__RelativeNamespace_Impl__Group_2__1__Impl : ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) ; + public final void rule__RelativeNamespace_Impl__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8446:1: ( ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) ) + // InternalRos1Parser.g:8447:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) + { + // InternalRos1Parser.g:8447:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) + // InternalRos1Parser.g:8448:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); + // InternalRos1Parser.g:8449:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) + // InternalRos1Parser.g:8449:3: rule__RelativeNamespace_Impl__PartsAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__PartsAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__1__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__2" + // InternalRos1Parser.g:8457:1: rule__RelativeNamespace_Impl__Group_2__2 : rule__RelativeNamespace_Impl__Group_2__2__Impl rule__RelativeNamespace_Impl__Group_2__3 ; + public final void rule__RelativeNamespace_Impl__Group_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8461:1: ( rule__RelativeNamespace_Impl__Group_2__2__Impl rule__RelativeNamespace_Impl__Group_2__3 ) + // InternalRos1Parser.g:8462:2: rule__RelativeNamespace_Impl__Group_2__2__Impl rule__RelativeNamespace_Impl__Group_2__3 + { + pushFollow(FOLLOW_12); + rule__RelativeNamespace_Impl__Group_2__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__2" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__2__Impl" + // InternalRos1Parser.g:8469:1: rule__RelativeNamespace_Impl__Group_2__2__Impl : ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) ; + public final void rule__RelativeNamespace_Impl__Group_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8473:1: ( ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) ) + // InternalRos1Parser.g:8474:1: ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) + { + // InternalRos1Parser.g:8474:1: ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) + // InternalRos1Parser.g:8475:2: ( rule__RelativeNamespace_Impl__Group_2_2__0 )* + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); + // InternalRos1Parser.g:8476:2: ( rule__RelativeNamespace_Impl__Group_2_2__0 )* + loop48: + do { + int alt48=2; + int LA48_0 = input.LA(1); + + if ( (LA48_0==Comma) ) { + alt48=1; + } + + + switch (alt48) { + case 1 : + // InternalRos1Parser.g:8476:3: rule__RelativeNamespace_Impl__Group_2_2__0 + { + pushFollow(FOLLOW_13); + rule__RelativeNamespace_Impl__Group_2_2__0(); + + state._fsp--; + + + } + break; + + default : + break loop48; + } + } while (true); + + after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__2__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__3" + // InternalRos1Parser.g:8484:1: rule__RelativeNamespace_Impl__Group_2__3 : rule__RelativeNamespace_Impl__Group_2__3__Impl ; + public final void rule__RelativeNamespace_Impl__Group_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8488:1: ( rule__RelativeNamespace_Impl__Group_2__3__Impl ) + // InternalRos1Parser.g:8489:2: rule__RelativeNamespace_Impl__Group_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__3" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__3__Impl" + // InternalRos1Parser.g:8495:1: rule__RelativeNamespace_Impl__Group_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__RelativeNamespace_Impl__Group_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8499:1: ( ( RightSquareBracket ) ) + // InternalRos1Parser.g:8500:1: ( RightSquareBracket ) + { + // InternalRos1Parser.g:8500:1: ( RightSquareBracket ) + // InternalRos1Parser.g:8501:2: RightSquareBracket + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__3__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__0" + // InternalRos1Parser.g:8511:1: rule__RelativeNamespace_Impl__Group_2_2__0 : rule__RelativeNamespace_Impl__Group_2_2__0__Impl rule__RelativeNamespace_Impl__Group_2_2__1 ; + public final void rule__RelativeNamespace_Impl__Group_2_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8515:1: ( rule__RelativeNamespace_Impl__Group_2_2__0__Impl rule__RelativeNamespace_Impl__Group_2_2__1 ) + // InternalRos1Parser.g:8516:2: rule__RelativeNamespace_Impl__Group_2_2__0__Impl rule__RelativeNamespace_Impl__Group_2_2__1 + { + pushFollow(FOLLOW_40); + rule__RelativeNamespace_Impl__Group_2_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__0" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__0__Impl" + // InternalRos1Parser.g:8523:1: rule__RelativeNamespace_Impl__Group_2_2__0__Impl : ( Comma ) ; + public final void rule__RelativeNamespace_Impl__Group_2_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8527:1: ( ( Comma ) ) + // InternalRos1Parser.g:8528:1: ( Comma ) + { + // InternalRos1Parser.g:8528:1: ( Comma ) + // InternalRos1Parser.g:8529:2: Comma + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__0__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__1" + // InternalRos1Parser.g:8538:1: rule__RelativeNamespace_Impl__Group_2_2__1 : rule__RelativeNamespace_Impl__Group_2_2__1__Impl ; + public final void rule__RelativeNamespace_Impl__Group_2_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8542:1: ( rule__RelativeNamespace_Impl__Group_2_2__1__Impl ) + // InternalRos1Parser.g:8543:2: rule__RelativeNamespace_Impl__Group_2_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__1" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__1__Impl" + // InternalRos1Parser.g:8549:1: rule__RelativeNamespace_Impl__Group_2_2__1__Impl : ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) ; + public final void rule__RelativeNamespace_Impl__Group_2_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8553:1: ( ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) ) + // InternalRos1Parser.g:8554:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) + { + // InternalRos1Parser.g:8554:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) + // InternalRos1Parser.g:8555:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); + // InternalRos1Parser.g:8556:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) + // InternalRos1Parser.g:8556:3: rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__PartsAssignment_2_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__1__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group__0" + // InternalRos1Parser.g:8565:1: rule__PrivateNamespace__Group__0 : rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 ; + public final void rule__PrivateNamespace__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8569:1: ( rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 ) + // InternalRos1Parser.g:8570:2: rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 + { + pushFollow(FOLLOW_38); + rule__PrivateNamespace__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__0" + + + // $ANTLR start "rule__PrivateNamespace__Group__0__Impl" + // InternalRos1Parser.g:8577:1: rule__PrivateNamespace__Group__0__Impl : ( () ) ; + public final void rule__PrivateNamespace__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8581:1: ( ( () ) ) + // InternalRos1Parser.g:8582:1: ( () ) + { + // InternalRos1Parser.g:8582:1: ( () ) + // InternalRos1Parser.g:8583:2: () + { + before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); + // InternalRos1Parser.g:8584:2: () + // InternalRos1Parser.g:8584:3: + { + } + + after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__0__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group__1" + // InternalRos1Parser.g:8592:1: rule__PrivateNamespace__Group__1 : rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 ; + public final void rule__PrivateNamespace__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8596:1: ( rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 ) + // InternalRos1Parser.g:8597:2: rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 + { + pushFollow(FOLLOW_10); + rule__PrivateNamespace__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__1" + + + // $ANTLR start "rule__PrivateNamespace__Group__1__Impl" + // InternalRos1Parser.g:8604:1: rule__PrivateNamespace__Group__1__Impl : ( PrivateNamespace ) ; + public final void rule__PrivateNamespace__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8608:1: ( ( PrivateNamespace ) ) + // InternalRos1Parser.g:8609:1: ( PrivateNamespace ) + { + // InternalRos1Parser.g:8609:1: ( PrivateNamespace ) + // InternalRos1Parser.g:8610:2: PrivateNamespace + { + before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); + match(input,PrivateNamespace,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__1__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group__2" + // InternalRos1Parser.g:8619:1: rule__PrivateNamespace__Group__2 : rule__PrivateNamespace__Group__2__Impl ; + public final void rule__PrivateNamespace__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8623:1: ( rule__PrivateNamespace__Group__2__Impl ) + // InternalRos1Parser.g:8624:2: rule__PrivateNamespace__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__2" + + + // $ANTLR start "rule__PrivateNamespace__Group__2__Impl" + // InternalRos1Parser.g:8630:1: rule__PrivateNamespace__Group__2__Impl : ( ( rule__PrivateNamespace__Group_2__0 )? ) ; + public final void rule__PrivateNamespace__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8634:1: ( ( ( rule__PrivateNamespace__Group_2__0 )? ) ) + // InternalRos1Parser.g:8635:1: ( ( rule__PrivateNamespace__Group_2__0 )? ) + { + // InternalRos1Parser.g:8635:1: ( ( rule__PrivateNamespace__Group_2__0 )? ) + // InternalRos1Parser.g:8636:2: ( rule__PrivateNamespace__Group_2__0 )? + { + before(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); + // InternalRos1Parser.g:8637:2: ( rule__PrivateNamespace__Group_2__0 )? + int alt49=2; + int LA49_0 = input.LA(1); + + if ( (LA49_0==LeftSquareBracket) ) { + alt49=1; + } + switch (alt49) { + case 1 : + // InternalRos1Parser.g:8637:3: rule__PrivateNamespace__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__2__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__0" + // InternalRos1Parser.g:8646:1: rule__PrivateNamespace__Group_2__0 : rule__PrivateNamespace__Group_2__0__Impl rule__PrivateNamespace__Group_2__1 ; + public final void rule__PrivateNamespace__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8650:1: ( rule__PrivateNamespace__Group_2__0__Impl rule__PrivateNamespace__Group_2__1 ) + // InternalRos1Parser.g:8651:2: rule__PrivateNamespace__Group_2__0__Impl rule__PrivateNamespace__Group_2__1 + { + pushFollow(FOLLOW_40); + rule__PrivateNamespace__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__0" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__0__Impl" + // InternalRos1Parser.g:8658:1: rule__PrivateNamespace__Group_2__0__Impl : ( LeftSquareBracket ) ; + public final void rule__PrivateNamespace__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8662:1: ( ( LeftSquareBracket ) ) + // InternalRos1Parser.g:8663:1: ( LeftSquareBracket ) + { + // InternalRos1Parser.g:8663:1: ( LeftSquareBracket ) + // InternalRos1Parser.g:8664:2: LeftSquareBracket + { + before(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__0__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__1" + // InternalRos1Parser.g:8673:1: rule__PrivateNamespace__Group_2__1 : rule__PrivateNamespace__Group_2__1__Impl rule__PrivateNamespace__Group_2__2 ; + public final void rule__PrivateNamespace__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8677:1: ( rule__PrivateNamespace__Group_2__1__Impl rule__PrivateNamespace__Group_2__2 ) + // InternalRos1Parser.g:8678:2: rule__PrivateNamespace__Group_2__1__Impl rule__PrivateNamespace__Group_2__2 + { + pushFollow(FOLLOW_12); + rule__PrivateNamespace__Group_2__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__1" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__1__Impl" + // InternalRos1Parser.g:8685:1: rule__PrivateNamespace__Group_2__1__Impl : ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) ; + public final void rule__PrivateNamespace__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8689:1: ( ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) ) + // InternalRos1Parser.g:8690:1: ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) + { + // InternalRos1Parser.g:8690:1: ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) + // InternalRos1Parser.g:8691:2: ( rule__PrivateNamespace__PartsAssignment_2_1 ) + { + before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); + // InternalRos1Parser.g:8692:2: ( rule__PrivateNamespace__PartsAssignment_2_1 ) + // InternalRos1Parser.g:8692:3: rule__PrivateNamespace__PartsAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__PartsAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__1__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__2" + // InternalRos1Parser.g:8700:1: rule__PrivateNamespace__Group_2__2 : rule__PrivateNamespace__Group_2__2__Impl rule__PrivateNamespace__Group_2__3 ; + public final void rule__PrivateNamespace__Group_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8704:1: ( rule__PrivateNamespace__Group_2__2__Impl rule__PrivateNamespace__Group_2__3 ) + // InternalRos1Parser.g:8705:2: rule__PrivateNamespace__Group_2__2__Impl rule__PrivateNamespace__Group_2__3 + { + pushFollow(FOLLOW_12); + rule__PrivateNamespace__Group_2__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__2" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__2__Impl" + // InternalRos1Parser.g:8712:1: rule__PrivateNamespace__Group_2__2__Impl : ( ( rule__PrivateNamespace__Group_2_2__0 )* ) ; + public final void rule__PrivateNamespace__Group_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8716:1: ( ( ( rule__PrivateNamespace__Group_2_2__0 )* ) ) + // InternalRos1Parser.g:8717:1: ( ( rule__PrivateNamespace__Group_2_2__0 )* ) + { + // InternalRos1Parser.g:8717:1: ( ( rule__PrivateNamespace__Group_2_2__0 )* ) + // InternalRos1Parser.g:8718:2: ( rule__PrivateNamespace__Group_2_2__0 )* + { + before(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); + // InternalRos1Parser.g:8719:2: ( rule__PrivateNamespace__Group_2_2__0 )* + loop50: + do { + int alt50=2; + int LA50_0 = input.LA(1); + + if ( (LA50_0==Comma) ) { + alt50=1; + } + + + switch (alt50) { + case 1 : + // InternalRos1Parser.g:8719:3: rule__PrivateNamespace__Group_2_2__0 + { + pushFollow(FOLLOW_13); + rule__PrivateNamespace__Group_2_2__0(); + + state._fsp--; + + + } + break; + + default : + break loop50; + } + } while (true); + + after(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__2__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__3" + // InternalRos1Parser.g:8727:1: rule__PrivateNamespace__Group_2__3 : rule__PrivateNamespace__Group_2__3__Impl ; + public final void rule__PrivateNamespace__Group_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8731:1: ( rule__PrivateNamespace__Group_2__3__Impl ) + // InternalRos1Parser.g:8732:2: rule__PrivateNamespace__Group_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__3" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__3__Impl" + // InternalRos1Parser.g:8738:1: rule__PrivateNamespace__Group_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__PrivateNamespace__Group_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8742:1: ( ( RightSquareBracket ) ) + // InternalRos1Parser.g:8743:1: ( RightSquareBracket ) + { + // InternalRos1Parser.g:8743:1: ( RightSquareBracket ) + // InternalRos1Parser.g:8744:2: RightSquareBracket + { + before(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__3__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2_2__0" + // InternalRos1Parser.g:8754:1: rule__PrivateNamespace__Group_2_2__0 : rule__PrivateNamespace__Group_2_2__0__Impl rule__PrivateNamespace__Group_2_2__1 ; + public final void rule__PrivateNamespace__Group_2_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8758:1: ( rule__PrivateNamespace__Group_2_2__0__Impl rule__PrivateNamespace__Group_2_2__1 ) + // InternalRos1Parser.g:8759:2: rule__PrivateNamespace__Group_2_2__0__Impl rule__PrivateNamespace__Group_2_2__1 + { + pushFollow(FOLLOW_40); + rule__PrivateNamespace__Group_2_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2_2__0" + + + // $ANTLR start "rule__PrivateNamespace__Group_2_2__0__Impl" + // InternalRos1Parser.g:8766:1: rule__PrivateNamespace__Group_2_2__0__Impl : ( Comma ) ; + public final void rule__PrivateNamespace__Group_2_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8770:1: ( ( Comma ) ) + // InternalRos1Parser.g:8771:1: ( Comma ) + { + // InternalRos1Parser.g:8771:1: ( Comma ) + // InternalRos1Parser.g:8772:2: Comma + { + before(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2_2__0__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2_2__1" + // InternalRos1Parser.g:8781:1: rule__PrivateNamespace__Group_2_2__1 : rule__PrivateNamespace__Group_2_2__1__Impl ; + public final void rule__PrivateNamespace__Group_2_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8785:1: ( rule__PrivateNamespace__Group_2_2__1__Impl ) + // InternalRos1Parser.g:8786:2: rule__PrivateNamespace__Group_2_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2_2__1" + + + // $ANTLR start "rule__PrivateNamespace__Group_2_2__1__Impl" + // InternalRos1Parser.g:8792:1: rule__PrivateNamespace__Group_2_2__1__Impl : ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) ; + public final void rule__PrivateNamespace__Group_2_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8796:1: ( ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) ) + // InternalRos1Parser.g:8797:1: ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) + { + // InternalRos1Parser.g:8797:1: ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) + // InternalRos1Parser.g:8798:2: ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) + { + before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); + // InternalRos1Parser.g:8799:2: ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) + // InternalRos1Parser.g:8799:3: rule__PrivateNamespace__PartsAssignment_2_2_1 + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__PartsAssignment_2_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2_2__1__Impl" + + + // $ANTLR start "rule__Parameter__Group__0" + // InternalRos1Parser.g:8808: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:8812:1: ( rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ) + // InternalRos1Parser.g:8813: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:8820:1: rule__Parameter__Group__0__Impl : ( () ) ; + public final void rule__Parameter__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8824:1: ( ( () ) ) + // InternalRos1Parser.g:8825:1: ( () ) + { + // InternalRos1Parser.g:8825:1: ( () ) + // InternalRos1Parser.g:8826:2: () + { + before(grammarAccess.getParameterAccess().getParameterAction_0()); + // InternalRos1Parser.g:8827:2: () + // InternalRos1Parser.g:8827: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:8835: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:8839:1: ( rule__Parameter__Group__1__Impl rule__Parameter__Group__2 ) + // InternalRos1Parser.g:8840: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:8847: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:8851:1: ( ( ( rule__Parameter__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:8852:1: ( ( rule__Parameter__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:8852:1: ( ( rule__Parameter__NameAssignment_1 ) ) + // InternalRos1Parser.g:8853:2: ( rule__Parameter__NameAssignment_1 ) + { + before(grammarAccess.getParameterAccess().getNameAssignment_1()); + // InternalRos1Parser.g:8854:2: ( rule__Parameter__NameAssignment_1 ) + // InternalRos1Parser.g:8854: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:8862: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:8866:1: ( rule__Parameter__Group__2__Impl rule__Parameter__Group__3 ) + // InternalRos1Parser.g:8867: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:8874:1: rule__Parameter__Group__2__Impl : ( Colon ) ; + public final void rule__Parameter__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8878:1: ( ( Colon ) ) + // InternalRos1Parser.g:8879:1: ( Colon ) + { + // InternalRos1Parser.g:8879:1: ( Colon ) + // InternalRos1Parser.g:8880: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:8889: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:8893:1: ( rule__Parameter__Group__3__Impl rule__Parameter__Group__4 ) + // InternalRos1Parser.g:8894:2: rule__Parameter__Group__3__Impl rule__Parameter__Group__4 + { + pushFollow(FOLLOW_42); + 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:8901:1: rule__Parameter__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Parameter__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8905:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:8906:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:8906:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:8907: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:8916: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:8920:1: ( rule__Parameter__Group__4__Impl rule__Parameter__Group__5 ) + // InternalRos1Parser.g:8921:2: rule__Parameter__Group__4__Impl rule__Parameter__Group__5 + { + pushFollow(FOLLOW_43); + 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:8928:1: rule__Parameter__Group__4__Impl : ( Type ) ; + public final void rule__Parameter__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8932:1: ( ( Type ) ) + // InternalRos1Parser.g:8933:1: ( Type ) + { + // InternalRos1Parser.g:8933:1: ( Type ) + // InternalRos1Parser.g:8934:2: Type + { + before(grammarAccess.getParameterAccess().getTypeKeyword_4()); + match(input,Type,FOLLOW_2); + after(grammarAccess.getParameterAccess().getTypeKeyword_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:8943:1: rule__Parameter__Group__5 : rule__Parameter__Group__5__Impl rule__Parameter__Group__6 ; + public final void rule__Parameter__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8947:1: ( rule__Parameter__Group__5__Impl rule__Parameter__Group__6 ) + // InternalRos1Parser.g:8948:2: rule__Parameter__Group__5__Impl rule__Parameter__Group__6 + { + pushFollow(FOLLOW_37); + rule__Parameter__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__6(); + + 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:8955:1: rule__Parameter__Group__5__Impl : ( ( rule__Parameter__TypeAssignment_5 ) ) ; + public final void rule__Parameter__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8959:1: ( ( ( rule__Parameter__TypeAssignment_5 ) ) ) + // InternalRos1Parser.g:8960:1: ( ( rule__Parameter__TypeAssignment_5 ) ) + { + // InternalRos1Parser.g:8960:1: ( ( rule__Parameter__TypeAssignment_5 ) ) + // InternalRos1Parser.g:8961:2: ( rule__Parameter__TypeAssignment_5 ) + { + before(grammarAccess.getParameterAccess().getTypeAssignment_5()); + // InternalRos1Parser.g:8962:2: ( rule__Parameter__TypeAssignment_5 ) + // InternalRos1Parser.g:8962:3: rule__Parameter__TypeAssignment_5 + { + pushFollow(FOLLOW_2); + rule__Parameter__TypeAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAccess().getTypeAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__5__Impl" + + + // $ANTLR start "rule__Parameter__Group__6" + // InternalRos1Parser.g:8970:1: rule__Parameter__Group__6 : rule__Parameter__Group__6__Impl rule__Parameter__Group__7 ; + public final void rule__Parameter__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8974:1: ( rule__Parameter__Group__6__Impl rule__Parameter__Group__7 ) + // InternalRos1Parser.g:8975:2: rule__Parameter__Group__6__Impl rule__Parameter__Group__7 + { + pushFollow(FOLLOW_37); + rule__Parameter__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__6" + + + // $ANTLR start "rule__Parameter__Group__6__Impl" + // InternalRos1Parser.g:8982:1: rule__Parameter__Group__6__Impl : ( ( rule__Parameter__Group_6__0 )? ) ; + public final void rule__Parameter__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:8986:1: ( ( ( rule__Parameter__Group_6__0 )? ) ) + // InternalRos1Parser.g:8987:1: ( ( rule__Parameter__Group_6__0 )? ) + { + // InternalRos1Parser.g:8987:1: ( ( rule__Parameter__Group_6__0 )? ) + // InternalRos1Parser.g:8988:2: ( rule__Parameter__Group_6__0 )? + { + before(grammarAccess.getParameterAccess().getGroup_6()); + // InternalRos1Parser.g:8989:2: ( rule__Parameter__Group_6__0 )? + int alt51=2; + int LA51_0 = input.LA(1); + + if ( (LA51_0==Ns) ) { + alt51=1; + } + switch (alt51) { + case 1 : + // InternalRos1Parser.g:8989:3: rule__Parameter__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Parameter__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__6__Impl" + + + // $ANTLR start "rule__Parameter__Group__7" + // InternalRos1Parser.g:8997:1: rule__Parameter__Group__7 : rule__Parameter__Group__7__Impl rule__Parameter__Group__8 ; + public final void rule__Parameter__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9001:1: ( rule__Parameter__Group__7__Impl rule__Parameter__Group__8 ) + // InternalRos1Parser.g:9002:2: rule__Parameter__Group__7__Impl rule__Parameter__Group__8 + { + pushFollow(FOLLOW_44); + rule__Parameter__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__7" + + + // $ANTLR start "rule__Parameter__Group__7__Impl" + // InternalRos1Parser.g:9009:1: rule__Parameter__Group__7__Impl : ( RULE_END ) ; + public final void rule__Parameter__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9013:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:9014:1: ( RULE_END ) + { + // InternalRos1Parser.g:9014:1: ( RULE_END ) + // InternalRos1Parser.g:9015:2: RULE_END + { + before(grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__7__Impl" + + + // $ANTLR start "rule__Parameter__Group__8" + // InternalRos1Parser.g:9024:1: rule__Parameter__Group__8 : rule__Parameter__Group__8__Impl ; + public final void rule__Parameter__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9028:1: ( rule__Parameter__Group__8__Impl ) + // InternalRos1Parser.g:9029:2: rule__Parameter__Group__8__Impl + { + pushFollow(FOLLOW_2); + rule__Parameter__Group__8__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__8" + + + // $ANTLR start "rule__Parameter__Group__8__Impl" + // InternalRos1Parser.g:9035:1: rule__Parameter__Group__8__Impl : ( RightCurlyBracket ) ; + public final void rule__Parameter__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9039:1: ( ( RightCurlyBracket ) ) + // InternalRos1Parser.g:9040:1: ( RightCurlyBracket ) + { + // InternalRos1Parser.g:9040:1: ( RightCurlyBracket ) + // InternalRos1Parser.g:9041:2: RightCurlyBracket + { + before(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); + match(input,RightCurlyBracket,FOLLOW_2); + after(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__8__Impl" + + + // $ANTLR start "rule__Parameter__Group_6__0" + // InternalRos1Parser.g:9051:1: rule__Parameter__Group_6__0 : rule__Parameter__Group_6__0__Impl rule__Parameter__Group_6__1 ; + public final void rule__Parameter__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9055:1: ( rule__Parameter__Group_6__0__Impl rule__Parameter__Group_6__1 ) + // InternalRos1Parser.g:9056:2: rule__Parameter__Group_6__0__Impl rule__Parameter__Group_6__1 + { + pushFollow(FOLLOW_38); + rule__Parameter__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_6__0" + + + // $ANTLR start "rule__Parameter__Group_6__0__Impl" + // InternalRos1Parser.g:9063:1: rule__Parameter__Group_6__0__Impl : ( Ns ) ; + public final void rule__Parameter__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9067:1: ( ( Ns ) ) + // InternalRos1Parser.g:9068:1: ( Ns ) + { + // InternalRos1Parser.g:9068:1: ( Ns ) + // InternalRos1Parser.g:9069:2: Ns + { + before(grammarAccess.getParameterAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getParameterAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_6__0__Impl" + + + // $ANTLR start "rule__Parameter__Group_6__1" + // InternalRos1Parser.g:9078:1: rule__Parameter__Group_6__1 : rule__Parameter__Group_6__1__Impl ; + public final void rule__Parameter__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9082:1: ( rule__Parameter__Group_6__1__Impl ) + // InternalRos1Parser.g:9083:2: rule__Parameter__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__Parameter__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_6__1" + + + // $ANTLR start "rule__Parameter__Group_6__1__Impl" + // InternalRos1Parser.g:9089:1: rule__Parameter__Group_6__1__Impl : ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) ; + public final void rule__Parameter__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9093:1: ( ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) ) + // InternalRos1Parser.g:9094:1: ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) + { + // InternalRos1Parser.g:9094:1: ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) + // InternalRos1Parser.g:9095:2: ( rule__Parameter__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); + // InternalRos1Parser.g:9096:2: ( rule__Parameter__NamespaceAssignment_6_1 ) + // InternalRos1Parser.g:9096:3: rule__Parameter__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__Parameter__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_6__1__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__0" + // InternalRos1Parser.g:9105:1: rule__ParameterListType__Group__0 : rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 ; + public final void rule__ParameterListType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9109:1: ( rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 ) + // InternalRos1Parser.g:9110:2: rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 + { + pushFollow(FOLLOW_45); + rule__ParameterListType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__0" + + + // $ANTLR start "rule__ParameterListType__Group__0__Impl" + // InternalRos1Parser.g:9117:1: rule__ParameterListType__Group__0__Impl : ( () ) ; + public final void rule__ParameterListType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9121:1: ( ( () ) ) + // InternalRos1Parser.g:9122:1: ( () ) + { + // InternalRos1Parser.g:9122:1: ( () ) + // InternalRos1Parser.g:9123:2: () + { + before(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); + // InternalRos1Parser.g:9124:2: () + // InternalRos1Parser.g:9124:3: + { + } + + after(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__1" + // InternalRos1Parser.g:9132:1: rule__ParameterListType__Group__1 : rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 ; + public final void rule__ParameterListType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9136:1: ( rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 ) + // InternalRos1Parser.g:9137:2: rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 + { + pushFollow(FOLLOW_10); + rule__ParameterListType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__1" + + + // $ANTLR start "rule__ParameterListType__Group__1__Impl" + // InternalRos1Parser.g:9144:1: rule__ParameterListType__Group__1__Impl : ( List ) ; + public final void rule__ParameterListType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9148:1: ( ( List ) ) + // InternalRos1Parser.g:9149:1: ( List ) + { + // InternalRos1Parser.g:9149:1: ( List ) + // InternalRos1Parser.g:9150:2: List + { + before(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); + match(input,List,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__2" + // InternalRos1Parser.g:9159:1: rule__ParameterListType__Group__2 : rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 ; + public final void rule__ParameterListType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9163:1: ( rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 ) + // InternalRos1Parser.g:9164:2: rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 + { + pushFollow(FOLLOW_43); + rule__ParameterListType__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__2" + + + // $ANTLR start "rule__ParameterListType__Group__2__Impl" + // InternalRos1Parser.g:9171:1: rule__ParameterListType__Group__2__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterListType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9175:1: ( ( LeftSquareBracket ) ) + // InternalRos1Parser.g:9176:1: ( LeftSquareBracket ) + { + // InternalRos1Parser.g:9176:1: ( LeftSquareBracket ) + // InternalRos1Parser.g:9177:2: LeftSquareBracket + { + before(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__3" + // InternalRos1Parser.g:9186:1: rule__ParameterListType__Group__3 : rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 ; + public final void rule__ParameterListType__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9190:1: ( rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 ) + // InternalRos1Parser.g:9191:2: rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 + { + pushFollow(FOLLOW_12); + rule__ParameterListType__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__3" + + + // $ANTLR start "rule__ParameterListType__Group__3__Impl" + // InternalRos1Parser.g:9198:1: rule__ParameterListType__Group__3__Impl : ( ( rule__ParameterListType__SequenceAssignment_3 ) ) ; + public final void rule__ParameterListType__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9202:1: ( ( ( rule__ParameterListType__SequenceAssignment_3 ) ) ) + // InternalRos1Parser.g:9203:1: ( ( rule__ParameterListType__SequenceAssignment_3 ) ) + { + // InternalRos1Parser.g:9203:1: ( ( rule__ParameterListType__SequenceAssignment_3 ) ) + // InternalRos1Parser.g:9204:2: ( rule__ParameterListType__SequenceAssignment_3 ) + { + before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); + // InternalRos1Parser.g:9205:2: ( rule__ParameterListType__SequenceAssignment_3 ) + // InternalRos1Parser.g:9205:3: rule__ParameterListType__SequenceAssignment_3 + { + pushFollow(FOLLOW_2); + rule__ParameterListType__SequenceAssignment_3(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__3__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__4" + // InternalRos1Parser.g:9213:1: rule__ParameterListType__Group__4 : rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 ; + public final void rule__ParameterListType__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9217:1: ( rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 ) + // InternalRos1Parser.g:9218:2: rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 + { + pushFollow(FOLLOW_12); + rule__ParameterListType__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__4" + + + // $ANTLR start "rule__ParameterListType__Group__4__Impl" + // InternalRos1Parser.g:9225:1: rule__ParameterListType__Group__4__Impl : ( ( rule__ParameterListType__Group_4__0 )* ) ; + public final void rule__ParameterListType__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9229:1: ( ( ( rule__ParameterListType__Group_4__0 )* ) ) + // InternalRos1Parser.g:9230:1: ( ( rule__ParameterListType__Group_4__0 )* ) + { + // InternalRos1Parser.g:9230:1: ( ( rule__ParameterListType__Group_4__0 )* ) + // InternalRos1Parser.g:9231:2: ( rule__ParameterListType__Group_4__0 )* + { + before(grammarAccess.getParameterListTypeAccess().getGroup_4()); + // InternalRos1Parser.g:9232:2: ( rule__ParameterListType__Group_4__0 )* + loop52: + do { + int alt52=2; + int LA52_0 = input.LA(1); + + if ( (LA52_0==Comma) ) { + alt52=1; + } + + + switch (alt52) { + case 1 : + // InternalRos1Parser.g:9232:3: rule__ParameterListType__Group_4__0 + { + pushFollow(FOLLOW_13); + rule__ParameterListType__Group_4__0(); + + state._fsp--; + + + } + break; + + default : + break loop52; + } + } while (true); + + after(grammarAccess.getParameterListTypeAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__4__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__5" + // InternalRos1Parser.g:9240:1: rule__ParameterListType__Group__5 : rule__ParameterListType__Group__5__Impl ; + public final void rule__ParameterListType__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9244:1: ( rule__ParameterListType__Group__5__Impl ) + // InternalRos1Parser.g:9245:2: rule__ParameterListType__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__5__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__5" + + + // $ANTLR start "rule__ParameterListType__Group__5__Impl" + // InternalRos1Parser.g:9251:1: rule__ParameterListType__Group__5__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterListType__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9255:1: ( ( RightSquareBracket ) ) + // InternalRos1Parser.g:9256:1: ( RightSquareBracket ) + { + // InternalRos1Parser.g:9256:1: ( RightSquareBracket ) + // InternalRos1Parser.g:9257:2: RightSquareBracket + { + before(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__5__Impl" + + + // $ANTLR start "rule__ParameterListType__Group_4__0" + // InternalRos1Parser.g:9267:1: rule__ParameterListType__Group_4__0 : rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 ; + public final void rule__ParameterListType__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9271:1: ( rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 ) + // InternalRos1Parser.g:9272:2: rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 + { + pushFollow(FOLLOW_43); + rule__ParameterListType__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group_4__0" + + + // $ANTLR start "rule__ParameterListType__Group_4__0__Impl" + // InternalRos1Parser.g:9279:1: rule__ParameterListType__Group_4__0__Impl : ( Comma ) ; + public final void rule__ParameterListType__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9283:1: ( ( Comma ) ) + // InternalRos1Parser.g:9284:1: ( Comma ) + { + // InternalRos1Parser.g:9284:1: ( Comma ) + // InternalRos1Parser.g:9285:2: Comma + { + before(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group_4__0__Impl" + + + // $ANTLR start "rule__ParameterListType__Group_4__1" + // InternalRos1Parser.g:9294:1: rule__ParameterListType__Group_4__1 : rule__ParameterListType__Group_4__1__Impl ; + public final void rule__ParameterListType__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9298:1: ( rule__ParameterListType__Group_4__1__Impl ) + // InternalRos1Parser.g:9299:2: rule__ParameterListType__Group_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterListType__Group_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group_4__1" + + + // $ANTLR start "rule__ParameterListType__Group_4__1__Impl" + // InternalRos1Parser.g:9305:1: rule__ParameterListType__Group_4__1__Impl : ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) ; + public final void rule__ParameterListType__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9309:1: ( ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) ) + // InternalRos1Parser.g:9310:1: ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) + { + // InternalRos1Parser.g:9310:1: ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) + // InternalRos1Parser.g:9311:2: ( rule__ParameterListType__SequenceAssignment_4_1 ) + { + before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); + // InternalRos1Parser.g:9312:2: ( rule__ParameterListType__SequenceAssignment_4_1 ) + // InternalRos1Parser.g:9312:3: rule__ParameterListType__SequenceAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__ParameterListType__SequenceAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group_4__1__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__0" + // InternalRos1Parser.g:9321:1: rule__ParameterStructType__Group__0 : rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 ; + public final void rule__ParameterStructType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9325:1: ( rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 ) + // InternalRos1Parser.g:9326:2: rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 + { + pushFollow(FOLLOW_46); + rule__ParameterStructType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__0" + + + // $ANTLR start "rule__ParameterStructType__Group__0__Impl" + // InternalRos1Parser.g:9333:1: rule__ParameterStructType__Group__0__Impl : ( () ) ; + public final void rule__ParameterStructType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9337:1: ( ( () ) ) + // InternalRos1Parser.g:9338:1: ( () ) + { + // InternalRos1Parser.g:9338:1: ( () ) + // InternalRos1Parser.g:9339:2: () + { + before(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); + // InternalRos1Parser.g:9340:2: () + // InternalRos1Parser.g:9340:3: + { + } + + after(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__1" + // InternalRos1Parser.g:9348:1: rule__ParameterStructType__Group__1 : rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 ; + public final void rule__ParameterStructType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9352:1: ( rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 ) + // InternalRos1Parser.g:9353:2: rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 + { + pushFollow(FOLLOW_10); + rule__ParameterStructType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__1" + + + // $ANTLR start "rule__ParameterStructType__Group__1__Impl" + // InternalRos1Parser.g:9360:1: rule__ParameterStructType__Group__1__Impl : ( Struct ) ; + public final void rule__ParameterStructType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9364:1: ( ( Struct ) ) + // InternalRos1Parser.g:9365:1: ( Struct ) + { + // InternalRos1Parser.g:9365:1: ( Struct ) + // InternalRos1Parser.g:9366:2: Struct + { + before(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); + match(input,Struct,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__2" + // InternalRos1Parser.g:9375:1: rule__ParameterStructType__Group__2 : rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 ; + public final void rule__ParameterStructType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9379:1: ( rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 ) + // InternalRos1Parser.g:9380:2: rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 + { + pushFollow(FOLLOW_7); + rule__ParameterStructType__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__2" + + + // $ANTLR start "rule__ParameterStructType__Group__2__Impl" + // InternalRos1Parser.g:9387:1: rule__ParameterStructType__Group__2__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterStructType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9391:1: ( ( LeftSquareBracket ) ) + // InternalRos1Parser.g:9392:1: ( LeftSquareBracket ) + { + // InternalRos1Parser.g:9392:1: ( LeftSquareBracket ) + // InternalRos1Parser.g:9393:2: LeftSquareBracket + { + before(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__3" + // InternalRos1Parser.g:9402:1: rule__ParameterStructType__Group__3 : rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 ; + public final void rule__ParameterStructType__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9406:1: ( rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 ) + // InternalRos1Parser.g:9407:2: rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 + { + pushFollow(FOLLOW_12); + rule__ParameterStructType__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__3" + + + // $ANTLR start "rule__ParameterStructType__Group__3__Impl" + // InternalRos1Parser.g:9414:1: rule__ParameterStructType__Group__3__Impl : ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) ; + public final void rule__ParameterStructType__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9418:1: ( ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) ) + // InternalRos1Parser.g:9419:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) + { + // InternalRos1Parser.g:9419:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) + // InternalRos1Parser.g:9420:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) + { + before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); + // InternalRos1Parser.g:9421:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) + // InternalRos1Parser.g:9421:3: rule__ParameterStructType__ParameterstructypetmemberAssignment_3 + { + pushFollow(FOLLOW_2); + rule__ParameterStructType__ParameterstructypetmemberAssignment_3(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__3__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__4" + // InternalRos1Parser.g:9429:1: rule__ParameterStructType__Group__4 : rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 ; + public final void rule__ParameterStructType__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9433:1: ( rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 ) + // InternalRos1Parser.g:9434:2: rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 + { + pushFollow(FOLLOW_12); + rule__ParameterStructType__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__4" + + + // $ANTLR start "rule__ParameterStructType__Group__4__Impl" + // InternalRos1Parser.g:9441:1: rule__ParameterStructType__Group__4__Impl : ( ( rule__ParameterStructType__Group_4__0 )* ) ; + public final void rule__ParameterStructType__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9445:1: ( ( ( rule__ParameterStructType__Group_4__0 )* ) ) + // InternalRos1Parser.g:9446:1: ( ( rule__ParameterStructType__Group_4__0 )* ) + { + // InternalRos1Parser.g:9446:1: ( ( rule__ParameterStructType__Group_4__0 )* ) + // InternalRos1Parser.g:9447:2: ( rule__ParameterStructType__Group_4__0 )* + { + before(grammarAccess.getParameterStructTypeAccess().getGroup_4()); + // InternalRos1Parser.g:9448:2: ( rule__ParameterStructType__Group_4__0 )* + loop53: + do { + int alt53=2; + int LA53_0 = input.LA(1); + + if ( (LA53_0==Comma) ) { + alt53=1; + } + + + switch (alt53) { + case 1 : + // InternalRos1Parser.g:9448:3: rule__ParameterStructType__Group_4__0 + { + pushFollow(FOLLOW_13); + rule__ParameterStructType__Group_4__0(); + + state._fsp--; + + + } + break; + + default : + break loop53; + } + } while (true); + + after(grammarAccess.getParameterStructTypeAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__4__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__5" + // InternalRos1Parser.g:9456:1: rule__ParameterStructType__Group__5 : rule__ParameterStructType__Group__5__Impl ; + public final void rule__ParameterStructType__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9460:1: ( rule__ParameterStructType__Group__5__Impl ) + // InternalRos1Parser.g:9461:2: rule__ParameterStructType__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__5__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__5" + + + // $ANTLR start "rule__ParameterStructType__Group__5__Impl" + // InternalRos1Parser.g:9467:1: rule__ParameterStructType__Group__5__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterStructType__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9471:1: ( ( RightSquareBracket ) ) + // InternalRos1Parser.g:9472:1: ( RightSquareBracket ) + { + // InternalRos1Parser.g:9472:1: ( RightSquareBracket ) + // InternalRos1Parser.g:9473:2: RightSquareBracket + { + before(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__5__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group_4__0" + // InternalRos1Parser.g:9483:1: rule__ParameterStructType__Group_4__0 : rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 ; + public final void rule__ParameterStructType__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9487:1: ( rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 ) + // InternalRos1Parser.g:9488:2: rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 + { + pushFollow(FOLLOW_7); + rule__ParameterStructType__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group_4__0" + + + // $ANTLR start "rule__ParameterStructType__Group_4__0__Impl" + // InternalRos1Parser.g:9495:1: rule__ParameterStructType__Group_4__0__Impl : ( Comma ) ; + public final void rule__ParameterStructType__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9499:1: ( ( Comma ) ) + // InternalRos1Parser.g:9500:1: ( Comma ) + { + // InternalRos1Parser.g:9500:1: ( Comma ) + // InternalRos1Parser.g:9501:2: Comma + { + before(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group_4__0__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group_4__1" + // InternalRos1Parser.g:9510:1: rule__ParameterStructType__Group_4__1 : rule__ParameterStructType__Group_4__1__Impl ; + public final void rule__ParameterStructType__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9514:1: ( rule__ParameterStructType__Group_4__1__Impl ) + // InternalRos1Parser.g:9515:2: rule__ParameterStructType__Group_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group_4__1" + + + // $ANTLR start "rule__ParameterStructType__Group_4__1__Impl" + // InternalRos1Parser.g:9521:1: rule__ParameterStructType__Group_4__1__Impl : ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) ; + public final void rule__ParameterStructType__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9525:1: ( ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) ) + // InternalRos1Parser.g:9526:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) + { + // InternalRos1Parser.g:9526:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) + // InternalRos1Parser.g:9527:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) + { + before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); + // InternalRos1Parser.g:9528:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) + // InternalRos1Parser.g:9528:3: rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group_4__1__Impl" + + + // $ANTLR start "rule__ParameterIntegerType__Group__0" + // InternalRos1Parser.g:9537:1: rule__ParameterIntegerType__Group__0 : rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 ; + public final void rule__ParameterIntegerType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9541:1: ( rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 ) + // InternalRos1Parser.g:9542:2: rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 + { + pushFollow(FOLLOW_47); + rule__ParameterIntegerType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__0" + + + // $ANTLR start "rule__ParameterIntegerType__Group__0__Impl" + // InternalRos1Parser.g:9549:1: rule__ParameterIntegerType__Group__0__Impl : ( () ) ; + public final void rule__ParameterIntegerType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9553:1: ( ( () ) ) + // InternalRos1Parser.g:9554:1: ( () ) + { + // InternalRos1Parser.g:9554:1: ( () ) + // InternalRos1Parser.g:9555:2: () + { + before(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); + // InternalRos1Parser.g:9556:2: () + // InternalRos1Parser.g:9556:3: + { + } + + after(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterIntegerType__Group__1" + // InternalRos1Parser.g:9564:1: rule__ParameterIntegerType__Group__1 : rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 ; + public final void rule__ParameterIntegerType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9568:1: ( rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 ) + // InternalRos1Parser.g:9569:2: rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 + { + pushFollow(FOLLOW_48); + rule__ParameterIntegerType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__1" + + + // $ANTLR start "rule__ParameterIntegerType__Group__1__Impl" + // InternalRos1Parser.g:9576:1: rule__ParameterIntegerType__Group__1__Impl : ( Integer ) ; + public final void rule__ParameterIntegerType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9580:1: ( ( Integer ) ) + // InternalRos1Parser.g:9581:1: ( Integer ) + { + // InternalRos1Parser.g:9581:1: ( Integer ) + // InternalRos1Parser.g:9582:2: Integer + { + before(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); + match(input,Integer,FOLLOW_2); + after(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterIntegerType__Group__2" + // InternalRos1Parser.g:9591:1: rule__ParameterIntegerType__Group__2 : rule__ParameterIntegerType__Group__2__Impl ; + public final void rule__ParameterIntegerType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9595:1: ( rule__ParameterIntegerType__Group__2__Impl ) + // InternalRos1Parser.g:9596:2: rule__ParameterIntegerType__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__2" + + + // $ANTLR start "rule__ParameterIntegerType__Group__2__Impl" + // InternalRos1Parser.g:9602:1: rule__ParameterIntegerType__Group__2__Impl : ( ( rule__ParameterIntegerType__Group_2__0 )? ) ; + public final void rule__ParameterIntegerType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9606:1: ( ( ( rule__ParameterIntegerType__Group_2__0 )? ) ) + // InternalRos1Parser.g:9607:1: ( ( rule__ParameterIntegerType__Group_2__0 )? ) + { + // InternalRos1Parser.g:9607:1: ( ( rule__ParameterIntegerType__Group_2__0 )? ) + // InternalRos1Parser.g:9608:2: ( rule__ParameterIntegerType__Group_2__0 )? + { + before(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); + // InternalRos1Parser.g:9609:2: ( rule__ParameterIntegerType__Group_2__0 )? + int alt54=2; + int LA54_0 = input.LA(1); + + if ( (LA54_0==Default) ) { + int LA54_1 = input.LA(2); + + if ( (LA54_1==RULE_DECINT) ) { + alt54=1; + } + } + switch (alt54) { + case 1 : + // InternalRos1Parser.g:9609:3: rule__ParameterIntegerType__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterIntegerType__Group_2__0" + // InternalRos1Parser.g:9618:1: rule__ParameterIntegerType__Group_2__0 : rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 ; + public final void rule__ParameterIntegerType__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9622:1: ( rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 ) + // InternalRos1Parser.g:9623:2: rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 + { + pushFollow(FOLLOW_49); + rule__ParameterIntegerType__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group_2__0" + + + // $ANTLR start "rule__ParameterIntegerType__Group_2__0__Impl" + // InternalRos1Parser.g:9630:1: rule__ParameterIntegerType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterIntegerType__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9634:1: ( ( Default ) ) + // InternalRos1Parser.g:9635:1: ( Default ) + { + // InternalRos1Parser.g:9635:1: ( Default ) + // InternalRos1Parser.g:9636:2: Default + { + before(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterIntegerType__Group_2__1" + // InternalRos1Parser.g:9645:1: rule__ParameterIntegerType__Group_2__1 : rule__ParameterIntegerType__Group_2__1__Impl ; + public final void rule__ParameterIntegerType__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9649:1: ( rule__ParameterIntegerType__Group_2__1__Impl ) + // InternalRos1Parser.g:9650:2: rule__ParameterIntegerType__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group_2__1" + + + // $ANTLR start "rule__ParameterIntegerType__Group_2__1__Impl" + // InternalRos1Parser.g:9656:1: rule__ParameterIntegerType__Group_2__1__Impl : ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterIntegerType__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9660:1: ( ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) ) + // InternalRos1Parser.g:9661:1: ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) + { + // InternalRos1Parser.g:9661:1: ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) + // InternalRos1Parser.g:9662:2: ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) + { + before(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); + // InternalRos1Parser.g:9663:2: ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) + // InternalRos1Parser.g:9663:3: rule__ParameterIntegerType__DefaultAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__DefaultAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterStringType__Group__0" + // InternalRos1Parser.g:9672:1: rule__ParameterStringType__Group__0 : rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 ; + public final void rule__ParameterStringType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9676:1: ( rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 ) + // InternalRos1Parser.g:9677:2: rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 + { + pushFollow(FOLLOW_50); + rule__ParameterStringType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__0" + + + // $ANTLR start "rule__ParameterStringType__Group__0__Impl" + // InternalRos1Parser.g:9684:1: rule__ParameterStringType__Group__0__Impl : ( () ) ; + public final void rule__ParameterStringType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9688:1: ( ( () ) ) + // InternalRos1Parser.g:9689:1: ( () ) + { + // InternalRos1Parser.g:9689:1: ( () ) + // InternalRos1Parser.g:9690:2: () + { + before(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); + // InternalRos1Parser.g:9691:2: () + // InternalRos1Parser.g:9691:3: + { + } + + after(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterStringType__Group__1" + // InternalRos1Parser.g:9699:1: rule__ParameterStringType__Group__1 : rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 ; + public final void rule__ParameterStringType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9703:1: ( rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 ) + // InternalRos1Parser.g:9704:2: rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 + { + pushFollow(FOLLOW_48); + rule__ParameterStringType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__1" + + + // $ANTLR start "rule__ParameterStringType__Group__1__Impl" + // InternalRos1Parser.g:9711:1: rule__ParameterStringType__Group__1__Impl : ( String ) ; + public final void rule__ParameterStringType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9715:1: ( ( String ) ) + // InternalRos1Parser.g:9716:1: ( String ) + { + // InternalRos1Parser.g:9716:1: ( String ) + // InternalRos1Parser.g:9717:2: String + { + before(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); + match(input,String,FOLLOW_2); + after(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterStringType__Group__2" + // InternalRos1Parser.g:9726:1: rule__ParameterStringType__Group__2 : rule__ParameterStringType__Group__2__Impl ; + public final void rule__ParameterStringType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9730:1: ( rule__ParameterStringType__Group__2__Impl ) + // InternalRos1Parser.g:9731:2: rule__ParameterStringType__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__2" + + + // $ANTLR start "rule__ParameterStringType__Group__2__Impl" + // InternalRos1Parser.g:9737:1: rule__ParameterStringType__Group__2__Impl : ( ( rule__ParameterStringType__Group_2__0 )? ) ; + public final void rule__ParameterStringType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9741:1: ( ( ( rule__ParameterStringType__Group_2__0 )? ) ) + // InternalRos1Parser.g:9742:1: ( ( rule__ParameterStringType__Group_2__0 )? ) + { + // InternalRos1Parser.g:9742:1: ( ( rule__ParameterStringType__Group_2__0 )? ) + // InternalRos1Parser.g:9743:2: ( rule__ParameterStringType__Group_2__0 )? + { + before(grammarAccess.getParameterStringTypeAccess().getGroup_2()); + // InternalRos1Parser.g:9744:2: ( rule__ParameterStringType__Group_2__0 )? + int alt55=2; + int LA55_0 = input.LA(1); + + if ( (LA55_0==Default) ) { + int LA55_1 = input.LA(2); + + if ( (LA55_1==RULE_ID||LA55_1==RULE_STRING) ) { + alt55=1; + } + } + switch (alt55) { + case 1 : + // InternalRos1Parser.g:9744:3: rule__ParameterStringType__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterStringTypeAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterStringType__Group_2__0" + // InternalRos1Parser.g:9753:1: rule__ParameterStringType__Group_2__0 : rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 ; + public final void rule__ParameterStringType__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9757:1: ( rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 ) + // InternalRos1Parser.g:9758:2: rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 + { + pushFollow(FOLLOW_7); + rule__ParameterStringType__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group_2__0" + + + // $ANTLR start "rule__ParameterStringType__Group_2__0__Impl" + // InternalRos1Parser.g:9765:1: rule__ParameterStringType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterStringType__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9769:1: ( ( Default ) ) + // InternalRos1Parser.g:9770:1: ( Default ) + { + // InternalRos1Parser.g:9770:1: ( Default ) + // InternalRos1Parser.g:9771:2: Default + { + before(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterStringType__Group_2__1" + // InternalRos1Parser.g:9780:1: rule__ParameterStringType__Group_2__1 : rule__ParameterStringType__Group_2__1__Impl ; + public final void rule__ParameterStringType__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9784:1: ( rule__ParameterStringType__Group_2__1__Impl ) + // InternalRos1Parser.g:9785:2: rule__ParameterStringType__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group_2__1" + + + // $ANTLR start "rule__ParameterStringType__Group_2__1__Impl" + // InternalRos1Parser.g:9791:1: rule__ParameterStringType__Group_2__1__Impl : ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterStringType__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9795:1: ( ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) ) + // InternalRos1Parser.g:9796:1: ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) + { + // InternalRos1Parser.g:9796:1: ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) + // InternalRos1Parser.g:9797:2: ( rule__ParameterStringType__DefaultAssignment_2_1 ) + { + before(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); + // InternalRos1Parser.g:9798:2: ( rule__ParameterStringType__DefaultAssignment_2_1 ) + // InternalRos1Parser.g:9798:3: rule__ParameterStringType__DefaultAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStringType__DefaultAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterDoubleType__Group__0" + // InternalRos1Parser.g:9807:1: rule__ParameterDoubleType__Group__0 : rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 ; + public final void rule__ParameterDoubleType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9811:1: ( rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 ) + // InternalRos1Parser.g:9812:2: rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 + { + pushFollow(FOLLOW_51); + rule__ParameterDoubleType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__0" + + + // $ANTLR start "rule__ParameterDoubleType__Group__0__Impl" + // InternalRos1Parser.g:9819:1: rule__ParameterDoubleType__Group__0__Impl : ( () ) ; + public final void rule__ParameterDoubleType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9823:1: ( ( () ) ) + // InternalRos1Parser.g:9824:1: ( () ) + { + // InternalRos1Parser.g:9824:1: ( () ) + // InternalRos1Parser.g:9825:2: () + { + before(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); + // InternalRos1Parser.g:9826:2: () + // InternalRos1Parser.g:9826:3: + { + } + + after(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterDoubleType__Group__1" + // InternalRos1Parser.g:9834:1: rule__ParameterDoubleType__Group__1 : rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 ; + public final void rule__ParameterDoubleType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9838:1: ( rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 ) + // InternalRos1Parser.g:9839:2: rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 + { + pushFollow(FOLLOW_48); + rule__ParameterDoubleType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__1" + + + // $ANTLR start "rule__ParameterDoubleType__Group__1__Impl" + // InternalRos1Parser.g:9846:1: rule__ParameterDoubleType__Group__1__Impl : ( Double ) ; + public final void rule__ParameterDoubleType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9850:1: ( ( Double ) ) + // InternalRos1Parser.g:9851:1: ( Double ) + { + // InternalRos1Parser.g:9851:1: ( Double ) + // InternalRos1Parser.g:9852:2: Double + { + before(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); + match(input,Double,FOLLOW_2); + after(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterDoubleType__Group__2" + // InternalRos1Parser.g:9861:1: rule__ParameterDoubleType__Group__2 : rule__ParameterDoubleType__Group__2__Impl ; + public final void rule__ParameterDoubleType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9865:1: ( rule__ParameterDoubleType__Group__2__Impl ) + // InternalRos1Parser.g:9866:2: rule__ParameterDoubleType__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__2" + + + // $ANTLR start "rule__ParameterDoubleType__Group__2__Impl" + // InternalRos1Parser.g:9872:1: rule__ParameterDoubleType__Group__2__Impl : ( ( rule__ParameterDoubleType__Group_2__0 )? ) ; + public final void rule__ParameterDoubleType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9876:1: ( ( ( rule__ParameterDoubleType__Group_2__0 )? ) ) + // InternalRos1Parser.g:9877:1: ( ( rule__ParameterDoubleType__Group_2__0 )? ) + { + // InternalRos1Parser.g:9877:1: ( ( rule__ParameterDoubleType__Group_2__0 )? ) + // InternalRos1Parser.g:9878:2: ( rule__ParameterDoubleType__Group_2__0 )? + { + before(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); + // InternalRos1Parser.g:9879:2: ( rule__ParameterDoubleType__Group_2__0 )? + int alt56=2; + int LA56_0 = input.LA(1); + + if ( (LA56_0==Default) ) { + int LA56_1 = input.LA(2); + + if ( (LA56_1==RULE_DOUBLE) ) { + alt56=1; + } + } + switch (alt56) { + case 1 : + // InternalRos1Parser.g:9879:3: rule__ParameterDoubleType__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterDoubleType__Group_2__0" + // InternalRos1Parser.g:9888:1: rule__ParameterDoubleType__Group_2__0 : rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 ; + public final void rule__ParameterDoubleType__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9892:1: ( rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 ) + // InternalRos1Parser.g:9893:2: rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 + { + pushFollow(FOLLOW_52); + rule__ParameterDoubleType__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group_2__0" + + + // $ANTLR start "rule__ParameterDoubleType__Group_2__0__Impl" + // InternalRos1Parser.g:9900:1: rule__ParameterDoubleType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterDoubleType__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9904:1: ( ( Default ) ) + // InternalRos1Parser.g:9905:1: ( Default ) + { + // InternalRos1Parser.g:9905:1: ( Default ) + // InternalRos1Parser.g:9906:2: Default + { + before(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterDoubleType__Group_2__1" + // InternalRos1Parser.g:9915:1: rule__ParameterDoubleType__Group_2__1 : rule__ParameterDoubleType__Group_2__1__Impl ; + public final void rule__ParameterDoubleType__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9919:1: ( rule__ParameterDoubleType__Group_2__1__Impl ) + // InternalRos1Parser.g:9920:2: rule__ParameterDoubleType__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group_2__1" + + + // $ANTLR start "rule__ParameterDoubleType__Group_2__1__Impl" + // InternalRos1Parser.g:9926:1: rule__ParameterDoubleType__Group_2__1__Impl : ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterDoubleType__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9930:1: ( ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) ) + // InternalRos1Parser.g:9931:1: ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) + { + // InternalRos1Parser.g:9931:1: ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) + // InternalRos1Parser.g:9932:2: ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) + { + before(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); + // InternalRos1Parser.g:9933:2: ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) + // InternalRos1Parser.g:9933:3: rule__ParameterDoubleType__DefaultAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__DefaultAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterBooleanType__Group__0" + // InternalRos1Parser.g:9942:1: rule__ParameterBooleanType__Group__0 : rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 ; + public final void rule__ParameterBooleanType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9946:1: ( rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 ) + // InternalRos1Parser.g:9947:2: rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 + { + pushFollow(FOLLOW_53); + rule__ParameterBooleanType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__0" + + + // $ANTLR start "rule__ParameterBooleanType__Group__0__Impl" + // InternalRos1Parser.g:9954:1: rule__ParameterBooleanType__Group__0__Impl : ( () ) ; + public final void rule__ParameterBooleanType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9958:1: ( ( () ) ) + // InternalRos1Parser.g:9959:1: ( () ) + { + // InternalRos1Parser.g:9959:1: ( () ) + // InternalRos1Parser.g:9960:2: () + { + before(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); + // InternalRos1Parser.g:9961:2: () + // InternalRos1Parser.g:9961:3: + { + } + + after(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterBooleanType__Group__1" + // InternalRos1Parser.g:9969:1: rule__ParameterBooleanType__Group__1 : rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 ; + public final void rule__ParameterBooleanType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9973:1: ( rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 ) + // InternalRos1Parser.g:9974:2: rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 + { + pushFollow(FOLLOW_48); + rule__ParameterBooleanType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__1" + + + // $ANTLR start "rule__ParameterBooleanType__Group__1__Impl" + // InternalRos1Parser.g:9981:1: rule__ParameterBooleanType__Group__1__Impl : ( Boolean ) ; + public final void rule__ParameterBooleanType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:9985:1: ( ( Boolean ) ) + // InternalRos1Parser.g:9986:1: ( Boolean ) + { + // InternalRos1Parser.g:9986:1: ( Boolean ) + // InternalRos1Parser.g:9987:2: Boolean + { + before(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); + match(input,Boolean,FOLLOW_2); + after(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterBooleanType__Group__2" + // InternalRos1Parser.g:9996:1: rule__ParameterBooleanType__Group__2 : rule__ParameterBooleanType__Group__2__Impl ; + public final void rule__ParameterBooleanType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10000:1: ( rule__ParameterBooleanType__Group__2__Impl ) + // InternalRos1Parser.g:10001:2: rule__ParameterBooleanType__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__2" + + + // $ANTLR start "rule__ParameterBooleanType__Group__2__Impl" + // InternalRos1Parser.g:10007:1: rule__ParameterBooleanType__Group__2__Impl : ( ( rule__ParameterBooleanType__Group_2__0 )? ) ; + public final void rule__ParameterBooleanType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10011:1: ( ( ( rule__ParameterBooleanType__Group_2__0 )? ) ) + // InternalRos1Parser.g:10012:1: ( ( rule__ParameterBooleanType__Group_2__0 )? ) + { + // InternalRos1Parser.g:10012:1: ( ( rule__ParameterBooleanType__Group_2__0 )? ) + // InternalRos1Parser.g:10013:2: ( rule__ParameterBooleanType__Group_2__0 )? + { + before(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); + // InternalRos1Parser.g:10014:2: ( rule__ParameterBooleanType__Group_2__0 )? + int alt57=2; + int LA57_0 = input.LA(1); + + if ( (LA57_0==Default) ) { + int LA57_1 = input.LA(2); + + if ( (LA57_1==RULE_BOOLEAN) ) { + alt57=1; + } + } + switch (alt57) { + case 1 : + // InternalRos1Parser.g:10014:3: rule__ParameterBooleanType__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterBooleanType__Group_2__0" + // InternalRos1Parser.g:10023:1: rule__ParameterBooleanType__Group_2__0 : rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 ; + public final void rule__ParameterBooleanType__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10027:1: ( rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 ) + // InternalRos1Parser.g:10028:2: rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 + { + pushFollow(FOLLOW_54); + rule__ParameterBooleanType__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group_2__0" + + + // $ANTLR start "rule__ParameterBooleanType__Group_2__0__Impl" + // InternalRos1Parser.g:10035:1: rule__ParameterBooleanType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterBooleanType__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10039:1: ( ( Default ) ) + // InternalRos1Parser.g:10040:1: ( Default ) + { + // InternalRos1Parser.g:10040:1: ( Default ) + // InternalRos1Parser.g:10041:2: Default + { + before(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterBooleanType__Group_2__1" + // InternalRos1Parser.g:10050:1: rule__ParameterBooleanType__Group_2__1 : rule__ParameterBooleanType__Group_2__1__Impl ; + public final void rule__ParameterBooleanType__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10054:1: ( rule__ParameterBooleanType__Group_2__1__Impl ) + // InternalRos1Parser.g:10055:2: rule__ParameterBooleanType__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group_2__1" + + + // $ANTLR start "rule__ParameterBooleanType__Group_2__1__Impl" + // InternalRos1Parser.g:10061:1: rule__ParameterBooleanType__Group_2__1__Impl : ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterBooleanType__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10065:1: ( ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) ) + // InternalRos1Parser.g:10066:1: ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) + { + // InternalRos1Parser.g:10066:1: ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) + // InternalRos1Parser.g:10067:2: ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) + { + before(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); + // InternalRos1Parser.g:10068:2: ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) + // InternalRos1Parser.g:10068:3: rule__ParameterBooleanType__DefaultAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__DefaultAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterBase64Type__Group__0" + // InternalRos1Parser.g:10077:1: rule__ParameterBase64Type__Group__0 : rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 ; + public final void rule__ParameterBase64Type__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10081:1: ( rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 ) + // InternalRos1Parser.g:10082:2: rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 + { + pushFollow(FOLLOW_55); + rule__ParameterBase64Type__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__0" + + + // $ANTLR start "rule__ParameterBase64Type__Group__0__Impl" + // InternalRos1Parser.g:10089:1: rule__ParameterBase64Type__Group__0__Impl : ( () ) ; + public final void rule__ParameterBase64Type__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10093:1: ( ( () ) ) + // InternalRos1Parser.g:10094:1: ( () ) + { + // InternalRos1Parser.g:10094:1: ( () ) + // InternalRos1Parser.g:10095:2: () + { + before(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); + // InternalRos1Parser.g:10096:2: () + // InternalRos1Parser.g:10096:3: + { + } + + after(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__0__Impl" + + + // $ANTLR start "rule__ParameterBase64Type__Group__1" + // InternalRos1Parser.g:10104:1: rule__ParameterBase64Type__Group__1 : rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 ; + public final void rule__ParameterBase64Type__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10108:1: ( rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 ) + // InternalRos1Parser.g:10109:2: rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 + { + pushFollow(FOLLOW_48); + rule__ParameterBase64Type__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__1" + + + // $ANTLR start "rule__ParameterBase64Type__Group__1__Impl" + // InternalRos1Parser.g:10116:1: rule__ParameterBase64Type__Group__1__Impl : ( Base64 ) ; + public final void rule__ParameterBase64Type__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10120:1: ( ( Base64 ) ) + // InternalRos1Parser.g:10121:1: ( Base64 ) + { + // InternalRos1Parser.g:10121:1: ( Base64 ) + // InternalRos1Parser.g:10122:2: Base64 + { + before(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); + match(input,Base64,FOLLOW_2); + after(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__1__Impl" + + + // $ANTLR start "rule__ParameterBase64Type__Group__2" + // InternalRos1Parser.g:10131:1: rule__ParameterBase64Type__Group__2 : rule__ParameterBase64Type__Group__2__Impl ; + public final void rule__ParameterBase64Type__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10135:1: ( rule__ParameterBase64Type__Group__2__Impl ) + // InternalRos1Parser.g:10136:2: rule__ParameterBase64Type__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__2" + + + // $ANTLR start "rule__ParameterBase64Type__Group__2__Impl" + // InternalRos1Parser.g:10142:1: rule__ParameterBase64Type__Group__2__Impl : ( ( rule__ParameterBase64Type__Group_2__0 )? ) ; + public final void rule__ParameterBase64Type__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10146:1: ( ( ( rule__ParameterBase64Type__Group_2__0 )? ) ) + // InternalRos1Parser.g:10147:1: ( ( rule__ParameterBase64Type__Group_2__0 )? ) + { + // InternalRos1Parser.g:10147:1: ( ( rule__ParameterBase64Type__Group_2__0 )? ) + // InternalRos1Parser.g:10148:2: ( rule__ParameterBase64Type__Group_2__0 )? + { + before(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); + // InternalRos1Parser.g:10149:2: ( rule__ParameterBase64Type__Group_2__0 )? + int alt58=2; + int LA58_0 = input.LA(1); + + if ( (LA58_0==Default) ) { + int LA58_1 = input.LA(2); + + if ( (LA58_1==RULE_BINARY) ) { + alt58=1; + } + } + switch (alt58) { + case 1 : + // InternalRos1Parser.g:10149:3: rule__ParameterBase64Type__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__2__Impl" + + + // $ANTLR start "rule__ParameterBase64Type__Group_2__0" + // InternalRos1Parser.g:10158:1: rule__ParameterBase64Type__Group_2__0 : rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 ; + public final void rule__ParameterBase64Type__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10162:1: ( rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 ) + // InternalRos1Parser.g:10163:2: rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 + { + pushFollow(FOLLOW_56); + rule__ParameterBase64Type__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group_2__0" + + + // $ANTLR start "rule__ParameterBase64Type__Group_2__0__Impl" + // InternalRos1Parser.g:10170:1: rule__ParameterBase64Type__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterBase64Type__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10174:1: ( ( Default ) ) + // InternalRos1Parser.g:10175:1: ( Default ) + { + // InternalRos1Parser.g:10175:1: ( Default ) + // InternalRos1Parser.g:10176:2: Default + { + before(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterBase64Type__Group_2__1" + // InternalRos1Parser.g:10185:1: rule__ParameterBase64Type__Group_2__1 : rule__ParameterBase64Type__Group_2__1__Impl ; + public final void rule__ParameterBase64Type__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10189:1: ( rule__ParameterBase64Type__Group_2__1__Impl ) + // InternalRos1Parser.g:10190:2: rule__ParameterBase64Type__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group_2__1" + + + // $ANTLR start "rule__ParameterBase64Type__Group_2__1__Impl" + // InternalRos1Parser.g:10196:1: rule__ParameterBase64Type__Group_2__1__Impl : ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterBase64Type__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10200:1: ( ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) ) + // InternalRos1Parser.g:10201:1: ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) + { + // InternalRos1Parser.g:10201:1: ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) + // InternalRos1Parser.g:10202:2: ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) + { + before(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); + // InternalRos1Parser.g:10203:2: ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) + // InternalRos1Parser.g:10203:3: rule__ParameterBase64Type__DefaultAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__DefaultAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__0" + // InternalRos1Parser.g:10212:1: rule__ParameterArrayType__Group__0 : rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 ; + public final void rule__ParameterArrayType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10216:1: ( rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 ) + // InternalRos1Parser.g:10217:2: rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 + { + pushFollow(FOLLOW_5); + rule__ParameterArrayType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__0" + + + // $ANTLR start "rule__ParameterArrayType__Group__0__Impl" + // InternalRos1Parser.g:10224:1: rule__ParameterArrayType__Group__0__Impl : ( Array ) ; + public final void rule__ParameterArrayType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10228:1: ( ( Array ) ) + // InternalRos1Parser.g:10229:1: ( Array ) + { + // InternalRos1Parser.g:10229:1: ( Array ) + // InternalRos1Parser.g:10230:2: Array + { + before(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); + match(input,Array,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__1" + // InternalRos1Parser.g:10239:1: rule__ParameterArrayType__Group__1 : rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 ; + public final void rule__ParameterArrayType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10243:1: ( rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 ) + // InternalRos1Parser.g:10244:2: rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 + { + pushFollow(FOLLOW_42); + rule__ParameterArrayType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__1" + + + // $ANTLR start "rule__ParameterArrayType__Group__1__Impl" + // InternalRos1Parser.g:10251:1: rule__ParameterArrayType__Group__1__Impl : ( RULE_BEGIN ) ; + public final void rule__ParameterArrayType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10255:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:10256:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:10256:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:10257:2: RULE_BEGIN + { + before(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__2" + // InternalRos1Parser.g:10266:1: rule__ParameterArrayType__Group__2 : rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 ; + public final void rule__ParameterArrayType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10270:1: ( rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 ) + // InternalRos1Parser.g:10271:2: rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 + { + pushFollow(FOLLOW_43); + rule__ParameterArrayType__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__2" + + + // $ANTLR start "rule__ParameterArrayType__Group__2__Impl" + // InternalRos1Parser.g:10278:1: rule__ParameterArrayType__Group__2__Impl : ( Type ) ; + public final void rule__ParameterArrayType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10282:1: ( ( Type ) ) + // InternalRos1Parser.g:10283:1: ( Type ) + { + // InternalRos1Parser.g:10283:1: ( Type ) + // InternalRos1Parser.g:10284:2: Type + { + before(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); + match(input,Type,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__3" + // InternalRos1Parser.g:10293:1: rule__ParameterArrayType__Group__3 : rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 ; + public final void rule__ParameterArrayType__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10297:1: ( rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 ) + // InternalRos1Parser.g:10298:2: rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 + { + pushFollow(FOLLOW_57); + rule__ParameterArrayType__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__3" + + + // $ANTLR start "rule__ParameterArrayType__Group__3__Impl" + // InternalRos1Parser.g:10305:1: rule__ParameterArrayType__Group__3__Impl : ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) ; + public final void rule__ParameterArrayType__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10309:1: ( ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) ) + // InternalRos1Parser.g:10310:1: ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) + { + // InternalRos1Parser.g:10310:1: ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) + // InternalRos1Parser.g:10311:2: ( rule__ParameterArrayType__TypeAssignment_3 ) + { + before(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); + // InternalRos1Parser.g:10312:2: ( rule__ParameterArrayType__TypeAssignment_3 ) + // InternalRos1Parser.g:10312:3: rule__ParameterArrayType__TypeAssignment_3 + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__TypeAssignment_3(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__3__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__4" + // InternalRos1Parser.g:10320:1: rule__ParameterArrayType__Group__4 : rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 ; + public final void rule__ParameterArrayType__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10324:1: ( rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 ) + // InternalRos1Parser.g:10325:2: rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 + { + pushFollow(FOLLOW_57); + rule__ParameterArrayType__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__4" + + + // $ANTLR start "rule__ParameterArrayType__Group__4__Impl" + // InternalRos1Parser.g:10332:1: rule__ParameterArrayType__Group__4__Impl : ( ( rule__ParameterArrayType__Group_4__0 )? ) ; + public final void rule__ParameterArrayType__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10336:1: ( ( ( rule__ParameterArrayType__Group_4__0 )? ) ) + // InternalRos1Parser.g:10337:1: ( ( rule__ParameterArrayType__Group_4__0 )? ) + { + // InternalRos1Parser.g:10337:1: ( ( rule__ParameterArrayType__Group_4__0 )? ) + // InternalRos1Parser.g:10338:2: ( rule__ParameterArrayType__Group_4__0 )? + { + before(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); + // InternalRos1Parser.g:10339:2: ( rule__ParameterArrayType__Group_4__0 )? + int alt59=2; + int LA59_0 = input.LA(1); + + if ( (LA59_0==Default) ) { + alt59=1; + } + switch (alt59) { + case 1 : + // InternalRos1Parser.g:10339:3: rule__ParameterArrayType__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group_4__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__4__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__5" + // InternalRos1Parser.g:10347:1: rule__ParameterArrayType__Group__5 : rule__ParameterArrayType__Group__5__Impl ; + public final void rule__ParameterArrayType__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10351:1: ( rule__ParameterArrayType__Group__5__Impl ) + // InternalRos1Parser.g:10352:2: rule__ParameterArrayType__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__5__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__5" + + + // $ANTLR start "rule__ParameterArrayType__Group__5__Impl" + // InternalRos1Parser.g:10358:1: rule__ParameterArrayType__Group__5__Impl : ( RULE_END ) ; + public final void rule__ParameterArrayType__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10362:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:10363:1: ( RULE_END ) + { + // InternalRos1Parser.g:10363:1: ( RULE_END ) + // InternalRos1Parser.g:10364:2: RULE_END + { + before(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__5__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group_4__0" + // InternalRos1Parser.g:10374:1: rule__ParameterArrayType__Group_4__0 : rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 ; + public final void rule__ParameterArrayType__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10378:1: ( rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 ) + // InternalRos1Parser.g:10379:2: rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 + { + pushFollow(FOLLOW_10); + rule__ParameterArrayType__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group_4__0" + + + // $ANTLR start "rule__ParameterArrayType__Group_4__0__Impl" + // InternalRos1Parser.g:10386:1: rule__ParameterArrayType__Group_4__0__Impl : ( Default ) ; + public final void rule__ParameterArrayType__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10390:1: ( ( Default ) ) + // InternalRos1Parser.g:10391:1: ( Default ) + { + // InternalRos1Parser.g:10391:1: ( Default ) + // InternalRos1Parser.g:10392:2: Default + { + before(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group_4__0__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group_4__1" + // InternalRos1Parser.g:10401:1: rule__ParameterArrayType__Group_4__1 : rule__ParameterArrayType__Group_4__1__Impl ; + public final void rule__ParameterArrayType__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10405:1: ( rule__ParameterArrayType__Group_4__1__Impl ) + // InternalRos1Parser.g:10406:2: rule__ParameterArrayType__Group_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group_4__1" + + + // $ANTLR start "rule__ParameterArrayType__Group_4__1__Impl" + // InternalRos1Parser.g:10412:1: rule__ParameterArrayType__Group_4__1__Impl : ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) ; + public final void rule__ParameterArrayType__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10416:1: ( ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) ) + // InternalRos1Parser.g:10417:1: ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) + { + // InternalRos1Parser.g:10417:1: ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) + // InternalRos1Parser.g:10418:2: ( rule__ParameterArrayType__DefaultAssignment_4_1 ) + { + before(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); + // InternalRos1Parser.g:10419:2: ( rule__ParameterArrayType__DefaultAssignment_4_1 ) + // InternalRos1Parser.g:10419:3: rule__ParameterArrayType__DefaultAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__DefaultAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group_4__1__Impl" + + + // $ANTLR start "rule__ParameterList__Group__0" + // InternalRos1Parser.g:10428:1: rule__ParameterList__Group__0 : rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 ; + public final void rule__ParameterList__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10432:1: ( rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 ) + // InternalRos1Parser.g:10433:2: rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 + { + pushFollow(FOLLOW_10); + rule__ParameterList__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterList__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__0" + + + // $ANTLR start "rule__ParameterList__Group__0__Impl" + // InternalRos1Parser.g:10440:1: rule__ParameterList__Group__0__Impl : ( () ) ; + public final void rule__ParameterList__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10444:1: ( ( () ) ) + // InternalRos1Parser.g:10445:1: ( () ) + { + // InternalRos1Parser.g:10445:1: ( () ) + // InternalRos1Parser.g:10446:2: () + { + before(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); + // InternalRos1Parser.g:10447:2: () + // InternalRos1Parser.g:10447:3: + { + } + + after(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__0__Impl" + + + // $ANTLR start "rule__ParameterList__Group__1" + // InternalRos1Parser.g:10455:1: rule__ParameterList__Group__1 : rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 ; + public final void rule__ParameterList__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10459:1: ( rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 ) + // InternalRos1Parser.g:10460:2: rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 + { + pushFollow(FOLLOW_58); + rule__ParameterList__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterList__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__1" + + + // $ANTLR start "rule__ParameterList__Group__1__Impl" + // InternalRos1Parser.g:10467:1: rule__ParameterList__Group__1__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterList__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10471:1: ( ( LeftSquareBracket ) ) + // InternalRos1Parser.g:10472:1: ( LeftSquareBracket ) + { + // InternalRos1Parser.g:10472:1: ( LeftSquareBracket ) + // InternalRos1Parser.g:10473:2: LeftSquareBracket + { + before(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__1__Impl" + + + // $ANTLR start "rule__ParameterList__Group__2" + // InternalRos1Parser.g:10482:1: rule__ParameterList__Group__2 : rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 ; + public final void rule__ParameterList__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10486:1: ( rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 ) + // InternalRos1Parser.g:10487:2: rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 + { + pushFollow(FOLLOW_12); + rule__ParameterList__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterList__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__2" + + + // $ANTLR start "rule__ParameterList__Group__2__Impl" + // InternalRos1Parser.g:10494:1: rule__ParameterList__Group__2__Impl : ( ( rule__ParameterList__ValueAssignment_2 ) ) ; + public final void rule__ParameterList__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10498:1: ( ( ( rule__ParameterList__ValueAssignment_2 ) ) ) + // InternalRos1Parser.g:10499:1: ( ( rule__ParameterList__ValueAssignment_2 ) ) + { + // InternalRos1Parser.g:10499:1: ( ( rule__ParameterList__ValueAssignment_2 ) ) + // InternalRos1Parser.g:10500:2: ( rule__ParameterList__ValueAssignment_2 ) + { + before(grammarAccess.getParameterListAccess().getValueAssignment_2()); + // InternalRos1Parser.g:10501:2: ( rule__ParameterList__ValueAssignment_2 ) + // InternalRos1Parser.g:10501:3: rule__ParameterList__ValueAssignment_2 + { + pushFollow(FOLLOW_2); + rule__ParameterList__ValueAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListAccess().getValueAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__2__Impl" + + + // $ANTLR start "rule__ParameterList__Group__3" + // InternalRos1Parser.g:10509:1: rule__ParameterList__Group__3 : rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 ; + public final void rule__ParameterList__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10513:1: ( rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 ) + // InternalRos1Parser.g:10514:2: rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 + { + pushFollow(FOLLOW_12); + rule__ParameterList__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterList__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__3" + + + // $ANTLR start "rule__ParameterList__Group__3__Impl" + // InternalRos1Parser.g:10521:1: rule__ParameterList__Group__3__Impl : ( ( rule__ParameterList__Group_3__0 )* ) ; + public final void rule__ParameterList__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10525:1: ( ( ( rule__ParameterList__Group_3__0 )* ) ) + // InternalRos1Parser.g:10526:1: ( ( rule__ParameterList__Group_3__0 )* ) + { + // InternalRos1Parser.g:10526:1: ( ( rule__ParameterList__Group_3__0 )* ) + // InternalRos1Parser.g:10527:2: ( rule__ParameterList__Group_3__0 )* + { + before(grammarAccess.getParameterListAccess().getGroup_3()); + // InternalRos1Parser.g:10528:2: ( rule__ParameterList__Group_3__0 )* + loop60: + do { + int alt60=2; + int LA60_0 = input.LA(1); + + if ( (LA60_0==Comma) ) { + alt60=1; + } + + + switch (alt60) { + case 1 : + // InternalRos1Parser.g:10528:3: rule__ParameterList__Group_3__0 + { + pushFollow(FOLLOW_13); + rule__ParameterList__Group_3__0(); + + state._fsp--; + + + } + break; + + default : + break loop60; + } + } while (true); + + after(grammarAccess.getParameterListAccess().getGroup_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__3__Impl" + + + // $ANTLR start "rule__ParameterList__Group__4" + // InternalRos1Parser.g:10536:1: rule__ParameterList__Group__4 : rule__ParameterList__Group__4__Impl ; + public final void rule__ParameterList__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10540:1: ( rule__ParameterList__Group__4__Impl ) + // InternalRos1Parser.g:10541:2: rule__ParameterList__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterList__Group__4__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__4" + + + // $ANTLR start "rule__ParameterList__Group__4__Impl" + // InternalRos1Parser.g:10547:1: rule__ParameterList__Group__4__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterList__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10551:1: ( ( RightSquareBracket ) ) + // InternalRos1Parser.g:10552:1: ( RightSquareBracket ) + { + // InternalRos1Parser.g:10552:1: ( RightSquareBracket ) + // InternalRos1Parser.g:10553:2: RightSquareBracket + { + before(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__4__Impl" + + + // $ANTLR start "rule__ParameterList__Group_3__0" + // InternalRos1Parser.g:10563:1: rule__ParameterList__Group_3__0 : rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 ; + public final void rule__ParameterList__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10567:1: ( rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 ) + // InternalRos1Parser.g:10568:2: rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 + { + pushFollow(FOLLOW_58); + rule__ParameterList__Group_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterList__Group_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group_3__0" + + + // $ANTLR start "rule__ParameterList__Group_3__0__Impl" + // InternalRos1Parser.g:10575:1: rule__ParameterList__Group_3__0__Impl : ( Comma ) ; + public final void rule__ParameterList__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10579:1: ( ( Comma ) ) + // InternalRos1Parser.g:10580:1: ( Comma ) + { + // InternalRos1Parser.g:10580:1: ( Comma ) + // InternalRos1Parser.g:10581:2: Comma + { + before(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group_3__0__Impl" + + + // $ANTLR start "rule__ParameterList__Group_3__1" + // InternalRos1Parser.g:10590:1: rule__ParameterList__Group_3__1 : rule__ParameterList__Group_3__1__Impl ; + public final void rule__ParameterList__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10594:1: ( rule__ParameterList__Group_3__1__Impl ) + // InternalRos1Parser.g:10595:2: rule__ParameterList__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterList__Group_3__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group_3__1" + + + // $ANTLR start "rule__ParameterList__Group_3__1__Impl" + // InternalRos1Parser.g:10601:1: rule__ParameterList__Group_3__1__Impl : ( ( rule__ParameterList__ValueAssignment_3_1 ) ) ; + public final void rule__ParameterList__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10605:1: ( ( ( rule__ParameterList__ValueAssignment_3_1 ) ) ) + // InternalRos1Parser.g:10606:1: ( ( rule__ParameterList__ValueAssignment_3_1 ) ) + { + // InternalRos1Parser.g:10606:1: ( ( rule__ParameterList__ValueAssignment_3_1 ) ) + // InternalRos1Parser.g:10607:2: ( rule__ParameterList__ValueAssignment_3_1 ) + { + before(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); + // InternalRos1Parser.g:10608:2: ( rule__ParameterList__ValueAssignment_3_1 ) + // InternalRos1Parser.g:10608:3: rule__ParameterList__ValueAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__ParameterList__ValueAssignment_3_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group_3__1__Impl" + + + // $ANTLR start "rule__ParameterAny__Group__0" + // InternalRos1Parser.g:10617:1: rule__ParameterAny__Group__0 : rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 ; + public final void rule__ParameterAny__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10621:1: ( rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 ) + // InternalRos1Parser.g:10622:2: rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 + { + pushFollow(FOLLOW_59); + rule__ParameterAny__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterAny__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__0" + + + // $ANTLR start "rule__ParameterAny__Group__0__Impl" + // InternalRos1Parser.g:10629:1: rule__ParameterAny__Group__0__Impl : ( () ) ; + public final void rule__ParameterAny__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10633:1: ( ( () ) ) + // InternalRos1Parser.g:10634:1: ( () ) + { + // InternalRos1Parser.g:10634:1: ( () ) + // InternalRos1Parser.g:10635:2: () + { + before(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); + // InternalRos1Parser.g:10636:2: () + // InternalRos1Parser.g:10636:3: + { + } + + after(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__0__Impl" + + + // $ANTLR start "rule__ParameterAny__Group__1" + // InternalRos1Parser.g:10644:1: rule__ParameterAny__Group__1 : rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 ; + public final void rule__ParameterAny__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10648:1: ( rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 ) + // InternalRos1Parser.g:10649:2: rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 + { + pushFollow(FOLLOW_60); + rule__ParameterAny__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterAny__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__1" + + + // $ANTLR start "rule__ParameterAny__Group__1__Impl" + // InternalRos1Parser.g:10656:1: rule__ParameterAny__Group__1__Impl : ( ParameterAny ) ; + public final void rule__ParameterAny__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10660:1: ( ( ParameterAny ) ) + // InternalRos1Parser.g:10661:1: ( ParameterAny ) + { + // InternalRos1Parser.g:10661:1: ( ParameterAny ) + // InternalRos1Parser.g:10662:2: ParameterAny + { + before(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); + match(input,ParameterAny,FOLLOW_2); + after(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__1__Impl" + + + // $ANTLR start "rule__ParameterAny__Group__2" + // InternalRos1Parser.g:10671:1: rule__ParameterAny__Group__2 : rule__ParameterAny__Group__2__Impl ; + public final void rule__ParameterAny__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10675:1: ( rule__ParameterAny__Group__2__Impl ) + // InternalRos1Parser.g:10676:2: rule__ParameterAny__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterAny__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__2" + + + // $ANTLR start "rule__ParameterAny__Group__2__Impl" + // InternalRos1Parser.g:10682:1: rule__ParameterAny__Group__2__Impl : ( ( rule__ParameterAny__Group_2__0 )? ) ; + public final void rule__ParameterAny__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10686:1: ( ( ( rule__ParameterAny__Group_2__0 )? ) ) + // InternalRos1Parser.g:10687:1: ( ( rule__ParameterAny__Group_2__0 )? ) + { + // InternalRos1Parser.g:10687:1: ( ( rule__ParameterAny__Group_2__0 )? ) + // InternalRos1Parser.g:10688:2: ( rule__ParameterAny__Group_2__0 )? + { + before(grammarAccess.getParameterAnyAccess().getGroup_2()); + // InternalRos1Parser.g:10689:2: ( rule__ParameterAny__Group_2__0 )? + int alt61=2; + int LA61_0 = input.LA(1); + + if ( (LA61_0==Value) ) { + alt61=1; + } + switch (alt61) { + case 1 : + // InternalRos1Parser.g:10689:3: rule__ParameterAny__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterAny__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterAnyAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__2__Impl" + + + // $ANTLR start "rule__ParameterAny__Group_2__0" + // InternalRos1Parser.g:10698:1: rule__ParameterAny__Group_2__0 : rule__ParameterAny__Group_2__0__Impl rule__ParameterAny__Group_2__1 ; + public final void rule__ParameterAny__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10702:1: ( rule__ParameterAny__Group_2__0__Impl rule__ParameterAny__Group_2__1 ) + // InternalRos1Parser.g:10703:2: rule__ParameterAny__Group_2__0__Impl rule__ParameterAny__Group_2__1 + { + pushFollow(FOLLOW_7); + rule__ParameterAny__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterAny__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group_2__0" + + + // $ANTLR start "rule__ParameterAny__Group_2__0__Impl" + // InternalRos1Parser.g:10710:1: rule__ParameterAny__Group_2__0__Impl : ( Value ) ; + public final void rule__ParameterAny__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10714:1: ( ( Value ) ) + // InternalRos1Parser.g:10715:1: ( Value ) + { + // InternalRos1Parser.g:10715:1: ( Value ) + // InternalRos1Parser.g:10716:2: Value + { + before(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); + match(input,Value,FOLLOW_2); + after(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterAny__Group_2__1" + // InternalRos1Parser.g:10725:1: rule__ParameterAny__Group_2__1 : rule__ParameterAny__Group_2__1__Impl ; + public final void rule__ParameterAny__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10729:1: ( rule__ParameterAny__Group_2__1__Impl ) + // InternalRos1Parser.g:10730:2: rule__ParameterAny__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterAny__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group_2__1" + + + // $ANTLR start "rule__ParameterAny__Group_2__1__Impl" + // InternalRos1Parser.g:10736:1: rule__ParameterAny__Group_2__1__Impl : ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) ; + public final void rule__ParameterAny__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10740:1: ( ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) ) + // InternalRos1Parser.g:10741:1: ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) + { + // InternalRos1Parser.g:10741:1: ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) + // InternalRos1Parser.g:10742:2: ( rule__ParameterAny__ValueAssignment_2_1 ) + { + before(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); + // InternalRos1Parser.g:10743:2: ( rule__ParameterAny__ValueAssignment_2_1 ) + // InternalRos1Parser.g:10743:3: rule__ParameterAny__ValueAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterAny__ValueAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group__0" + // InternalRos1Parser.g:10752:1: rule__ParameterStruct__Group__0 : rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 ; + public final void rule__ParameterStruct__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10756:1: ( rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 ) + // InternalRos1Parser.g:10757:2: rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 + { + pushFollow(FOLLOW_58); + rule__ParameterStruct__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group__0" + + + // $ANTLR start "rule__ParameterStruct__Group__0__Impl" + // InternalRos1Parser.g:10764:1: rule__ParameterStruct__Group__0__Impl : ( () ) ; + public final void rule__ParameterStruct__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10768:1: ( ( () ) ) + // InternalRos1Parser.g:10769:1: ( () ) + { + // InternalRos1Parser.g:10769:1: ( () ) + // InternalRos1Parser.g:10770:2: () + { + before(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); + // InternalRos1Parser.g:10771:2: () + // InternalRos1Parser.g:10771:3: + { + } + + after(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group__0__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group__1" + // InternalRos1Parser.g:10779:1: rule__ParameterStruct__Group__1 : rule__ParameterStruct__Group__1__Impl ; + public final void rule__ParameterStruct__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10783:1: ( rule__ParameterStruct__Group__1__Impl ) + // InternalRos1Parser.g:10784:2: rule__ParameterStruct__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group__1" + + + // $ANTLR start "rule__ParameterStruct__Group__1__Impl" + // InternalRos1Parser.g:10790:1: rule__ParameterStruct__Group__1__Impl : ( ( rule__ParameterStruct__Group_1__0 )? ) ; + public final void rule__ParameterStruct__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10794:1: ( ( ( rule__ParameterStruct__Group_1__0 )? ) ) + // InternalRos1Parser.g:10795:1: ( ( rule__ParameterStruct__Group_1__0 )? ) + { + // InternalRos1Parser.g:10795:1: ( ( rule__ParameterStruct__Group_1__0 )? ) + // InternalRos1Parser.g:10796:2: ( rule__ParameterStruct__Group_1__0 )? + { + before(grammarAccess.getParameterStructAccess().getGroup_1()); + // InternalRos1Parser.g:10797:2: ( rule__ParameterStruct__Group_1__0 )? + int alt62=2; + int LA62_0 = input.LA(1); + + if ( (LA62_0==LeftSquareBracket) ) { + alt62=1; + } + switch (alt62) { + case 1 : + // InternalRos1Parser.g:10797:3: rule__ParameterStruct__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterStructAccess().getGroup_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group__1__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1__0" + // InternalRos1Parser.g:10806:1: rule__ParameterStruct__Group_1__0 : rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 ; + public final void rule__ParameterStruct__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10810:1: ( rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 ) + // InternalRos1Parser.g:10811:2: rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 + { + pushFollow(FOLLOW_61); + rule__ParameterStruct__Group_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__0" + + + // $ANTLR start "rule__ParameterStruct__Group_1__0__Impl" + // InternalRos1Parser.g:10818:1: rule__ParameterStruct__Group_1__0__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterStruct__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10822:1: ( ( LeftSquareBracket ) ) + // InternalRos1Parser.g:10823:1: ( LeftSquareBracket ) + { + // InternalRos1Parser.g:10823:1: ( LeftSquareBracket ) + // InternalRos1Parser.g:10824:2: LeftSquareBracket + { + before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__0__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1__1" + // InternalRos1Parser.g:10833:1: rule__ParameterStruct__Group_1__1 : rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 ; + public final void rule__ParameterStruct__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10837:1: ( rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 ) + // InternalRos1Parser.g:10838:2: rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 + { + pushFollow(FOLLOW_12); + rule__ParameterStruct__Group_1__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__1" + + + // $ANTLR start "rule__ParameterStruct__Group_1__1__Impl" + // InternalRos1Parser.g:10845:1: rule__ParameterStruct__Group_1__1__Impl : ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) ; + public final void rule__ParameterStruct__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10849:1: ( ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) ) + // InternalRos1Parser.g:10850:1: ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) + { + // InternalRos1Parser.g:10850:1: ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) + // InternalRos1Parser.g:10851:2: ( rule__ParameterStruct__ValueAssignment_1_1 ) + { + before(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); + // InternalRos1Parser.g:10852:2: ( rule__ParameterStruct__ValueAssignment_1_1 ) + // InternalRos1Parser.g:10852:3: rule__ParameterStruct__ValueAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__ValueAssignment_1_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__1__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1__2" + // InternalRos1Parser.g:10860:1: rule__ParameterStruct__Group_1__2 : rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 ; + public final void rule__ParameterStruct__Group_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10864:1: ( rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 ) + // InternalRos1Parser.g:10865:2: rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 + { + pushFollow(FOLLOW_12); + rule__ParameterStruct__Group_1__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__2" + + + // $ANTLR start "rule__ParameterStruct__Group_1__2__Impl" + // InternalRos1Parser.g:10872:1: rule__ParameterStruct__Group_1__2__Impl : ( ( rule__ParameterStruct__Group_1_2__0 )* ) ; + public final void rule__ParameterStruct__Group_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10876:1: ( ( ( rule__ParameterStruct__Group_1_2__0 )* ) ) + // InternalRos1Parser.g:10877:1: ( ( rule__ParameterStruct__Group_1_2__0 )* ) + { + // InternalRos1Parser.g:10877:1: ( ( rule__ParameterStruct__Group_1_2__0 )* ) + // InternalRos1Parser.g:10878:2: ( rule__ParameterStruct__Group_1_2__0 )* + { + before(grammarAccess.getParameterStructAccess().getGroup_1_2()); + // InternalRos1Parser.g:10879:2: ( rule__ParameterStruct__Group_1_2__0 )* + loop63: + do { + int alt63=2; + int LA63_0 = input.LA(1); + + if ( (LA63_0==Comma) ) { + alt63=1; + } + + + switch (alt63) { + case 1 : + // InternalRos1Parser.g:10879:3: rule__ParameterStruct__Group_1_2__0 + { + pushFollow(FOLLOW_13); + rule__ParameterStruct__Group_1_2__0(); + + state._fsp--; + + + } + break; + + default : + break loop63; + } + } while (true); + + after(grammarAccess.getParameterStructAccess().getGroup_1_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__2__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1__3" + // InternalRos1Parser.g:10887:1: rule__ParameterStruct__Group_1__3 : rule__ParameterStruct__Group_1__3__Impl ; + public final void rule__ParameterStruct__Group_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10891:1: ( rule__ParameterStruct__Group_1__3__Impl ) + // InternalRos1Parser.g:10892:2: rule__ParameterStruct__Group_1__3__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__3" + + + // $ANTLR start "rule__ParameterStruct__Group_1__3__Impl" + // InternalRos1Parser.g:10898:1: rule__ParameterStruct__Group_1__3__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterStruct__Group_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10902:1: ( ( RightSquareBracket ) ) + // InternalRos1Parser.g:10903:1: ( RightSquareBracket ) + { + // InternalRos1Parser.g:10903:1: ( RightSquareBracket ) + // InternalRos1Parser.g:10904:2: RightSquareBracket + { + before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__3__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__0" + // InternalRos1Parser.g:10914:1: rule__ParameterStruct__Group_1_2__0 : rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 ; + public final void rule__ParameterStruct__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10918:1: ( rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 ) + // InternalRos1Parser.g:10919:2: rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 + { + pushFollow(FOLLOW_10); + rule__ParameterStruct__Group_1_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__0" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__0__Impl" + // InternalRos1Parser.g:10926:1: rule__ParameterStruct__Group_1_2__0__Impl : ( Comma ) ; + public final void rule__ParameterStruct__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10930:1: ( ( Comma ) ) + // InternalRos1Parser.g:10931:1: ( Comma ) + { + // InternalRos1Parser.g:10931:1: ( Comma ) + // InternalRos1Parser.g:10932:2: Comma + { + before(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__0__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__1" + // InternalRos1Parser.g:10941:1: rule__ParameterStruct__Group_1_2__1 : rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 ; + public final void rule__ParameterStruct__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10945:1: ( rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 ) + // InternalRos1Parser.g:10946:2: rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 + { + pushFollow(FOLLOW_61); + rule__ParameterStruct__Group_1_2__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1_2__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__1" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__1__Impl" + // InternalRos1Parser.g:10953:1: rule__ParameterStruct__Group_1_2__1__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterStruct__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10957:1: ( ( LeftSquareBracket ) ) + // InternalRos1Parser.g:10958:1: ( LeftSquareBracket ) + { + // InternalRos1Parser.g:10958:1: ( LeftSquareBracket ) + // InternalRos1Parser.g:10959:2: LeftSquareBracket + { + before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__1__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__2" + // InternalRos1Parser.g:10968:1: rule__ParameterStruct__Group_1_2__2 : rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 ; + public final void rule__ParameterStruct__Group_1_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10972:1: ( rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 ) + // InternalRos1Parser.g:10973:2: rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 + { + pushFollow(FOLLOW_62); + rule__ParameterStruct__Group_1_2__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1_2__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__2" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__2__Impl" + // InternalRos1Parser.g:10980:1: rule__ParameterStruct__Group_1_2__2__Impl : ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) ; + public final void rule__ParameterStruct__Group_1_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10984:1: ( ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) ) + // InternalRos1Parser.g:10985:1: ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) + { + // InternalRos1Parser.g:10985:1: ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) + // InternalRos1Parser.g:10986:2: ( rule__ParameterStruct__ValueAssignment_1_2_2 ) + { + before(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); + // InternalRos1Parser.g:10987:2: ( rule__ParameterStruct__ValueAssignment_1_2_2 ) + // InternalRos1Parser.g:10987:3: rule__ParameterStruct__ValueAssignment_1_2_2 + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__ValueAssignment_1_2_2(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__2__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__3" + // InternalRos1Parser.g:10995:1: rule__ParameterStruct__Group_1_2__3 : rule__ParameterStruct__Group_1_2__3__Impl ; + public final void rule__ParameterStruct__Group_1_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:10999:1: ( rule__ParameterStruct__Group_1_2__3__Impl ) + // InternalRos1Parser.g:11000:2: rule__ParameterStruct__Group_1_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1_2__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__3" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__3__Impl" + // InternalRos1Parser.g:11006:1: rule__ParameterStruct__Group_1_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterStruct__Group_1_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11010:1: ( ( RightSquareBracket ) ) + // InternalRos1Parser.g:11011:1: ( RightSquareBracket ) + { + // InternalRos1Parser.g:11011:1: ( RightSquareBracket ) + // InternalRos1Parser.g:11012:2: RightSquareBracket + { + before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__3__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__0" + // InternalRos1Parser.g:11022:1: rule__ParameterStructMember__Group__0 : rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 ; + public final void rule__ParameterStructMember__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11026:1: ( rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 ) + // InternalRos1Parser.g:11027:2: rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 + { + pushFollow(FOLLOW_7); + rule__ParameterStructMember__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__0" + + + // $ANTLR start "rule__ParameterStructMember__Group__0__Impl" + // InternalRos1Parser.g:11034:1: rule__ParameterStructMember__Group__0__Impl : ( ParameterStructMember ) ; + public final void rule__ParameterStructMember__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11038:1: ( ( ParameterStructMember ) ) + // InternalRos1Parser.g:11039:1: ( ParameterStructMember ) + { + // InternalRos1Parser.g:11039:1: ( ParameterStructMember ) + // InternalRos1Parser.g:11040:2: ParameterStructMember + { + before(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); + match(input,ParameterStructMember,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__0__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__1" + // InternalRos1Parser.g:11049:1: rule__ParameterStructMember__Group__1 : rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 ; + public final void rule__ParameterStructMember__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11053:1: ( rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 ) + // InternalRos1Parser.g:11054:2: rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 + { + pushFollow(FOLLOW_4); + rule__ParameterStructMember__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__1" + + + // $ANTLR start "rule__ParameterStructMember__Group__1__Impl" + // InternalRos1Parser.g:11061:1: rule__ParameterStructMember__Group__1__Impl : ( ( rule__ParameterStructMember__NameAssignment_1 ) ) ; + public final void rule__ParameterStructMember__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11065:1: ( ( ( rule__ParameterStructMember__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:11066:1: ( ( rule__ParameterStructMember__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:11066:1: ( ( rule__ParameterStructMember__NameAssignment_1 ) ) + // InternalRos1Parser.g:11067:2: ( rule__ParameterStructMember__NameAssignment_1 ) + { + before(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); + // InternalRos1Parser.g:11068:2: ( rule__ParameterStructMember__NameAssignment_1 ) + // InternalRos1Parser.g:11068:3: rule__ParameterStructMember__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStructMember__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__1__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__2" + // InternalRos1Parser.g:11076:1: rule__ParameterStructMember__Group__2 : rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 ; + public final void rule__ParameterStructMember__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11080:1: ( rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 ) + // InternalRos1Parser.g:11081:2: rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 + { + pushFollow(FOLLOW_5); + rule__ParameterStructMember__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__2" + + + // $ANTLR start "rule__ParameterStructMember__Group__2__Impl" + // InternalRos1Parser.g:11088:1: rule__ParameterStructMember__Group__2__Impl : ( Colon ) ; + public final void rule__ParameterStructMember__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11092:1: ( ( Colon ) ) + // InternalRos1Parser.g:11093:1: ( Colon ) + { + // InternalRos1Parser.g:11093:1: ( Colon ) + // InternalRos1Parser.g:11094:2: Colon + { + before(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__2__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__3" + // InternalRos1Parser.g:11103:1: rule__ParameterStructMember__Group__3 : rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 ; + public final void rule__ParameterStructMember__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11107:1: ( rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 ) + // InternalRos1Parser.g:11108:2: rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 + { + pushFollow(FOLLOW_58); + rule__ParameterStructMember__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__3" + + + // $ANTLR start "rule__ParameterStructMember__Group__3__Impl" + // InternalRos1Parser.g:11115:1: rule__ParameterStructMember__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ParameterStructMember__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11119:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:11120:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:11120:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:11121:2: RULE_BEGIN + { + before(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__3__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__4" + // InternalRos1Parser.g:11130:1: rule__ParameterStructMember__Group__4 : rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 ; + public final void rule__ParameterStructMember__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11134:1: ( rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 ) + // InternalRos1Parser.g:11135:2: rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 + { + pushFollow(FOLLOW_27); + rule__ParameterStructMember__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__4" + + + // $ANTLR start "rule__ParameterStructMember__Group__4__Impl" + // InternalRos1Parser.g:11142:1: rule__ParameterStructMember__Group__4__Impl : ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) ; + public final void rule__ParameterStructMember__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11146:1: ( ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) ) + // InternalRos1Parser.g:11147:1: ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) + { + // InternalRos1Parser.g:11147:1: ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) + // InternalRos1Parser.g:11148:2: ( rule__ParameterStructMember__ValueAssignment_4 ) + { + before(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); + // InternalRos1Parser.g:11149:2: ( rule__ParameterStructMember__ValueAssignment_4 ) + // InternalRos1Parser.g:11149:3: rule__ParameterStructMember__ValueAssignment_4 + { + pushFollow(FOLLOW_2); + rule__ParameterStructMember__ValueAssignment_4(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__4__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__5" + // InternalRos1Parser.g:11157:1: rule__ParameterStructMember__Group__5 : rule__ParameterStructMember__Group__5__Impl ; + public final void rule__ParameterStructMember__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11161:1: ( rule__ParameterStructMember__Group__5__Impl ) + // InternalRos1Parser.g:11162:2: rule__ParameterStructMember__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__5__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__5" + + + // $ANTLR start "rule__ParameterStructMember__Group__5__Impl" + // InternalRos1Parser.g:11168:1: rule__ParameterStructMember__Group__5__Impl : ( RULE_END ) ; + public final void rule__ParameterStructMember__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11172:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:11173:1: ( RULE_END ) + { + // InternalRos1Parser.g:11173:1: ( RULE_END ) + // InternalRos1Parser.g:11174:2: RULE_END + { + before(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__5__Impl" + + + // $ANTLR start "rule__ParameterStructTypeMember__Group__0" + // InternalRos1Parser.g:11184:1: rule__ParameterStructTypeMember__Group__0 : rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 ; + public final void rule__ParameterStructTypeMember__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11188:1: ( rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 ) + // InternalRos1Parser.g:11189:2: rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 + { + pushFollow(FOLLOW_43); + rule__ParameterStructTypeMember__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__Group__0" + + + // $ANTLR start "rule__ParameterStructTypeMember__Group__0__Impl" + // InternalRos1Parser.g:11196:1: rule__ParameterStructTypeMember__Group__0__Impl : ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) ; + public final void rule__ParameterStructTypeMember__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11200:1: ( ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) ) + // InternalRos1Parser.g:11201:1: ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) + { + // InternalRos1Parser.g:11201:1: ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) + // InternalRos1Parser.g:11202:2: ( rule__ParameterStructTypeMember__NameAssignment_0 ) + { + before(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); + // InternalRos1Parser.g:11203:2: ( rule__ParameterStructTypeMember__NameAssignment_0 ) + // InternalRos1Parser.g:11203:3: rule__ParameterStructTypeMember__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__NameAssignment_0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__Group__0__Impl" + + + // $ANTLR start "rule__ParameterStructTypeMember__Group__1" + // InternalRos1Parser.g:11211:1: rule__ParameterStructTypeMember__Group__1 : rule__ParameterStructTypeMember__Group__1__Impl ; + public final void rule__ParameterStructTypeMember__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11215:1: ( rule__ParameterStructTypeMember__Group__1__Impl ) + // InternalRos1Parser.g:11216:2: rule__ParameterStructTypeMember__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__Group__1" + + + // $ANTLR start "rule__ParameterStructTypeMember__Group__1__Impl" + // InternalRos1Parser.g:11222:1: rule__ParameterStructTypeMember__Group__1__Impl : ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) ; + public final void rule__ParameterStructTypeMember__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11226:1: ( ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) ) + // InternalRos1Parser.g:11227:1: ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) + { + // InternalRos1Parser.g:11227:1: ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) + // InternalRos1Parser.g:11228:2: ( rule__ParameterStructTypeMember__TypeAssignment_1 ) + { + before(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); + // InternalRos1Parser.g:11229:2: ( rule__ParameterStructTypeMember__TypeAssignment_1 ) + // InternalRos1Parser.g:11229:3: rule__ParameterStructTypeMember__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__TypeAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__Group__1__Impl" + + + // $ANTLR start "rule__MessagePart__Group__0" + // InternalRos1Parser.g:11238:1: rule__MessagePart__Group__0 : rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 ; + public final void rule__MessagePart__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11242:1: ( rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 ) + // InternalRos1Parser.g:11243:2: rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 + { + pushFollow(FOLLOW_63); + rule__MessagePart__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__MessagePart__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__Group__0" + + + // $ANTLR start "rule__MessagePart__Group__0__Impl" + // InternalRos1Parser.g:11250:1: rule__MessagePart__Group__0__Impl : ( ( rule__MessagePart__TypeAssignment_0 ) ) ; + public final void rule__MessagePart__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11254:1: ( ( ( rule__MessagePart__TypeAssignment_0 ) ) ) + // InternalRos1Parser.g:11255:1: ( ( rule__MessagePart__TypeAssignment_0 ) ) + { + // InternalRos1Parser.g:11255:1: ( ( rule__MessagePart__TypeAssignment_0 ) ) + // InternalRos1Parser.g:11256:2: ( rule__MessagePart__TypeAssignment_0 ) + { + before(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); + // InternalRos1Parser.g:11257:2: ( rule__MessagePart__TypeAssignment_0 ) + // InternalRos1Parser.g:11257:3: rule__MessagePart__TypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__MessagePart__TypeAssignment_0(); + + state._fsp--; + + + } + + after(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__Group__0__Impl" + + + // $ANTLR start "rule__MessagePart__Group__1" + // InternalRos1Parser.g:11265:1: rule__MessagePart__Group__1 : rule__MessagePart__Group__1__Impl ; + public final void rule__MessagePart__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11269:1: ( rule__MessagePart__Group__1__Impl ) + // InternalRos1Parser.g:11270:2: rule__MessagePart__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__MessagePart__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__Group__1" + + + // $ANTLR start "rule__MessagePart__Group__1__Impl" + // InternalRos1Parser.g:11276:1: rule__MessagePart__Group__1__Impl : ( ( rule__MessagePart__DataAssignment_1 ) ) ; + public final void rule__MessagePart__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11280:1: ( ( ( rule__MessagePart__DataAssignment_1 ) ) ) + // InternalRos1Parser.g:11281:1: ( ( rule__MessagePart__DataAssignment_1 ) ) + { + // InternalRos1Parser.g:11281:1: ( ( rule__MessagePart__DataAssignment_1 ) ) + // InternalRos1Parser.g:11282:2: ( rule__MessagePart__DataAssignment_1 ) + { + before(grammarAccess.getMessagePartAccess().getDataAssignment_1()); + // InternalRos1Parser.g:11283:2: ( rule__MessagePart__DataAssignment_1 ) + // InternalRos1Parser.g:11283:3: rule__MessagePart__DataAssignment_1 + { + pushFollow(FOLLOW_2); + rule__MessagePart__DataAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getMessagePartAccess().getDataAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__Group__1__Impl" + + + // $ANTLR start "rule__Bool__Group__0" + // InternalRos1Parser.g:11292:1: rule__Bool__Group__0 : rule__Bool__Group__0__Impl rule__Bool__Group__1 ; + public final void rule__Bool__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11296:1: ( rule__Bool__Group__0__Impl rule__Bool__Group__1 ) + // InternalRos1Parser.g:11297:2: rule__Bool__Group__0__Impl rule__Bool__Group__1 + { + pushFollow(FOLLOW_64); + rule__Bool__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Bool__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Bool__Group__0" + + + // $ANTLR start "rule__Bool__Group__0__Impl" + // InternalRos1Parser.g:11304:1: rule__Bool__Group__0__Impl : ( () ) ; + public final void rule__Bool__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11308:1: ( ( () ) ) + // InternalRos1Parser.g:11309:1: ( () ) + { + // InternalRos1Parser.g:11309:1: ( () ) + // InternalRos1Parser.g:11310:2: () + { + before(grammarAccess.getBoolAccess().getBoolAction_0()); + // InternalRos1Parser.g:11311:2: () + // InternalRos1Parser.g:11311:3: + { + } + + after(grammarAccess.getBoolAccess().getBoolAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Bool__Group__0__Impl" + + + // $ANTLR start "rule__Bool__Group__1" + // InternalRos1Parser.g:11319:1: rule__Bool__Group__1 : rule__Bool__Group__1__Impl ; + public final void rule__Bool__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11323:1: ( rule__Bool__Group__1__Impl ) + // InternalRos1Parser.g:11324:2: rule__Bool__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Bool__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Bool__Group__1" + + + // $ANTLR start "rule__Bool__Group__1__Impl" + // InternalRos1Parser.g:11330:1: rule__Bool__Group__1__Impl : ( Bool ) ; + public final void rule__Bool__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11334:1: ( ( Bool ) ) + // InternalRos1Parser.g:11335:1: ( Bool ) + { + // InternalRos1Parser.g:11335:1: ( Bool ) + // InternalRos1Parser.g:11336:2: Bool + { + before(grammarAccess.getBoolAccess().getBoolKeyword_1()); + match(input,Bool,FOLLOW_2); + after(grammarAccess.getBoolAccess().getBoolKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Bool__Group__1__Impl" + + + // $ANTLR start "rule__Int8__Group__0" + // InternalRos1Parser.g:11346:1: rule__Int8__Group__0 : rule__Int8__Group__0__Impl rule__Int8__Group__1 ; + public final void rule__Int8__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11350:1: ( rule__Int8__Group__0__Impl rule__Int8__Group__1 ) + // InternalRos1Parser.g:11351:2: rule__Int8__Group__0__Impl rule__Int8__Group__1 + { + pushFollow(FOLLOW_65); + rule__Int8__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int8__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8__Group__0" + + + // $ANTLR start "rule__Int8__Group__0__Impl" + // InternalRos1Parser.g:11358:1: rule__Int8__Group__0__Impl : ( () ) ; + public final void rule__Int8__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11362:1: ( ( () ) ) + // InternalRos1Parser.g:11363:1: ( () ) + { + // InternalRos1Parser.g:11363:1: ( () ) + // InternalRos1Parser.g:11364:2: () + { + before(grammarAccess.getInt8Access().getInt8Action_0()); + // InternalRos1Parser.g:11365:2: () + // InternalRos1Parser.g:11365:3: + { + } + + after(grammarAccess.getInt8Access().getInt8Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8__Group__0__Impl" + + + // $ANTLR start "rule__Int8__Group__1" + // InternalRos1Parser.g:11373:1: rule__Int8__Group__1 : rule__Int8__Group__1__Impl ; + public final void rule__Int8__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11377:1: ( rule__Int8__Group__1__Impl ) + // InternalRos1Parser.g:11378:2: rule__Int8__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int8__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8__Group__1" + + + // $ANTLR start "rule__Int8__Group__1__Impl" + // InternalRos1Parser.g:11384:1: rule__Int8__Group__1__Impl : ( Int8 ) ; + public final void rule__Int8__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11388:1: ( ( Int8 ) ) + // InternalRos1Parser.g:11389:1: ( Int8 ) + { + // InternalRos1Parser.g:11389:1: ( Int8 ) + // InternalRos1Parser.g:11390:2: Int8 + { + before(grammarAccess.getInt8Access().getInt8Keyword_1()); + match(input,Int8,FOLLOW_2); + after(grammarAccess.getInt8Access().getInt8Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8__Group__1__Impl" + + + // $ANTLR start "rule__Uint8__Group__0" + // InternalRos1Parser.g:11400:1: rule__Uint8__Group__0 : rule__Uint8__Group__0__Impl rule__Uint8__Group__1 ; + public final void rule__Uint8__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11404:1: ( rule__Uint8__Group__0__Impl rule__Uint8__Group__1 ) + // InternalRos1Parser.g:11405:2: rule__Uint8__Group__0__Impl rule__Uint8__Group__1 + { + pushFollow(FOLLOW_66); + rule__Uint8__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint8__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8__Group__0" + + + // $ANTLR start "rule__Uint8__Group__0__Impl" + // InternalRos1Parser.g:11412:1: rule__Uint8__Group__0__Impl : ( () ) ; + public final void rule__Uint8__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11416:1: ( ( () ) ) + // InternalRos1Parser.g:11417:1: ( () ) + { + // InternalRos1Parser.g:11417:1: ( () ) + // InternalRos1Parser.g:11418:2: () + { + before(grammarAccess.getUint8Access().getUint8Action_0()); + // InternalRos1Parser.g:11419:2: () + // InternalRos1Parser.g:11419:3: + { + } + + after(grammarAccess.getUint8Access().getUint8Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8__Group__0__Impl" + + + // $ANTLR start "rule__Uint8__Group__1" + // InternalRos1Parser.g:11427:1: rule__Uint8__Group__1 : rule__Uint8__Group__1__Impl ; + public final void rule__Uint8__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11431:1: ( rule__Uint8__Group__1__Impl ) + // InternalRos1Parser.g:11432:2: rule__Uint8__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint8__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8__Group__1" + + + // $ANTLR start "rule__Uint8__Group__1__Impl" + // InternalRos1Parser.g:11438:1: rule__Uint8__Group__1__Impl : ( Uint8 ) ; + public final void rule__Uint8__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11442:1: ( ( Uint8 ) ) + // InternalRos1Parser.g:11443:1: ( Uint8 ) + { + // InternalRos1Parser.g:11443:1: ( Uint8 ) + // InternalRos1Parser.g:11444:2: Uint8 + { + before(grammarAccess.getUint8Access().getUint8Keyword_1()); + match(input,Uint8,FOLLOW_2); + after(grammarAccess.getUint8Access().getUint8Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8__Group__1__Impl" + + + // $ANTLR start "rule__Int16__Group__0" + // InternalRos1Parser.g:11454:1: rule__Int16__Group__0 : rule__Int16__Group__0__Impl rule__Int16__Group__1 ; + public final void rule__Int16__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11458:1: ( rule__Int16__Group__0__Impl rule__Int16__Group__1 ) + // InternalRos1Parser.g:11459:2: rule__Int16__Group__0__Impl rule__Int16__Group__1 + { + pushFollow(FOLLOW_67); + rule__Int16__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int16__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16__Group__0" + + + // $ANTLR start "rule__Int16__Group__0__Impl" + // InternalRos1Parser.g:11466:1: rule__Int16__Group__0__Impl : ( () ) ; + public final void rule__Int16__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11470:1: ( ( () ) ) + // InternalRos1Parser.g:11471:1: ( () ) + { + // InternalRos1Parser.g:11471:1: ( () ) + // InternalRos1Parser.g:11472:2: () + { + before(grammarAccess.getInt16Access().getInt16Action_0()); + // InternalRos1Parser.g:11473:2: () + // InternalRos1Parser.g:11473:3: + { + } + + after(grammarAccess.getInt16Access().getInt16Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16__Group__0__Impl" + + + // $ANTLR start "rule__Int16__Group__1" + // InternalRos1Parser.g:11481:1: rule__Int16__Group__1 : rule__Int16__Group__1__Impl ; + public final void rule__Int16__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11485:1: ( rule__Int16__Group__1__Impl ) + // InternalRos1Parser.g:11486:2: rule__Int16__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int16__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16__Group__1" + + + // $ANTLR start "rule__Int16__Group__1__Impl" + // InternalRos1Parser.g:11492:1: rule__Int16__Group__1__Impl : ( Int16 ) ; + public final void rule__Int16__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11496:1: ( ( Int16 ) ) + // InternalRos1Parser.g:11497:1: ( Int16 ) + { + // InternalRos1Parser.g:11497:1: ( Int16 ) + // InternalRos1Parser.g:11498:2: Int16 + { + before(grammarAccess.getInt16Access().getInt16Keyword_1()); + match(input,Int16,FOLLOW_2); + after(grammarAccess.getInt16Access().getInt16Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16__Group__1__Impl" + + + // $ANTLR start "rule__Uint16__Group__0" + // InternalRos1Parser.g:11508:1: rule__Uint16__Group__0 : rule__Uint16__Group__0__Impl rule__Uint16__Group__1 ; + public final void rule__Uint16__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11512:1: ( rule__Uint16__Group__0__Impl rule__Uint16__Group__1 ) + // InternalRos1Parser.g:11513:2: rule__Uint16__Group__0__Impl rule__Uint16__Group__1 + { + pushFollow(FOLLOW_68); + rule__Uint16__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint16__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16__Group__0" + + + // $ANTLR start "rule__Uint16__Group__0__Impl" + // InternalRos1Parser.g:11520:1: rule__Uint16__Group__0__Impl : ( () ) ; + public final void rule__Uint16__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11524:1: ( ( () ) ) + // InternalRos1Parser.g:11525:1: ( () ) + { + // InternalRos1Parser.g:11525:1: ( () ) + // InternalRos1Parser.g:11526:2: () + { + before(grammarAccess.getUint16Access().getUint16Action_0()); + // InternalRos1Parser.g:11527:2: () + // InternalRos1Parser.g:11527:3: + { + } + + after(grammarAccess.getUint16Access().getUint16Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16__Group__0__Impl" + + + // $ANTLR start "rule__Uint16__Group__1" + // InternalRos1Parser.g:11535:1: rule__Uint16__Group__1 : rule__Uint16__Group__1__Impl ; + public final void rule__Uint16__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11539:1: ( rule__Uint16__Group__1__Impl ) + // InternalRos1Parser.g:11540:2: rule__Uint16__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint16__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16__Group__1" + + + // $ANTLR start "rule__Uint16__Group__1__Impl" + // InternalRos1Parser.g:11546:1: rule__Uint16__Group__1__Impl : ( Uint16 ) ; + public final void rule__Uint16__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11550:1: ( ( Uint16 ) ) + // InternalRos1Parser.g:11551:1: ( Uint16 ) + { + // InternalRos1Parser.g:11551:1: ( Uint16 ) + // InternalRos1Parser.g:11552:2: Uint16 + { + before(grammarAccess.getUint16Access().getUint16Keyword_1()); + match(input,Uint16,FOLLOW_2); + after(grammarAccess.getUint16Access().getUint16Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16__Group__1__Impl" + + + // $ANTLR start "rule__Int32__Group__0" + // InternalRos1Parser.g:11562:1: rule__Int32__Group__0 : rule__Int32__Group__0__Impl rule__Int32__Group__1 ; + public final void rule__Int32__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11566:1: ( rule__Int32__Group__0__Impl rule__Int32__Group__1 ) + // InternalRos1Parser.g:11567:2: rule__Int32__Group__0__Impl rule__Int32__Group__1 + { + pushFollow(FOLLOW_69); + rule__Int32__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int32__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32__Group__0" + + + // $ANTLR start "rule__Int32__Group__0__Impl" + // InternalRos1Parser.g:11574:1: rule__Int32__Group__0__Impl : ( () ) ; + public final void rule__Int32__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11578:1: ( ( () ) ) + // InternalRos1Parser.g:11579:1: ( () ) + { + // InternalRos1Parser.g:11579:1: ( () ) + // InternalRos1Parser.g:11580:2: () + { + before(grammarAccess.getInt32Access().getInt32Action_0()); + // InternalRos1Parser.g:11581:2: () + // InternalRos1Parser.g:11581:3: + { + } + + after(grammarAccess.getInt32Access().getInt32Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32__Group__0__Impl" + + + // $ANTLR start "rule__Int32__Group__1" + // InternalRos1Parser.g:11589:1: rule__Int32__Group__1 : rule__Int32__Group__1__Impl ; + public final void rule__Int32__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11593:1: ( rule__Int32__Group__1__Impl ) + // InternalRos1Parser.g:11594:2: rule__Int32__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int32__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32__Group__1" + + + // $ANTLR start "rule__Int32__Group__1__Impl" + // InternalRos1Parser.g:11600:1: rule__Int32__Group__1__Impl : ( Int32 ) ; + public final void rule__Int32__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11604:1: ( ( Int32 ) ) + // InternalRos1Parser.g:11605:1: ( Int32 ) + { + // InternalRos1Parser.g:11605:1: ( Int32 ) + // InternalRos1Parser.g:11606:2: Int32 + { + before(grammarAccess.getInt32Access().getInt32Keyword_1()); + match(input,Int32,FOLLOW_2); + after(grammarAccess.getInt32Access().getInt32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32__Group__1__Impl" + + + // $ANTLR start "rule__Uint32__Group__0" + // InternalRos1Parser.g:11616:1: rule__Uint32__Group__0 : rule__Uint32__Group__0__Impl rule__Uint32__Group__1 ; + public final void rule__Uint32__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11620:1: ( rule__Uint32__Group__0__Impl rule__Uint32__Group__1 ) + // InternalRos1Parser.g:11621:2: rule__Uint32__Group__0__Impl rule__Uint32__Group__1 + { + pushFollow(FOLLOW_70); + rule__Uint32__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint32__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32__Group__0" + + + // $ANTLR start "rule__Uint32__Group__0__Impl" + // InternalRos1Parser.g:11628:1: rule__Uint32__Group__0__Impl : ( () ) ; + public final void rule__Uint32__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11632:1: ( ( () ) ) + // InternalRos1Parser.g:11633:1: ( () ) + { + // InternalRos1Parser.g:11633:1: ( () ) + // InternalRos1Parser.g:11634:2: () + { + before(grammarAccess.getUint32Access().getUint32Action_0()); + // InternalRos1Parser.g:11635:2: () + // InternalRos1Parser.g:11635:3: + { + } + + after(grammarAccess.getUint32Access().getUint32Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32__Group__0__Impl" + + + // $ANTLR start "rule__Uint32__Group__1" + // InternalRos1Parser.g:11643:1: rule__Uint32__Group__1 : rule__Uint32__Group__1__Impl ; + public final void rule__Uint32__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11647:1: ( rule__Uint32__Group__1__Impl ) + // InternalRos1Parser.g:11648:2: rule__Uint32__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint32__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32__Group__1" + + + // $ANTLR start "rule__Uint32__Group__1__Impl" + // InternalRos1Parser.g:11654:1: rule__Uint32__Group__1__Impl : ( Uint32 ) ; + public final void rule__Uint32__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11658:1: ( ( Uint32 ) ) + // InternalRos1Parser.g:11659:1: ( Uint32 ) + { + // InternalRos1Parser.g:11659:1: ( Uint32 ) + // InternalRos1Parser.g:11660:2: Uint32 + { + before(grammarAccess.getUint32Access().getUint32Keyword_1()); + match(input,Uint32,FOLLOW_2); + after(grammarAccess.getUint32Access().getUint32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32__Group__1__Impl" + + + // $ANTLR start "rule__Int64__Group__0" + // InternalRos1Parser.g:11670:1: rule__Int64__Group__0 : rule__Int64__Group__0__Impl rule__Int64__Group__1 ; + public final void rule__Int64__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11674:1: ( rule__Int64__Group__0__Impl rule__Int64__Group__1 ) + // InternalRos1Parser.g:11675:2: rule__Int64__Group__0__Impl rule__Int64__Group__1 + { + pushFollow(FOLLOW_71); + rule__Int64__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int64__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64__Group__0" + + + // $ANTLR start "rule__Int64__Group__0__Impl" + // InternalRos1Parser.g:11682:1: rule__Int64__Group__0__Impl : ( () ) ; + public final void rule__Int64__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11686:1: ( ( () ) ) + // InternalRos1Parser.g:11687:1: ( () ) + { + // InternalRos1Parser.g:11687:1: ( () ) + // InternalRos1Parser.g:11688:2: () + { + before(grammarAccess.getInt64Access().getInt64Action_0()); + // InternalRos1Parser.g:11689:2: () + // InternalRos1Parser.g:11689:3: + { + } + + after(grammarAccess.getInt64Access().getInt64Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64__Group__0__Impl" + + + // $ANTLR start "rule__Int64__Group__1" + // InternalRos1Parser.g:11697:1: rule__Int64__Group__1 : rule__Int64__Group__1__Impl ; + public final void rule__Int64__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11701:1: ( rule__Int64__Group__1__Impl ) + // InternalRos1Parser.g:11702:2: rule__Int64__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int64__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64__Group__1" + + + // $ANTLR start "rule__Int64__Group__1__Impl" + // InternalRos1Parser.g:11708:1: rule__Int64__Group__1__Impl : ( Int64 ) ; + public final void rule__Int64__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11712:1: ( ( Int64 ) ) + // InternalRos1Parser.g:11713:1: ( Int64 ) + { + // InternalRos1Parser.g:11713:1: ( Int64 ) + // InternalRos1Parser.g:11714:2: Int64 + { + before(grammarAccess.getInt64Access().getInt64Keyword_1()); + match(input,Int64,FOLLOW_2); + after(grammarAccess.getInt64Access().getInt64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64__Group__1__Impl" + + + // $ANTLR start "rule__Uint64__Group__0" + // InternalRos1Parser.g:11724:1: rule__Uint64__Group__0 : rule__Uint64__Group__0__Impl rule__Uint64__Group__1 ; + public final void rule__Uint64__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11728:1: ( rule__Uint64__Group__0__Impl rule__Uint64__Group__1 ) + // InternalRos1Parser.g:11729:2: rule__Uint64__Group__0__Impl rule__Uint64__Group__1 + { + pushFollow(FOLLOW_72); + rule__Uint64__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint64__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64__Group__0" + + + // $ANTLR start "rule__Uint64__Group__0__Impl" + // InternalRos1Parser.g:11736:1: rule__Uint64__Group__0__Impl : ( () ) ; + public final void rule__Uint64__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11740:1: ( ( () ) ) + // InternalRos1Parser.g:11741:1: ( () ) + { + // InternalRos1Parser.g:11741:1: ( () ) + // InternalRos1Parser.g:11742:2: () + { + before(grammarAccess.getUint64Access().getUint64Action_0()); + // InternalRos1Parser.g:11743:2: () + // InternalRos1Parser.g:11743:3: + { + } + + after(grammarAccess.getUint64Access().getUint64Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64__Group__0__Impl" + + + // $ANTLR start "rule__Uint64__Group__1" + // InternalRos1Parser.g:11751:1: rule__Uint64__Group__1 : rule__Uint64__Group__1__Impl ; + public final void rule__Uint64__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11755:1: ( rule__Uint64__Group__1__Impl ) + // InternalRos1Parser.g:11756:2: rule__Uint64__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint64__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64__Group__1" + + + // $ANTLR start "rule__Uint64__Group__1__Impl" + // InternalRos1Parser.g:11762:1: rule__Uint64__Group__1__Impl : ( Uint64 ) ; + public final void rule__Uint64__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11766:1: ( ( Uint64 ) ) + // InternalRos1Parser.g:11767:1: ( Uint64 ) + { + // InternalRos1Parser.g:11767:1: ( Uint64 ) + // InternalRos1Parser.g:11768:2: Uint64 + { + before(grammarAccess.getUint64Access().getUint64Keyword_1()); + match(input,Uint64,FOLLOW_2); + after(grammarAccess.getUint64Access().getUint64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64__Group__1__Impl" + + + // $ANTLR start "rule__Float32__Group__0" + // InternalRos1Parser.g:11778:1: rule__Float32__Group__0 : rule__Float32__Group__0__Impl rule__Float32__Group__1 ; + public final void rule__Float32__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11782:1: ( rule__Float32__Group__0__Impl rule__Float32__Group__1 ) + // InternalRos1Parser.g:11783:2: rule__Float32__Group__0__Impl rule__Float32__Group__1 + { + pushFollow(FOLLOW_73); + rule__Float32__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Float32__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32__Group__0" + + + // $ANTLR start "rule__Float32__Group__0__Impl" + // InternalRos1Parser.g:11790:1: rule__Float32__Group__0__Impl : ( () ) ; + public final void rule__Float32__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11794:1: ( ( () ) ) + // InternalRos1Parser.g:11795:1: ( () ) + { + // InternalRos1Parser.g:11795:1: ( () ) + // InternalRos1Parser.g:11796:2: () + { + before(grammarAccess.getFloat32Access().getFloat32Action_0()); + // InternalRos1Parser.g:11797:2: () + // InternalRos1Parser.g:11797:3: + { + } + + after(grammarAccess.getFloat32Access().getFloat32Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32__Group__0__Impl" + + + // $ANTLR start "rule__Float32__Group__1" + // InternalRos1Parser.g:11805:1: rule__Float32__Group__1 : rule__Float32__Group__1__Impl ; + public final void rule__Float32__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11809:1: ( rule__Float32__Group__1__Impl ) + // InternalRos1Parser.g:11810:2: rule__Float32__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Float32__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32__Group__1" + + + // $ANTLR start "rule__Float32__Group__1__Impl" + // InternalRos1Parser.g:11816:1: rule__Float32__Group__1__Impl : ( Float32 ) ; + public final void rule__Float32__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11820:1: ( ( Float32 ) ) + // InternalRos1Parser.g:11821:1: ( Float32 ) + { + // InternalRos1Parser.g:11821:1: ( Float32 ) + // InternalRos1Parser.g:11822:2: Float32 + { + before(grammarAccess.getFloat32Access().getFloat32Keyword_1()); + match(input,Float32,FOLLOW_2); + after(grammarAccess.getFloat32Access().getFloat32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32__Group__1__Impl" + + + // $ANTLR start "rule__Float64__Group__0" + // InternalRos1Parser.g:11832:1: rule__Float64__Group__0 : rule__Float64__Group__0__Impl rule__Float64__Group__1 ; + public final void rule__Float64__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11836:1: ( rule__Float64__Group__0__Impl rule__Float64__Group__1 ) + // InternalRos1Parser.g:11837:2: rule__Float64__Group__0__Impl rule__Float64__Group__1 + { + pushFollow(FOLLOW_74); + rule__Float64__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Float64__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64__Group__0" + + + // $ANTLR start "rule__Float64__Group__0__Impl" + // InternalRos1Parser.g:11844:1: rule__Float64__Group__0__Impl : ( () ) ; + public final void rule__Float64__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11848:1: ( ( () ) ) + // InternalRos1Parser.g:11849:1: ( () ) + { + // InternalRos1Parser.g:11849:1: ( () ) + // InternalRos1Parser.g:11850:2: () + { + before(grammarAccess.getFloat64Access().getFloat64Action_0()); + // InternalRos1Parser.g:11851:2: () + // InternalRos1Parser.g:11851:3: + { + } + + after(grammarAccess.getFloat64Access().getFloat64Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64__Group__0__Impl" + + + // $ANTLR start "rule__Float64__Group__1" + // InternalRos1Parser.g:11859:1: rule__Float64__Group__1 : rule__Float64__Group__1__Impl ; + public final void rule__Float64__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11863:1: ( rule__Float64__Group__1__Impl ) + // InternalRos1Parser.g:11864:2: rule__Float64__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Float64__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64__Group__1" + + + // $ANTLR start "rule__Float64__Group__1__Impl" + // InternalRos1Parser.g:11870:1: rule__Float64__Group__1__Impl : ( Float64 ) ; + public final void rule__Float64__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11874:1: ( ( Float64 ) ) + // InternalRos1Parser.g:11875:1: ( Float64 ) + { + // InternalRos1Parser.g:11875:1: ( Float64 ) + // InternalRos1Parser.g:11876:2: Float64 + { + before(grammarAccess.getFloat64Access().getFloat64Keyword_1()); + match(input,Float64,FOLLOW_2); + after(grammarAccess.getFloat64Access().getFloat64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64__Group__1__Impl" + + + // $ANTLR start "rule__String0__Group__0" + // InternalRos1Parser.g:11886:1: rule__String0__Group__0 : rule__String0__Group__0__Impl rule__String0__Group__1 ; + public final void rule__String0__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11890:1: ( rule__String0__Group__0__Impl rule__String0__Group__1 ) + // InternalRos1Parser.g:11891:2: rule__String0__Group__0__Impl rule__String0__Group__1 + { + pushFollow(FOLLOW_75); + rule__String0__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__String0__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0__Group__0" + + + // $ANTLR start "rule__String0__Group__0__Impl" + // InternalRos1Parser.g:11898:1: rule__String0__Group__0__Impl : ( () ) ; + public final void rule__String0__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11902:1: ( ( () ) ) + // InternalRos1Parser.g:11903:1: ( () ) + { + // InternalRos1Parser.g:11903:1: ( () ) + // InternalRos1Parser.g:11904:2: () + { + before(grammarAccess.getString0Access().getStringAction_0()); + // InternalRos1Parser.g:11905:2: () + // InternalRos1Parser.g:11905:3: + { + } + + after(grammarAccess.getString0Access().getStringAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0__Group__0__Impl" + + + // $ANTLR start "rule__String0__Group__1" + // InternalRos1Parser.g:11913:1: rule__String0__Group__1 : rule__String0__Group__1__Impl ; + public final void rule__String0__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11917:1: ( rule__String0__Group__1__Impl ) + // InternalRos1Parser.g:11918:2: rule__String0__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__String0__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0__Group__1" + + + // $ANTLR start "rule__String0__Group__1__Impl" + // InternalRos1Parser.g:11924:1: rule__String0__Group__1__Impl : ( String_1 ) ; + public final void rule__String0__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11928:1: ( ( String_1 ) ) + // InternalRos1Parser.g:11929:1: ( String_1 ) + { + // InternalRos1Parser.g:11929:1: ( String_1 ) + // InternalRos1Parser.g:11930:2: String_1 + { + before(grammarAccess.getString0Access().getStringKeyword_1()); + match(input,String_1,FOLLOW_2); + after(grammarAccess.getString0Access().getStringKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0__Group__1__Impl" + + + // $ANTLR start "rule__Byte__Group__0" + // InternalRos1Parser.g:11940:1: rule__Byte__Group__0 : rule__Byte__Group__0__Impl rule__Byte__Group__1 ; + public final void rule__Byte__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11944:1: ( rule__Byte__Group__0__Impl rule__Byte__Group__1 ) + // InternalRos1Parser.g:11945:2: rule__Byte__Group__0__Impl rule__Byte__Group__1 + { + pushFollow(FOLLOW_76); + rule__Byte__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Byte__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Byte__Group__0" + + + // $ANTLR start "rule__Byte__Group__0__Impl" + // InternalRos1Parser.g:11952:1: rule__Byte__Group__0__Impl : ( () ) ; + public final void rule__Byte__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11956:1: ( ( () ) ) + // InternalRos1Parser.g:11957:1: ( () ) + { + // InternalRos1Parser.g:11957:1: ( () ) + // InternalRos1Parser.g:11958:2: () + { + before(grammarAccess.getByteAccess().getByteAction_0()); + // InternalRos1Parser.g:11959:2: () + // InternalRos1Parser.g:11959:3: + { + } + + after(grammarAccess.getByteAccess().getByteAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Byte__Group__0__Impl" + + + // $ANTLR start "rule__Byte__Group__1" + // InternalRos1Parser.g:11967:1: rule__Byte__Group__1 : rule__Byte__Group__1__Impl ; + public final void rule__Byte__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11971:1: ( rule__Byte__Group__1__Impl ) + // InternalRos1Parser.g:11972:2: rule__Byte__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Byte__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Byte__Group__1" + + + // $ANTLR start "rule__Byte__Group__1__Impl" + // InternalRos1Parser.g:11978:1: rule__Byte__Group__1__Impl : ( Byte ) ; + public final void rule__Byte__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11982:1: ( ( Byte ) ) + // InternalRos1Parser.g:11983:1: ( Byte ) + { + // InternalRos1Parser.g:11983:1: ( Byte ) + // InternalRos1Parser.g:11984:2: Byte + { + before(grammarAccess.getByteAccess().getByteKeyword_1()); + match(input,Byte,FOLLOW_2); + after(grammarAccess.getByteAccess().getByteKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Byte__Group__1__Impl" + + + // $ANTLR start "rule__Time__Group__0" + // InternalRos1Parser.g:11994:1: rule__Time__Group__0 : rule__Time__Group__0__Impl rule__Time__Group__1 ; + public final void rule__Time__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:11998:1: ( rule__Time__Group__0__Impl rule__Time__Group__1 ) + // InternalRos1Parser.g:11999:2: rule__Time__Group__0__Impl rule__Time__Group__1 + { + pushFollow(FOLLOW_77); + rule__Time__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Time__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Time__Group__0" + + + // $ANTLR start "rule__Time__Group__0__Impl" + // InternalRos1Parser.g:12006:1: rule__Time__Group__0__Impl : ( () ) ; + public final void rule__Time__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12010:1: ( ( () ) ) + // InternalRos1Parser.g:12011:1: ( () ) + { + // InternalRos1Parser.g:12011:1: ( () ) + // InternalRos1Parser.g:12012:2: () + { + before(grammarAccess.getTimeAccess().getTimeAction_0()); + // InternalRos1Parser.g:12013:2: () + // InternalRos1Parser.g:12013:3: + { + } + + after(grammarAccess.getTimeAccess().getTimeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Time__Group__0__Impl" + + + // $ANTLR start "rule__Time__Group__1" + // InternalRos1Parser.g:12021:1: rule__Time__Group__1 : rule__Time__Group__1__Impl ; + public final void rule__Time__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12025:1: ( rule__Time__Group__1__Impl ) + // InternalRos1Parser.g:12026:2: rule__Time__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Time__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Time__Group__1" + + + // $ANTLR start "rule__Time__Group__1__Impl" + // InternalRos1Parser.g:12032:1: rule__Time__Group__1__Impl : ( Time ) ; + public final void rule__Time__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12036:1: ( ( Time ) ) + // InternalRos1Parser.g:12037:1: ( Time ) + { + // InternalRos1Parser.g:12037:1: ( Time ) + // InternalRos1Parser.g:12038:2: Time + { + before(grammarAccess.getTimeAccess().getTimeKeyword_1()); + match(input,Time,FOLLOW_2); + after(grammarAccess.getTimeAccess().getTimeKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Time__Group__1__Impl" + + + // $ANTLR start "rule__Duration__Group__0" + // InternalRos1Parser.g:12048:1: rule__Duration__Group__0 : rule__Duration__Group__0__Impl rule__Duration__Group__1 ; + public final void rule__Duration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12052:1: ( rule__Duration__Group__0__Impl rule__Duration__Group__1 ) + // InternalRos1Parser.g:12053:2: rule__Duration__Group__0__Impl rule__Duration__Group__1 + { + pushFollow(FOLLOW_78); + rule__Duration__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Duration__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Duration__Group__0" + + + // $ANTLR start "rule__Duration__Group__0__Impl" + // InternalRos1Parser.g:12060:1: rule__Duration__Group__0__Impl : ( () ) ; + public final void rule__Duration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12064:1: ( ( () ) ) + // InternalRos1Parser.g:12065:1: ( () ) + { + // InternalRos1Parser.g:12065:1: ( () ) + // InternalRos1Parser.g:12066:2: () + { + before(grammarAccess.getDurationAccess().getDurationAction_0()); + // InternalRos1Parser.g:12067:2: () + // InternalRos1Parser.g:12067:3: + { + } + + after(grammarAccess.getDurationAccess().getDurationAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Duration__Group__0__Impl" + + + // $ANTLR start "rule__Duration__Group__1" + // InternalRos1Parser.g:12075:1: rule__Duration__Group__1 : rule__Duration__Group__1__Impl ; + public final void rule__Duration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12079:1: ( rule__Duration__Group__1__Impl ) + // InternalRos1Parser.g:12080:2: rule__Duration__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Duration__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Duration__Group__1" + + + // $ANTLR start "rule__Duration__Group__1__Impl" + // InternalRos1Parser.g:12086:1: rule__Duration__Group__1__Impl : ( Duration ) ; + public final void rule__Duration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12090:1: ( ( Duration ) ) + // InternalRos1Parser.g:12091:1: ( Duration ) + { + // InternalRos1Parser.g:12091:1: ( Duration ) + // InternalRos1Parser.g:12092:2: Duration + { + before(grammarAccess.getDurationAccess().getDurationKeyword_1()); + match(input,Duration,FOLLOW_2); + after(grammarAccess.getDurationAccess().getDurationKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Duration__Group__1__Impl" + + + // $ANTLR start "rule__BoolArray__Group__0" + // InternalRos1Parser.g:12102:1: rule__BoolArray__Group__0 : rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 ; + public final void rule__BoolArray__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12106:1: ( rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 ) + // InternalRos1Parser.g:12107:2: rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 + { + pushFollow(FOLLOW_79); + rule__BoolArray__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__BoolArray__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__BoolArray__Group__0" + + + // $ANTLR start "rule__BoolArray__Group__0__Impl" + // InternalRos1Parser.g:12114:1: rule__BoolArray__Group__0__Impl : ( () ) ; + public final void rule__BoolArray__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12118:1: ( ( () ) ) + // InternalRos1Parser.g:12119:1: ( () ) + { + // InternalRos1Parser.g:12119:1: ( () ) + // InternalRos1Parser.g:12120:2: () + { + before(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); + // InternalRos1Parser.g:12121:2: () + // InternalRos1Parser.g:12121:3: + { + } + + after(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__BoolArray__Group__0__Impl" + + + // $ANTLR start "rule__BoolArray__Group__1" + // InternalRos1Parser.g:12129:1: rule__BoolArray__Group__1 : rule__BoolArray__Group__1__Impl ; + public final void rule__BoolArray__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12133:1: ( rule__BoolArray__Group__1__Impl ) + // InternalRos1Parser.g:12134:2: rule__BoolArray__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__BoolArray__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__BoolArray__Group__1" + + + // $ANTLR start "rule__BoolArray__Group__1__Impl" + // InternalRos1Parser.g:12140:1: rule__BoolArray__Group__1__Impl : ( Bool_1 ) ; + public final void rule__BoolArray__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12144:1: ( ( Bool_1 ) ) + // InternalRos1Parser.g:12145:1: ( Bool_1 ) + { + // InternalRos1Parser.g:12145:1: ( Bool_1 ) + // InternalRos1Parser.g:12146:2: Bool_1 + { + before(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); + match(input,Bool_1,FOLLOW_2); + after(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__BoolArray__Group__1__Impl" + + + // $ANTLR start "rule__Int8Array__Group__0" + // InternalRos1Parser.g:12156:1: rule__Int8Array__Group__0 : rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 ; + public final void rule__Int8Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12160:1: ( rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 ) + // InternalRos1Parser.g:12161:2: rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 + { + pushFollow(FOLLOW_80); + rule__Int8Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int8Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8Array__Group__0" + + + // $ANTLR start "rule__Int8Array__Group__0__Impl" + // InternalRos1Parser.g:12168:1: rule__Int8Array__Group__0__Impl : ( () ) ; + public final void rule__Int8Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12172:1: ( ( () ) ) + // InternalRos1Parser.g:12173:1: ( () ) + { + // InternalRos1Parser.g:12173:1: ( () ) + // InternalRos1Parser.g:12174:2: () + { + before(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); + // InternalRos1Parser.g:12175:2: () + // InternalRos1Parser.g:12175:3: + { + } + + after(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8Array__Group__0__Impl" + + + // $ANTLR start "rule__Int8Array__Group__1" + // InternalRos1Parser.g:12183:1: rule__Int8Array__Group__1 : rule__Int8Array__Group__1__Impl ; + public final void rule__Int8Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12187:1: ( rule__Int8Array__Group__1__Impl ) + // InternalRos1Parser.g:12188:2: rule__Int8Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int8Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8Array__Group__1" + + + // $ANTLR start "rule__Int8Array__Group__1__Impl" + // InternalRos1Parser.g:12194:1: rule__Int8Array__Group__1__Impl : ( Int8_1 ) ; + public final void rule__Int8Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12198:1: ( ( Int8_1 ) ) + // InternalRos1Parser.g:12199:1: ( Int8_1 ) + { + // InternalRos1Parser.g:12199:1: ( Int8_1 ) + // InternalRos1Parser.g:12200:2: Int8_1 + { + before(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); + match(input,Int8_1,FOLLOW_2); + after(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8Array__Group__1__Impl" + + + // $ANTLR start "rule__Uint8Array__Group__0" + // InternalRos1Parser.g:12210:1: rule__Uint8Array__Group__0 : rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 ; + public final void rule__Uint8Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12214:1: ( rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 ) + // InternalRos1Parser.g:12215:2: rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 + { + pushFollow(FOLLOW_81); + rule__Uint8Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint8Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8Array__Group__0" + + + // $ANTLR start "rule__Uint8Array__Group__0__Impl" + // InternalRos1Parser.g:12222:1: rule__Uint8Array__Group__0__Impl : ( () ) ; + public final void rule__Uint8Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12226:1: ( ( () ) ) + // InternalRos1Parser.g:12227:1: ( () ) + { + // InternalRos1Parser.g:12227:1: ( () ) + // InternalRos1Parser.g:12228:2: () + { + before(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); + // InternalRos1Parser.g:12229:2: () + // InternalRos1Parser.g:12229:3: + { + } + + after(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8Array__Group__0__Impl" + + + // $ANTLR start "rule__Uint8Array__Group__1" + // InternalRos1Parser.g:12237:1: rule__Uint8Array__Group__1 : rule__Uint8Array__Group__1__Impl ; + public final void rule__Uint8Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12241:1: ( rule__Uint8Array__Group__1__Impl ) + // InternalRos1Parser.g:12242:2: rule__Uint8Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint8Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8Array__Group__1" + + + // $ANTLR start "rule__Uint8Array__Group__1__Impl" + // InternalRos1Parser.g:12248:1: rule__Uint8Array__Group__1__Impl : ( Uint8_1 ) ; + public final void rule__Uint8Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12252:1: ( ( Uint8_1 ) ) + // InternalRos1Parser.g:12253:1: ( Uint8_1 ) + { + // InternalRos1Parser.g:12253:1: ( Uint8_1 ) + // InternalRos1Parser.g:12254:2: Uint8_1 + { + before(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); + match(input,Uint8_1,FOLLOW_2); + after(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8Array__Group__1__Impl" + + + // $ANTLR start "rule__Int16Array__Group__0" + // InternalRos1Parser.g:12264:1: rule__Int16Array__Group__0 : rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 ; + public final void rule__Int16Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12268:1: ( rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 ) + // InternalRos1Parser.g:12269:2: rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 + { + pushFollow(FOLLOW_82); + rule__Int16Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int16Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16Array__Group__0" + + + // $ANTLR start "rule__Int16Array__Group__0__Impl" + // InternalRos1Parser.g:12276:1: rule__Int16Array__Group__0__Impl : ( () ) ; + public final void rule__Int16Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12280:1: ( ( () ) ) + // InternalRos1Parser.g:12281:1: ( () ) + { + // InternalRos1Parser.g:12281:1: ( () ) + // InternalRos1Parser.g:12282:2: () + { + before(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); + // InternalRos1Parser.g:12283:2: () + // InternalRos1Parser.g:12283:3: + { + } + + after(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16Array__Group__0__Impl" + + + // $ANTLR start "rule__Int16Array__Group__1" + // InternalRos1Parser.g:12291:1: rule__Int16Array__Group__1 : rule__Int16Array__Group__1__Impl ; + public final void rule__Int16Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12295:1: ( rule__Int16Array__Group__1__Impl ) + // InternalRos1Parser.g:12296:2: rule__Int16Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int16Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16Array__Group__1" + + + // $ANTLR start "rule__Int16Array__Group__1__Impl" + // InternalRos1Parser.g:12302:1: rule__Int16Array__Group__1__Impl : ( Int16_1 ) ; + public final void rule__Int16Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12306:1: ( ( Int16_1 ) ) + // InternalRos1Parser.g:12307:1: ( Int16_1 ) + { + // InternalRos1Parser.g:12307:1: ( Int16_1 ) + // InternalRos1Parser.g:12308:2: Int16_1 + { + before(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); + match(input,Int16_1,FOLLOW_2); + after(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16Array__Group__1__Impl" + + + // $ANTLR start "rule__Uint16Array__Group__0" + // InternalRos1Parser.g:12318:1: rule__Uint16Array__Group__0 : rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 ; + public final void rule__Uint16Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12322:1: ( rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 ) + // InternalRos1Parser.g:12323:2: rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 + { + pushFollow(FOLLOW_83); + rule__Uint16Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint16Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16Array__Group__0" + + + // $ANTLR start "rule__Uint16Array__Group__0__Impl" + // InternalRos1Parser.g:12330:1: rule__Uint16Array__Group__0__Impl : ( () ) ; + public final void rule__Uint16Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12334:1: ( ( () ) ) + // InternalRos1Parser.g:12335:1: ( () ) + { + // InternalRos1Parser.g:12335:1: ( () ) + // InternalRos1Parser.g:12336:2: () + { + before(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); + // InternalRos1Parser.g:12337:2: () + // InternalRos1Parser.g:12337:3: + { + } + + after(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16Array__Group__0__Impl" + + + // $ANTLR start "rule__Uint16Array__Group__1" + // InternalRos1Parser.g:12345:1: rule__Uint16Array__Group__1 : rule__Uint16Array__Group__1__Impl ; + public final void rule__Uint16Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12349:1: ( rule__Uint16Array__Group__1__Impl ) + // InternalRos1Parser.g:12350:2: rule__Uint16Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint16Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16Array__Group__1" + + + // $ANTLR start "rule__Uint16Array__Group__1__Impl" + // InternalRos1Parser.g:12356:1: rule__Uint16Array__Group__1__Impl : ( Uint16_1 ) ; + public final void rule__Uint16Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12360:1: ( ( Uint16_1 ) ) + // InternalRos1Parser.g:12361:1: ( Uint16_1 ) + { + // InternalRos1Parser.g:12361:1: ( Uint16_1 ) + // InternalRos1Parser.g:12362:2: Uint16_1 + { + before(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); + match(input,Uint16_1,FOLLOW_2); + after(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16Array__Group__1__Impl" + + + // $ANTLR start "rule__Int32Array__Group__0" + // InternalRos1Parser.g:12372:1: rule__Int32Array__Group__0 : rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 ; + public final void rule__Int32Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12376:1: ( rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 ) + // InternalRos1Parser.g:12377:2: rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 + { + pushFollow(FOLLOW_84); + rule__Int32Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int32Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32Array__Group__0" + + + // $ANTLR start "rule__Int32Array__Group__0__Impl" + // InternalRos1Parser.g:12384:1: rule__Int32Array__Group__0__Impl : ( () ) ; + public final void rule__Int32Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12388:1: ( ( () ) ) + // InternalRos1Parser.g:12389:1: ( () ) + { + // InternalRos1Parser.g:12389:1: ( () ) + // InternalRos1Parser.g:12390:2: () + { + before(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); + // InternalRos1Parser.g:12391:2: () + // InternalRos1Parser.g:12391:3: + { + } + + after(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32Array__Group__0__Impl" + + + // $ANTLR start "rule__Int32Array__Group__1" + // InternalRos1Parser.g:12399:1: rule__Int32Array__Group__1 : rule__Int32Array__Group__1__Impl ; + public final void rule__Int32Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12403:1: ( rule__Int32Array__Group__1__Impl ) + // InternalRos1Parser.g:12404:2: rule__Int32Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int32Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32Array__Group__1" + + + // $ANTLR start "rule__Int32Array__Group__1__Impl" + // InternalRos1Parser.g:12410:1: rule__Int32Array__Group__1__Impl : ( Int32_1 ) ; + public final void rule__Int32Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12414:1: ( ( Int32_1 ) ) + // InternalRos1Parser.g:12415:1: ( Int32_1 ) + { + // InternalRos1Parser.g:12415:1: ( Int32_1 ) + // InternalRos1Parser.g:12416:2: Int32_1 + { + before(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); + match(input,Int32_1,FOLLOW_2); + after(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32Array__Group__1__Impl" + + + // $ANTLR start "rule__Uint32Array__Group__0" + // InternalRos1Parser.g:12426:1: rule__Uint32Array__Group__0 : rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 ; + public final void rule__Uint32Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12430:1: ( rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 ) + // InternalRos1Parser.g:12431:2: rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 + { + pushFollow(FOLLOW_85); + rule__Uint32Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint32Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32Array__Group__0" + + + // $ANTLR start "rule__Uint32Array__Group__0__Impl" + // InternalRos1Parser.g:12438:1: rule__Uint32Array__Group__0__Impl : ( () ) ; + public final void rule__Uint32Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12442:1: ( ( () ) ) + // InternalRos1Parser.g:12443:1: ( () ) + { + // InternalRos1Parser.g:12443:1: ( () ) + // InternalRos1Parser.g:12444:2: () + { + before(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); + // InternalRos1Parser.g:12445:2: () + // InternalRos1Parser.g:12445:3: + { + } + + after(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32Array__Group__0__Impl" + + + // $ANTLR start "rule__Uint32Array__Group__1" + // InternalRos1Parser.g:12453:1: rule__Uint32Array__Group__1 : rule__Uint32Array__Group__1__Impl ; + public final void rule__Uint32Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12457:1: ( rule__Uint32Array__Group__1__Impl ) + // InternalRos1Parser.g:12458:2: rule__Uint32Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint32Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32Array__Group__1" + + + // $ANTLR start "rule__Uint32Array__Group__1__Impl" + // InternalRos1Parser.g:12464:1: rule__Uint32Array__Group__1__Impl : ( Uint32_1 ) ; + public final void rule__Uint32Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12468:1: ( ( Uint32_1 ) ) + // InternalRos1Parser.g:12469:1: ( Uint32_1 ) + { + // InternalRos1Parser.g:12469:1: ( Uint32_1 ) + // InternalRos1Parser.g:12470:2: Uint32_1 + { + before(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); + match(input,Uint32_1,FOLLOW_2); + after(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32Array__Group__1__Impl" + + + // $ANTLR start "rule__Int64Array__Group__0" + // InternalRos1Parser.g:12480:1: rule__Int64Array__Group__0 : rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 ; + public final void rule__Int64Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12484:1: ( rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 ) + // InternalRos1Parser.g:12485:2: rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 + { + pushFollow(FOLLOW_86); + rule__Int64Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int64Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64Array__Group__0" + + + // $ANTLR start "rule__Int64Array__Group__0__Impl" + // InternalRos1Parser.g:12492:1: rule__Int64Array__Group__0__Impl : ( () ) ; + public final void rule__Int64Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12496:1: ( ( () ) ) + // InternalRos1Parser.g:12497:1: ( () ) + { + // InternalRos1Parser.g:12497:1: ( () ) + // InternalRos1Parser.g:12498:2: () + { + before(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); + // InternalRos1Parser.g:12499:2: () + // InternalRos1Parser.g:12499:3: + { + } + + after(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64Array__Group__0__Impl" + + + // $ANTLR start "rule__Int64Array__Group__1" + // InternalRos1Parser.g:12507:1: rule__Int64Array__Group__1 : rule__Int64Array__Group__1__Impl ; + public final void rule__Int64Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12511:1: ( rule__Int64Array__Group__1__Impl ) + // InternalRos1Parser.g:12512:2: rule__Int64Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int64Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64Array__Group__1" + + + // $ANTLR start "rule__Int64Array__Group__1__Impl" + // InternalRos1Parser.g:12518:1: rule__Int64Array__Group__1__Impl : ( Int64_1 ) ; + public final void rule__Int64Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12522:1: ( ( Int64_1 ) ) + // InternalRos1Parser.g:12523:1: ( Int64_1 ) + { + // InternalRos1Parser.g:12523:1: ( Int64_1 ) + // InternalRos1Parser.g:12524:2: Int64_1 + { + before(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); + match(input,Int64_1,FOLLOW_2); + after(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64Array__Group__1__Impl" + + + // $ANTLR start "rule__Uint64Array__Group__0" + // InternalRos1Parser.g:12534:1: rule__Uint64Array__Group__0 : rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 ; + public final void rule__Uint64Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12538:1: ( rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 ) + // InternalRos1Parser.g:12539:2: rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 + { + pushFollow(FOLLOW_87); + rule__Uint64Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint64Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64Array__Group__0" + + + // $ANTLR start "rule__Uint64Array__Group__0__Impl" + // InternalRos1Parser.g:12546:1: rule__Uint64Array__Group__0__Impl : ( () ) ; + public final void rule__Uint64Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12550:1: ( ( () ) ) + // InternalRos1Parser.g:12551:1: ( () ) + { + // InternalRos1Parser.g:12551:1: ( () ) + // InternalRos1Parser.g:12552:2: () + { + before(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); + // InternalRos1Parser.g:12553:2: () + // InternalRos1Parser.g:12553:3: + { + } + + after(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64Array__Group__0__Impl" + + + // $ANTLR start "rule__Uint64Array__Group__1" + // InternalRos1Parser.g:12561:1: rule__Uint64Array__Group__1 : rule__Uint64Array__Group__1__Impl ; + public final void rule__Uint64Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12565:1: ( rule__Uint64Array__Group__1__Impl ) + // InternalRos1Parser.g:12566:2: rule__Uint64Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint64Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64Array__Group__1" + + + // $ANTLR start "rule__Uint64Array__Group__1__Impl" + // InternalRos1Parser.g:12572:1: rule__Uint64Array__Group__1__Impl : ( Uint64_1 ) ; + public final void rule__Uint64Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12576:1: ( ( Uint64_1 ) ) + // InternalRos1Parser.g:12577:1: ( Uint64_1 ) + { + // InternalRos1Parser.g:12577:1: ( Uint64_1 ) + // InternalRos1Parser.g:12578:2: Uint64_1 + { + before(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); + match(input,Uint64_1,FOLLOW_2); + after(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64Array__Group__1__Impl" + + + // $ANTLR start "rule__Float32Array__Group__0" + // InternalRos1Parser.g:12588:1: rule__Float32Array__Group__0 : rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 ; + public final void rule__Float32Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12592:1: ( rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 ) + // InternalRos1Parser.g:12593:2: rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 + { + pushFollow(FOLLOW_88); + rule__Float32Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Float32Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32Array__Group__0" + + + // $ANTLR start "rule__Float32Array__Group__0__Impl" + // InternalRos1Parser.g:12600:1: rule__Float32Array__Group__0__Impl : ( () ) ; + public final void rule__Float32Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12604:1: ( ( () ) ) + // InternalRos1Parser.g:12605:1: ( () ) + { + // InternalRos1Parser.g:12605:1: ( () ) + // InternalRos1Parser.g:12606:2: () + { + before(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); + // InternalRos1Parser.g:12607:2: () + // InternalRos1Parser.g:12607:3: + { + } + + after(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32Array__Group__0__Impl" + + + // $ANTLR start "rule__Float32Array__Group__1" + // InternalRos1Parser.g:12615:1: rule__Float32Array__Group__1 : rule__Float32Array__Group__1__Impl ; + public final void rule__Float32Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12619:1: ( rule__Float32Array__Group__1__Impl ) + // InternalRos1Parser.g:12620:2: rule__Float32Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Float32Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32Array__Group__1" + + + // $ANTLR start "rule__Float32Array__Group__1__Impl" + // InternalRos1Parser.g:12626:1: rule__Float32Array__Group__1__Impl : ( Float32_1 ) ; + public final void rule__Float32Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12630:1: ( ( Float32_1 ) ) + // InternalRos1Parser.g:12631:1: ( Float32_1 ) + { + // InternalRos1Parser.g:12631:1: ( Float32_1 ) + // InternalRos1Parser.g:12632:2: Float32_1 + { + before(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); + match(input,Float32_1,FOLLOW_2); + after(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32Array__Group__1__Impl" + + + // $ANTLR start "rule__Float64Array__Group__0" + // InternalRos1Parser.g:12642:1: rule__Float64Array__Group__0 : rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 ; + public final void rule__Float64Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12646:1: ( rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 ) + // InternalRos1Parser.g:12647:2: rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 + { + pushFollow(FOLLOW_89); + rule__Float64Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Float64Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64Array__Group__0" + + + // $ANTLR start "rule__Float64Array__Group__0__Impl" + // InternalRos1Parser.g:12654:1: rule__Float64Array__Group__0__Impl : ( () ) ; + public final void rule__Float64Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12658:1: ( ( () ) ) + // InternalRos1Parser.g:12659:1: ( () ) + { + // InternalRos1Parser.g:12659:1: ( () ) + // InternalRos1Parser.g:12660:2: () + { + before(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); + // InternalRos1Parser.g:12661:2: () + // InternalRos1Parser.g:12661:3: + { + } + + after(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64Array__Group__0__Impl" + + + // $ANTLR start "rule__Float64Array__Group__1" + // InternalRos1Parser.g:12669:1: rule__Float64Array__Group__1 : rule__Float64Array__Group__1__Impl ; + public final void rule__Float64Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12673:1: ( rule__Float64Array__Group__1__Impl ) + // InternalRos1Parser.g:12674:2: rule__Float64Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Float64Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64Array__Group__1" + + + // $ANTLR start "rule__Float64Array__Group__1__Impl" + // InternalRos1Parser.g:12680:1: rule__Float64Array__Group__1__Impl : ( Float64_1 ) ; + public final void rule__Float64Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12684:1: ( ( Float64_1 ) ) + // InternalRos1Parser.g:12685:1: ( Float64_1 ) + { + // InternalRos1Parser.g:12685:1: ( Float64_1 ) + // InternalRos1Parser.g:12686:2: Float64_1 + { + before(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); + match(input,Float64_1,FOLLOW_2); + after(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64Array__Group__1__Impl" + + + // $ANTLR start "rule__String0Array__Group__0" + // InternalRos1Parser.g:12696:1: rule__String0Array__Group__0 : rule__String0Array__Group__0__Impl rule__String0Array__Group__1 ; + public final void rule__String0Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12700:1: ( rule__String0Array__Group__0__Impl rule__String0Array__Group__1 ) + // InternalRos1Parser.g:12701:2: rule__String0Array__Group__0__Impl rule__String0Array__Group__1 + { + pushFollow(FOLLOW_90); + rule__String0Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__String0Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0Array__Group__0" + + + // $ANTLR start "rule__String0Array__Group__0__Impl" + // InternalRos1Parser.g:12708:1: rule__String0Array__Group__0__Impl : ( () ) ; + public final void rule__String0Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12712:1: ( ( () ) ) + // InternalRos1Parser.g:12713:1: ( () ) + { + // InternalRos1Parser.g:12713:1: ( () ) + // InternalRos1Parser.g:12714:2: () + { + before(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); + // InternalRos1Parser.g:12715:2: () + // InternalRos1Parser.g:12715:3: + { + } + + after(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0Array__Group__0__Impl" + + + // $ANTLR start "rule__String0Array__Group__1" + // InternalRos1Parser.g:12723:1: rule__String0Array__Group__1 : rule__String0Array__Group__1__Impl ; + public final void rule__String0Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12727:1: ( rule__String0Array__Group__1__Impl ) + // InternalRos1Parser.g:12728:2: rule__String0Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__String0Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0Array__Group__1" + + + // $ANTLR start "rule__String0Array__Group__1__Impl" + // InternalRos1Parser.g:12734:1: rule__String0Array__Group__1__Impl : ( String_2 ) ; + public final void rule__String0Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12738:1: ( ( String_2 ) ) + // InternalRos1Parser.g:12739:1: ( String_2 ) + { + // InternalRos1Parser.g:12739:1: ( String_2 ) + // InternalRos1Parser.g:12740:2: String_2 + { + before(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); + match(input,String_2,FOLLOW_2); + after(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0Array__Group__1__Impl" + + + // $ANTLR start "rule__ByteArray__Group__0" + // InternalRos1Parser.g:12750:1: rule__ByteArray__Group__0 : rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 ; + public final void rule__ByteArray__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12754:1: ( rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 ) + // InternalRos1Parser.g:12755:2: rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 + { + pushFollow(FOLLOW_91); + rule__ByteArray__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ByteArray__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ByteArray__Group__0" + + + // $ANTLR start "rule__ByteArray__Group__0__Impl" + // InternalRos1Parser.g:12762:1: rule__ByteArray__Group__0__Impl : ( () ) ; + public final void rule__ByteArray__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12766:1: ( ( () ) ) + // InternalRos1Parser.g:12767:1: ( () ) + { + // InternalRos1Parser.g:12767:1: ( () ) + // InternalRos1Parser.g:12768:2: () + { + before(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); + // InternalRos1Parser.g:12769:2: () + // InternalRos1Parser.g:12769:3: + { + } + + after(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ByteArray__Group__0__Impl" + + + // $ANTLR start "rule__ByteArray__Group__1" + // InternalRos1Parser.g:12777:1: rule__ByteArray__Group__1 : rule__ByteArray__Group__1__Impl ; + public final void rule__ByteArray__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12781:1: ( rule__ByteArray__Group__1__Impl ) + // InternalRos1Parser.g:12782:2: rule__ByteArray__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ByteArray__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ByteArray__Group__1" + + + // $ANTLR start "rule__ByteArray__Group__1__Impl" + // InternalRos1Parser.g:12788:1: rule__ByteArray__Group__1__Impl : ( Byte_1 ) ; + public final void rule__ByteArray__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12792:1: ( ( Byte_1 ) ) + // InternalRos1Parser.g:12793:1: ( Byte_1 ) + { + // InternalRos1Parser.g:12793:1: ( Byte_1 ) + // InternalRos1Parser.g:12794:2: Byte_1 + { + before(grammarAccess.getByteArrayAccess().getByteKeyword_1()); + match(input,Byte_1,FOLLOW_2); + after(grammarAccess.getByteArrayAccess().getByteKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ByteArray__Group__1__Impl" + + + // $ANTLR start "rule__Header__Group__0" + // InternalRos1Parser.g:12804:1: rule__Header__Group__0 : rule__Header__Group__0__Impl rule__Header__Group__1 ; + public final void rule__Header__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12808:1: ( rule__Header__Group__0__Impl rule__Header__Group__1 ) + // InternalRos1Parser.g:12809:2: rule__Header__Group__0__Impl rule__Header__Group__1 + { + pushFollow(FOLLOW_92); + rule__Header__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Header__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Header__Group__0" + + + // $ANTLR start "rule__Header__Group__0__Impl" + // InternalRos1Parser.g:12816:1: rule__Header__Group__0__Impl : ( () ) ; + public final void rule__Header__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12820:1: ( ( () ) ) + // InternalRos1Parser.g:12821:1: ( () ) + { + // InternalRos1Parser.g:12821:1: ( () ) + // InternalRos1Parser.g:12822:2: () + { + before(grammarAccess.getHeaderAccess().getHeaderAction_0()); + // InternalRos1Parser.g:12823:2: () + // InternalRos1Parser.g:12823:3: + { + } + + after(grammarAccess.getHeaderAccess().getHeaderAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Header__Group__0__Impl" + + + // $ANTLR start "rule__Header__Group__1" + // InternalRos1Parser.g:12831:1: rule__Header__Group__1 : rule__Header__Group__1__Impl ; + public final void rule__Header__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12835:1: ( rule__Header__Group__1__Impl ) + // InternalRos1Parser.g:12836:2: rule__Header__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Header__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Header__Group__1" + + + // $ANTLR start "rule__Header__Group__1__Impl" + // InternalRos1Parser.g:12842:1: rule__Header__Group__1__Impl : ( Header ) ; + public final void rule__Header__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12846:1: ( ( Header ) ) + // InternalRos1Parser.g:12847:1: ( Header ) + { + // InternalRos1Parser.g:12847:1: ( Header ) + // InternalRos1Parser.g:12848:2: Header + { + before(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); + match(input,Header,FOLLOW_2); + after(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Header__Group__1__Impl" + + + // $ANTLR start "rule__ArrayTopicSpecRef__Group__0" + // InternalRos1Parser.g:12858:1: rule__ArrayTopicSpecRef__Group__0 : rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 ; + public final void rule__ArrayTopicSpecRef__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12862:1: ( rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 ) + // InternalRos1Parser.g:12863:2: rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 + { + pushFollow(FOLLOW_93); + rule__ArrayTopicSpecRef__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ArrayTopicSpecRef__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayTopicSpecRef__Group__0" + + + // $ANTLR start "rule__ArrayTopicSpecRef__Group__0__Impl" + // InternalRos1Parser.g:12870:1: rule__ArrayTopicSpecRef__Group__0__Impl : ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) ; + public final void rule__ArrayTopicSpecRef__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12874:1: ( ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) ) + // InternalRos1Parser.g:12875:1: ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) + { + // InternalRos1Parser.g:12875:1: ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) + // InternalRos1Parser.g:12876:2: ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) + { + before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); + // InternalRos1Parser.g:12877:2: ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) + // InternalRos1Parser.g:12877:3: rule__ArrayTopicSpecRef__TopicSpecAssignment_0 + { + pushFollow(FOLLOW_2); + rule__ArrayTopicSpecRef__TopicSpecAssignment_0(); + + state._fsp--; + + + } + + after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayTopicSpecRef__Group__0__Impl" + + + // $ANTLR start "rule__ArrayTopicSpecRef__Group__1" + // InternalRos1Parser.g:12885:1: rule__ArrayTopicSpecRef__Group__1 : rule__ArrayTopicSpecRef__Group__1__Impl ; + public final void rule__ArrayTopicSpecRef__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12889:1: ( rule__ArrayTopicSpecRef__Group__1__Impl ) + // InternalRos1Parser.g:12890:2: rule__ArrayTopicSpecRef__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ArrayTopicSpecRef__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayTopicSpecRef__Group__1" + + + // $ANTLR start "rule__ArrayTopicSpecRef__Group__1__Impl" + // InternalRos1Parser.g:12896:1: rule__ArrayTopicSpecRef__Group__1__Impl : ( LeftSquareBracketRightSquareBracket ) ; + public final void rule__ArrayTopicSpecRef__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12900:1: ( ( LeftSquareBracketRightSquareBracket ) ) + // InternalRos1Parser.g:12901:1: ( LeftSquareBracketRightSquareBracket ) + { + // InternalRos1Parser.g:12901:1: ( LeftSquareBracketRightSquareBracket ) + // InternalRos1Parser.g:12902:2: LeftSquareBracketRightSquareBracket + { + before(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); + match(input,LeftSquareBracketRightSquareBracket,FOLLOW_2); + after(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayTopicSpecRef__Group__1__Impl" + + + // $ANTLR start "rule__CatkinPackage__NameAssignment_1" + // InternalRos1Parser.g:12912:1: rule__CatkinPackage__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__CatkinPackage__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12916:1: ( ( ruleRosNames ) ) + // InternalRos1Parser.g:12917:2: ( ruleRosNames ) + { + // InternalRos1Parser.g:12917:2: ( ruleRosNames ) + // InternalRos1Parser.g:12918: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:12927:1: rule__CatkinPackage__FromGitRepoAssignment_4_1 : ( ruleEString ) ; + public final void rule__CatkinPackage__FromGitRepoAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12931:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:12932:2: ( ruleEString ) + { + // InternalRos1Parser.g:12932:2: ( ruleEString ) + // InternalRos1Parser.g:12933: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:12942:1: rule__CatkinPackage__ArtifactAssignment_5_2 : ( ruleArtifact ) ; + public final void rule__CatkinPackage__ArtifactAssignment_5_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12946:1: ( ( ruleArtifact ) ) + // InternalRos1Parser.g:12947:2: ( ruleArtifact ) + { + // InternalRos1Parser.g:12947:2: ( ruleArtifact ) + // InternalRos1Parser.g:12948: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:12957:1: rule__CatkinPackage__DependencyAssignment_6_2 : ( ruleDependency ) ; + public final void rule__CatkinPackage__DependencyAssignment_6_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12961:1: ( ( ruleDependency ) ) + // InternalRos1Parser.g:12962:2: ( ruleDependency ) + { + // InternalRos1Parser.g:12962:2: ( ruleDependency ) + // InternalRos1Parser.g:12963: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:12972: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:12976:1: ( ( ruleDependency ) ) + // InternalRos1Parser.g:12977:2: ( ruleDependency ) + { + // InternalRos1Parser.g:12977:2: ( ruleDependency ) + // InternalRos1Parser.g:12978: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__Package_Impl__NameAssignment_1" + // InternalRos1Parser.g:12987:1: rule__Package_Impl__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__Package_Impl__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:12991:1: ( ( ruleRosNames ) ) + // InternalRos1Parser.g:12992:2: ( ruleRosNames ) + { + // InternalRos1Parser.g:12992:2: ( ruleRosNames ) + // InternalRos1Parser.g:12993:3: ruleRosNames + { + before(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleRosNames(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__NameAssignment_1" + + + // $ANTLR start "rule__Package_Impl__FromGitRepoAssignment_4_1" + // InternalRos1Parser.g:13002:1: rule__Package_Impl__FromGitRepoAssignment_4_1 : ( ruleEString ) ; + public final void rule__Package_Impl__FromGitRepoAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13006:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:13007:2: ( ruleEString ) + { + // InternalRos1Parser.g:13007:2: ( ruleEString ) + // InternalRos1Parser.g:13008:3: ruleEString + { + before(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__FromGitRepoAssignment_4_1" + + + // $ANTLR start "rule__Package_Impl__SpecAssignment_5_2" + // InternalRos1Parser.g:13017:1: rule__Package_Impl__SpecAssignment_5_2 : ( ruleSpecBase ) ; + public final void rule__Package_Impl__SpecAssignment_5_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13021:1: ( ( ruleSpecBase ) ) + // InternalRos1Parser.g:13022:2: ( ruleSpecBase ) + { + // InternalRos1Parser.g:13022:2: ( ruleSpecBase ) + // InternalRos1Parser.g:13023:3: ruleSpecBase + { + before(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); + pushFollow(FOLLOW_2); + ruleSpecBase(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__SpecAssignment_5_2" + + + // $ANTLR start "rule__Package_Impl__DependencyAssignment_6_2" + // InternalRos1Parser.g:13032:1: rule__Package_Impl__DependencyAssignment_6_2 : ( ruleDependency ) ; + public final void rule__Package_Impl__DependencyAssignment_6_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13036:1: ( ( ruleDependency ) ) + // InternalRos1Parser.g:13037:2: ( ruleDependency ) + { + // InternalRos1Parser.g:13037:2: ( ruleDependency ) + // InternalRos1Parser.g:13038:3: ruleDependency + { + before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); + pushFollow(FOLLOW_2); + ruleDependency(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__DependencyAssignment_6_2" + + + // $ANTLR start "rule__Package_Impl__DependencyAssignment_6_3_1" + // InternalRos1Parser.g:13047:1: rule__Package_Impl__DependencyAssignment_6_3_1 : ( ruleDependency ) ; + public final void rule__Package_Impl__DependencyAssignment_6_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13051:1: ( ( ruleDependency ) ) + // InternalRos1Parser.g:13052:2: ( ruleDependency ) + { + // InternalRos1Parser.g:13052:2: ( ruleDependency ) + // InternalRos1Parser.g:13053:3: ruleDependency + { + before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + pushFollow(FOLLOW_2); + ruleDependency(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__DependencyAssignment_6_3_1" + + + // $ANTLR start "rule__Artifact__NameAssignment_1" + // InternalRos1Parser.g:13062:1: rule__Artifact__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__Artifact__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13066:1: ( ( ruleRosNames ) ) + // InternalRos1Parser.g:13067:2: ( ruleRosNames ) + { + // InternalRos1Parser.g:13067:2: ( ruleRosNames ) + // InternalRos1Parser.g:13068: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:13077:1: rule__Artifact__NodeAssignment_4 : ( ruleNode ) ; + public final void rule__Artifact__NodeAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13081:1: ( ( ruleNode ) ) + // InternalRos1Parser.g:13082:2: ( ruleNode ) + { + // InternalRos1Parser.g:13082:2: ( ruleNode ) + // InternalRos1Parser.g:13083: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:13092:1: rule__Node__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__Node__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13096:1: ( ( ruleRosNames ) ) + // InternalRos1Parser.g:13097:2: ( ruleRosNames ) + { + // InternalRos1Parser.g:13097:2: ( ruleRosNames ) + // InternalRos1Parser.g:13098: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_0_2" + // InternalRos1Parser.g:13107:1: rule__Node__PublisherAssignment_3_0_2 : ( rulePublisher ) ; + public final void rule__Node__PublisherAssignment_3_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13111:1: ( ( rulePublisher ) ) + // InternalRos1Parser.g:13112:2: ( rulePublisher ) + { + // InternalRos1Parser.g:13112:2: ( rulePublisher ) + // InternalRos1Parser.g:13113:3: rulePublisher + { + before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); + pushFollow(FOLLOW_2); + rulePublisher(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__PublisherAssignment_3_0_2" + + + // $ANTLR start "rule__Node__SubscriberAssignment_3_1_2" + // InternalRos1Parser.g:13122:1: rule__Node__SubscriberAssignment_3_1_2 : ( ruleSubscriber ) ; + public final void rule__Node__SubscriberAssignment_3_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13126:1: ( ( ruleSubscriber ) ) + // InternalRos1Parser.g:13127:2: ( ruleSubscriber ) + { + // InternalRos1Parser.g:13127:2: ( ruleSubscriber ) + // InternalRos1Parser.g:13128:3: ruleSubscriber + { + before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); + pushFollow(FOLLOW_2); + ruleSubscriber(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__SubscriberAssignment_3_1_2" + + + // $ANTLR start "rule__Node__ServiceserverAssignment_3_2_2" + // InternalRos1Parser.g:13137:1: rule__Node__ServiceserverAssignment_3_2_2 : ( ruleServiceServer ) ; + public final void rule__Node__ServiceserverAssignment_3_2_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13141:1: ( ( ruleServiceServer ) ) + // InternalRos1Parser.g:13142:2: ( ruleServiceServer ) + { + // InternalRos1Parser.g:13142:2: ( ruleServiceServer ) + // InternalRos1Parser.g:13143:3: ruleServiceServer + { + before(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); + pushFollow(FOLLOW_2); + ruleServiceServer(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__ServiceserverAssignment_3_2_2" + + + // $ANTLR start "rule__Node__ServiceclientAssignment_3_3_2" + // InternalRos1Parser.g:13152:1: rule__Node__ServiceclientAssignment_3_3_2 : ( ruleServiceClient ) ; + public final void rule__Node__ServiceclientAssignment_3_3_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13156:1: ( ( ruleServiceClient ) ) + // InternalRos1Parser.g:13157:2: ( ruleServiceClient ) + { + // InternalRos1Parser.g:13157:2: ( ruleServiceClient ) + // InternalRos1Parser.g:13158:3: ruleServiceClient + { + before(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); + pushFollow(FOLLOW_2); + ruleServiceClient(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__ServiceclientAssignment_3_3_2" + + + // $ANTLR start "rule__Node__ActionserverAssignment_3_4_2" + // InternalRos1Parser.g:13167:1: rule__Node__ActionserverAssignment_3_4_2 : ( ruleActionServer ) ; + public final void rule__Node__ActionserverAssignment_3_4_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13171:1: ( ( ruleActionServer ) ) + // InternalRos1Parser.g:13172:2: ( ruleActionServer ) + { + // InternalRos1Parser.g:13172:2: ( ruleActionServer ) + // InternalRos1Parser.g:13173:3: ruleActionServer + { + before(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); + pushFollow(FOLLOW_2); + ruleActionServer(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__ActionserverAssignment_3_4_2" + + + // $ANTLR start "rule__Node__ActionclientAssignment_3_5_2" + // InternalRos1Parser.g:13182:1: rule__Node__ActionclientAssignment_3_5_2 : ( ruleActionClient ) ; + public final void rule__Node__ActionclientAssignment_3_5_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13186:1: ( ( ruleActionClient ) ) + // InternalRos1Parser.g:13187:2: ( ruleActionClient ) + { + // InternalRos1Parser.g:13187:2: ( ruleActionClient ) + // InternalRos1Parser.g:13188:3: ruleActionClient + { + before(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); + pushFollow(FOLLOW_2); + ruleActionClient(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__ActionclientAssignment_3_5_2" + + + // $ANTLR start "rule__Node__ParameterAssignment_3_6_2" + // InternalRos1Parser.g:13197:1: rule__Node__ParameterAssignment_3_6_2 : ( ruleParameter ) ; + public final void rule__Node__ParameterAssignment_3_6_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13201:1: ( ( ruleParameter ) ) + // InternalRos1Parser.g:13202:2: ( ruleParameter ) + { + // InternalRos1Parser.g:13202:2: ( ruleParameter ) + // InternalRos1Parser.g:13203:3: ruleParameter + { + before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); + pushFollow(FOLLOW_2); + ruleParameter(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__ParameterAssignment_3_6_2" + + + // $ANTLR start "rule__TopicSpec__NameAssignment_2" + // InternalRos1Parser.g:13212:1: rule__TopicSpec__NameAssignment_2 : ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) ; + public final void rule__TopicSpec__NameAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13216:1: ( ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) ) + // InternalRos1Parser.g:13217:2: ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) + { + // InternalRos1Parser.g:13217:2: ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) + // InternalRos1Parser.g:13218:3: ( rule__TopicSpec__NameAlternatives_2_0 ) + { + before(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); + // InternalRos1Parser.g:13219:3: ( rule__TopicSpec__NameAlternatives_2_0 ) + // InternalRos1Parser.g:13219:4: rule__TopicSpec__NameAlternatives_2_0 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__NameAlternatives_2_0(); + + state._fsp--; + + + } + + after(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__NameAssignment_2" + + + // $ANTLR start "rule__TopicSpec__MessageAssignment_5_1" + // InternalRos1Parser.g:13227:1: rule__TopicSpec__MessageAssignment_5_1 : ( ruleMessageDefinition ) ; + public final void rule__TopicSpec__MessageAssignment_5_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13231:1: ( ( ruleMessageDefinition ) ) + // InternalRos1Parser.g:13232:2: ( ruleMessageDefinition ) + { + // InternalRos1Parser.g:13232:2: ( ruleMessageDefinition ) + // InternalRos1Parser.g:13233:3: ruleMessageDefinition + { + before(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__MessageAssignment_5_1" + + + // $ANTLR start "rule__ServiceSpec__NameAssignment_2" + // InternalRos1Parser.g:13242:1: rule__ServiceSpec__NameAssignment_2 : ( ruleEString ) ; + public final void rule__ServiceSpec__NameAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13246:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:13247:2: ( ruleEString ) + { + // InternalRos1Parser.g:13247:2: ( ruleEString ) + // InternalRos1Parser.g:13248:3: ruleEString + { + before(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__NameAssignment_2" + + + // $ANTLR start "rule__ServiceSpec__RequestAssignment_5_1" + // InternalRos1Parser.g:13257:1: rule__ServiceSpec__RequestAssignment_5_1 : ( ruleMessageDefinition ) ; + public final void rule__ServiceSpec__RequestAssignment_5_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13261:1: ( ( ruleMessageDefinition ) ) + // InternalRos1Parser.g:13262:2: ( ruleMessageDefinition ) + { + // InternalRos1Parser.g:13262:2: ( ruleMessageDefinition ) + // InternalRos1Parser.g:13263:3: ruleMessageDefinition + { + before(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__RequestAssignment_5_1" + + + // $ANTLR start "rule__ServiceSpec__ResponseAssignment_7_1" + // InternalRos1Parser.g:13272:1: rule__ServiceSpec__ResponseAssignment_7_1 : ( ruleMessageDefinition ) ; + public final void rule__ServiceSpec__ResponseAssignment_7_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13276:1: ( ( ruleMessageDefinition ) ) + // InternalRos1Parser.g:13277:2: ( ruleMessageDefinition ) + { + // InternalRos1Parser.g:13277:2: ( ruleMessageDefinition ) + // InternalRos1Parser.g:13278:3: ruleMessageDefinition + { + before(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__ResponseAssignment_7_1" + + + // $ANTLR start "rule__ActionSpec__NameAssignment_2" + // InternalRos1Parser.g:13287:1: rule__ActionSpec__NameAssignment_2 : ( ruleEString ) ; + public final void rule__ActionSpec__NameAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13291:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:13292:2: ( ruleEString ) + { + // InternalRos1Parser.g:13292:2: ( ruleEString ) + // InternalRos1Parser.g:13293:3: ruleEString + { + before(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__NameAssignment_2" + + + // $ANTLR start "rule__ActionSpec__GoalAssignment_5_1" + // InternalRos1Parser.g:13302:1: rule__ActionSpec__GoalAssignment_5_1 : ( ruleMessageDefinition ) ; + public final void rule__ActionSpec__GoalAssignment_5_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13306:1: ( ( ruleMessageDefinition ) ) + // InternalRos1Parser.g:13307:2: ( ruleMessageDefinition ) + { + // InternalRos1Parser.g:13307:2: ( ruleMessageDefinition ) + // InternalRos1Parser.g:13308:3: ruleMessageDefinition + { + before(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__GoalAssignment_5_1" + + + // $ANTLR start "rule__ActionSpec__ResultAssignment_7_1" + // InternalRos1Parser.g:13317:1: rule__ActionSpec__ResultAssignment_7_1 : ( ruleMessageDefinition ) ; + public final void rule__ActionSpec__ResultAssignment_7_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13321:1: ( ( ruleMessageDefinition ) ) + // InternalRos1Parser.g:13322:2: ( ruleMessageDefinition ) + { + // InternalRos1Parser.g:13322:2: ( ruleMessageDefinition ) + // InternalRos1Parser.g:13323:3: ruleMessageDefinition + { + before(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__ResultAssignment_7_1" + + + // $ANTLR start "rule__ActionSpec__FeedbackAssignment_9_1" + // InternalRos1Parser.g:13332:1: rule__ActionSpec__FeedbackAssignment_9_1 : ( ruleMessageDefinition ) ; + public final void rule__ActionSpec__FeedbackAssignment_9_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13336:1: ( ( ruleMessageDefinition ) ) + // InternalRos1Parser.g:13337:2: ( ruleMessageDefinition ) + { + // InternalRos1Parser.g:13337:2: ( ruleMessageDefinition ) + // InternalRos1Parser.g:13338:3: ruleMessageDefinition + { + before(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__FeedbackAssignment_9_1" + + + // $ANTLR start "rule__MessageDefinition__MessagePartAssignment_1" + // InternalRos1Parser.g:13347:1: rule__MessageDefinition__MessagePartAssignment_1 : ( ruleMessagePart ) ; + public final void rule__MessageDefinition__MessagePartAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13351:1: ( ( ruleMessagePart ) ) + // InternalRos1Parser.g:13352:2: ( ruleMessagePart ) + { + // InternalRos1Parser.g:13352:2: ( ruleMessagePart ) + // InternalRos1Parser.g:13353:3: ruleMessagePart + { + before(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleMessagePart(); + + state._fsp--; + + after(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessageDefinition__MessagePartAssignment_1" + + + // $ANTLR start "rule__Publisher__NameAssignment_1" + // InternalRos1Parser.g:13362:1: rule__Publisher__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Publisher__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13366:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:13367:2: ( ruleEString ) + { + // InternalRos1Parser.g:13367:2: ( ruleEString ) + // InternalRos1Parser.g:13368: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:13377:1: rule__Publisher__MessageAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__Publisher__MessageAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13381:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:13382:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:13382:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:13383:3: ( ruleEString ) + { + before(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + // InternalRos1Parser.g:13384:3: ( ruleEString ) + // InternalRos1Parser.g:13385: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__Publisher__NamespaceAssignment_6_1" + // InternalRos1Parser.g:13396:1: rule__Publisher__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__Publisher__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13400:1: ( ( ruleNamespace ) ) + // InternalRos1Parser.g:13401:2: ( ruleNamespace ) + { + // InternalRos1Parser.g:13401:2: ( ruleNamespace ) + // InternalRos1Parser.g:13402:3: ruleNamespace + { + before(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__Subscriber__NameAssignment_1" + // InternalRos1Parser.g:13411:1: rule__Subscriber__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Subscriber__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13415:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:13416:2: ( ruleEString ) + { + // InternalRos1Parser.g:13416:2: ( ruleEString ) + // InternalRos1Parser.g:13417: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:13426:1: rule__Subscriber__MessageAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__Subscriber__MessageAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13430:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:13431:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:13431:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:13432:3: ( ruleEString ) + { + before(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + // InternalRos1Parser.g:13433:3: ( ruleEString ) + // InternalRos1Parser.g:13434: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__Subscriber__NamespaceAssignment_6_1" + // InternalRos1Parser.g:13445:1: rule__Subscriber__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__Subscriber__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13449:1: ( ( ruleNamespace ) ) + // InternalRos1Parser.g:13450:2: ( ruleNamespace ) + { + // InternalRos1Parser.g:13450:2: ( ruleNamespace ) + // InternalRos1Parser.g:13451:3: ruleNamespace + { + before(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__ServiceServer__NameAssignment_1" + // InternalRos1Parser.g:13460:1: rule__ServiceServer__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ServiceServer__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13464:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:13465:2: ( ruleEString ) + { + // InternalRos1Parser.g:13465:2: ( ruleEString ) + // InternalRos1Parser.g:13466:3: ruleEString + { + before(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__NameAssignment_1" + + + // $ANTLR start "rule__ServiceServer__ServiceAssignment_5" + // InternalRos1Parser.g:13475:1: rule__ServiceServer__ServiceAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__ServiceServer__ServiceAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13479:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:13480:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:13480:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:13481:3: ( ruleEString ) + { + before(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); + // InternalRos1Parser.g:13482:3: ( ruleEString ) + // InternalRos1Parser.g:13483:4: ruleEString + { + before(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); + + } + + after(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__ServiceAssignment_5" + + + // $ANTLR start "rule__ServiceServer__NamespaceAssignment_6_1" + // InternalRos1Parser.g:13494:1: rule__ServiceServer__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__ServiceServer__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13498:1: ( ( ruleNamespace ) ) + // InternalRos1Parser.g:13499:2: ( ruleNamespace ) + { + // InternalRos1Parser.g:13499:2: ( ruleNamespace ) + // InternalRos1Parser.g:13500:3: ruleNamespace + { + before(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__ServiceClient__NameAssignment_1" + // InternalRos1Parser.g:13509:1: rule__ServiceClient__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ServiceClient__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13513:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:13514:2: ( ruleEString ) + { + // InternalRos1Parser.g:13514:2: ( ruleEString ) + // InternalRos1Parser.g:13515:3: ruleEString + { + before(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__NameAssignment_1" + + + // $ANTLR start "rule__ServiceClient__ServiceAssignment_5" + // InternalRos1Parser.g:13524:1: rule__ServiceClient__ServiceAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__ServiceClient__ServiceAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13528:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:13529:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:13529:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:13530:3: ( ruleEString ) + { + before(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); + // InternalRos1Parser.g:13531:3: ( ruleEString ) + // InternalRos1Parser.g:13532:4: ruleEString + { + before(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); + + } + + after(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__ServiceAssignment_5" + + + // $ANTLR start "rule__ServiceClient__NamespaceAssignment_6_1" + // InternalRos1Parser.g:13543:1: rule__ServiceClient__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__ServiceClient__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13547:1: ( ( ruleNamespace ) ) + // InternalRos1Parser.g:13548:2: ( ruleNamespace ) + { + // InternalRos1Parser.g:13548:2: ( ruleNamespace ) + // InternalRos1Parser.g:13549:3: ruleNamespace + { + before(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__ActionServer__NameAssignment_1" + // InternalRos1Parser.g:13558:1: rule__ActionServer__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ActionServer__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13562:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:13563:2: ( ruleEString ) + { + // InternalRos1Parser.g:13563:2: ( ruleEString ) + // InternalRos1Parser.g:13564:3: ruleEString + { + before(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__NameAssignment_1" + + + // $ANTLR start "rule__ActionServer__ActionAssignment_5" + // InternalRos1Parser.g:13573:1: rule__ActionServer__ActionAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__ActionServer__ActionAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13577:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:13578:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:13578:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:13579:3: ( ruleEString ) + { + before(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); + // InternalRos1Parser.g:13580:3: ( ruleEString ) + // InternalRos1Parser.g:13581:4: ruleEString + { + before(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); + + } + + after(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__ActionAssignment_5" + + + // $ANTLR start "rule__ActionServer__NamespaceAssignment_6_1" + // InternalRos1Parser.g:13592:1: rule__ActionServer__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__ActionServer__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13596:1: ( ( ruleNamespace ) ) + // InternalRos1Parser.g:13597:2: ( ruleNamespace ) + { + // InternalRos1Parser.g:13597:2: ( ruleNamespace ) + // InternalRos1Parser.g:13598:3: ruleNamespace + { + before(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__ActionClient__NameAssignment_1" + // InternalRos1Parser.g:13607:1: rule__ActionClient__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ActionClient__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13611:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:13612:2: ( ruleEString ) + { + // InternalRos1Parser.g:13612:2: ( ruleEString ) + // InternalRos1Parser.g:13613:3: ruleEString + { + before(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__NameAssignment_1" + + + // $ANTLR start "rule__ActionClient__ActionAssignment_5" + // InternalRos1Parser.g:13622:1: rule__ActionClient__ActionAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__ActionClient__ActionAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13626:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:13627:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:13627:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:13628:3: ( ruleEString ) + { + before(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); + // InternalRos1Parser.g:13629:3: ( ruleEString ) + // InternalRos1Parser.g:13630:4: ruleEString + { + before(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); + + } + + after(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__ActionAssignment_5" + + + // $ANTLR start "rule__ActionClient__NamespaceAssignment_6_1" + // InternalRos1Parser.g:13641:1: rule__ActionClient__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__ActionClient__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13645:1: ( ( ruleNamespace ) ) + // InternalRos1Parser.g:13646:2: ( ruleNamespace ) + { + // InternalRos1Parser.g:13646:2: ( ruleNamespace ) + // InternalRos1Parser.g:13647:3: ruleNamespace + { + before(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__PackageDependency__PackageAssignment" + // InternalRos1Parser.g:13656:1: rule__PackageDependency__PackageAssignment : ( ( ruleEString ) ) ; + public final void rule__PackageDependency__PackageAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13660:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:13661:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:13661:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:13662:3: ( ruleEString ) + { + before(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); + // InternalRos1Parser.g:13663:3: ( ruleEString ) + // InternalRos1Parser.g:13664: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:13675:1: rule__ExternalDependency__NameAssignment_2 : ( ruleEString ) ; + public final void rule__ExternalDependency__NameAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13679:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:13680:2: ( ruleEString ) + { + // InternalRos1Parser.g:13680:2: ( ruleEString ) + // InternalRos1Parser.g:13681: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" + + + // $ANTLR start "rule__GlobalNamespace__PartsAssignment_2_1" + // InternalRos1Parser.g:13690:1: rule__GlobalNamespace__PartsAssignment_2_1 : ( ruleGraphName ) ; + public final void rule__GlobalNamespace__PartsAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13694:1: ( ( ruleGraphName ) ) + // InternalRos1Parser.g:13695:2: ( ruleGraphName ) + { + // InternalRos1Parser.g:13695:2: ( ruleGraphName ) + // InternalRos1Parser.g:13696:3: ruleGraphName + { + before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__PartsAssignment_2_1" + + + // $ANTLR start "rule__GlobalNamespace__PartsAssignment_2_2_1" + // InternalRos1Parser.g:13705:1: rule__GlobalNamespace__PartsAssignment_2_2_1 : ( ruleGraphName ) ; + public final void rule__GlobalNamespace__PartsAssignment_2_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13709:1: ( ( ruleGraphName ) ) + // InternalRos1Parser.g:13710:2: ( ruleGraphName ) + { + // InternalRos1Parser.g:13710:2: ( ruleGraphName ) + // InternalRos1Parser.g:13711:3: ruleGraphName + { + before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__PartsAssignment_2_2_1" + + + // $ANTLR start "rule__RelativeNamespace_Impl__PartsAssignment_2_1" + // InternalRos1Parser.g:13720:1: rule__RelativeNamespace_Impl__PartsAssignment_2_1 : ( ruleGraphName ) ; + public final void rule__RelativeNamespace_Impl__PartsAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13724:1: ( ( ruleGraphName ) ) + // InternalRos1Parser.g:13725:2: ( ruleGraphName ) + { + // InternalRos1Parser.g:13725:2: ( ruleGraphName ) + // InternalRos1Parser.g:13726:3: ruleGraphName + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__PartsAssignment_2_1" + + + // $ANTLR start "rule__RelativeNamespace_Impl__PartsAssignment_2_2_1" + // InternalRos1Parser.g:13735:1: rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 : ( ruleGraphName ) ; + public final void rule__RelativeNamespace_Impl__PartsAssignment_2_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13739:1: ( ( ruleGraphName ) ) + // InternalRos1Parser.g:13740:2: ( ruleGraphName ) + { + // InternalRos1Parser.g:13740:2: ( ruleGraphName ) + // InternalRos1Parser.g:13741:3: ruleGraphName + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__PartsAssignment_2_2_1" + + + // $ANTLR start "rule__PrivateNamespace__PartsAssignment_2_1" + // InternalRos1Parser.g:13750:1: rule__PrivateNamespace__PartsAssignment_2_1 : ( ruleGraphName ) ; + public final void rule__PrivateNamespace__PartsAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13754:1: ( ( ruleGraphName ) ) + // InternalRos1Parser.g:13755:2: ( ruleGraphName ) + { + // InternalRos1Parser.g:13755:2: ( ruleGraphName ) + // InternalRos1Parser.g:13756:3: ruleGraphName + { + before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__PartsAssignment_2_1" + + + // $ANTLR start "rule__PrivateNamespace__PartsAssignment_2_2_1" + // InternalRos1Parser.g:13765:1: rule__PrivateNamespace__PartsAssignment_2_2_1 : ( ruleGraphName ) ; + public final void rule__PrivateNamespace__PartsAssignment_2_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13769:1: ( ( ruleGraphName ) ) + // InternalRos1Parser.g:13770:2: ( ruleGraphName ) + { + // InternalRos1Parser.g:13770:2: ( ruleGraphName ) + // InternalRos1Parser.g:13771:3: ruleGraphName + { + before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__PartsAssignment_2_2_1" + + + // $ANTLR start "rule__Parameter__NameAssignment_1" + // InternalRos1Parser.g:13780:1: rule__Parameter__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Parameter__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13784:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:13785:2: ( ruleEString ) + { + // InternalRos1Parser.g:13785:2: ( ruleEString ) + // InternalRos1Parser.g:13786: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__Parameter__TypeAssignment_5" + // InternalRos1Parser.g:13795:1: rule__Parameter__TypeAssignment_5 : ( ruleParameterType ) ; + public final void rule__Parameter__TypeAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13799:1: ( ( ruleParameterType ) ) + // InternalRos1Parser.g:13800:2: ( ruleParameterType ) + { + // InternalRos1Parser.g:13800:2: ( ruleParameterType ) + // InternalRos1Parser.g:13801:3: ruleParameterType + { + before(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); + pushFollow(FOLLOW_2); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__TypeAssignment_5" + + + // $ANTLR start "rule__Parameter__NamespaceAssignment_6_1" + // InternalRos1Parser.g:13810:1: rule__Parameter__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__Parameter__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13814:1: ( ( ruleNamespace ) ) + // InternalRos1Parser.g:13815:2: ( ruleNamespace ) + { + // InternalRos1Parser.g:13815:2: ( ruleNamespace ) + // InternalRos1Parser.g:13816:3: ruleNamespace + { + before(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__ParameterListType__SequenceAssignment_3" + // InternalRos1Parser.g:13825:1: rule__ParameterListType__SequenceAssignment_3 : ( ruleParameterType ) ; + public final void rule__ParameterListType__SequenceAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13829:1: ( ( ruleParameterType ) ) + // InternalRos1Parser.g:13830:2: ( ruleParameterType ) + { + // InternalRos1Parser.g:13830:2: ( ruleParameterType ) + // InternalRos1Parser.g:13831:3: ruleParameterType + { + before(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); + pushFollow(FOLLOW_2); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__SequenceAssignment_3" + + + // $ANTLR start "rule__ParameterListType__SequenceAssignment_4_1" + // InternalRos1Parser.g:13840:1: rule__ParameterListType__SequenceAssignment_4_1 : ( ruleParameterType ) ; + public final void rule__ParameterListType__SequenceAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13844:1: ( ( ruleParameterType ) ) + // InternalRos1Parser.g:13845:2: ( ruleParameterType ) + { + // InternalRos1Parser.g:13845:2: ( ruleParameterType ) + // InternalRos1Parser.g:13846:3: ruleParameterType + { + before(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); + pushFollow(FOLLOW_2); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__SequenceAssignment_4_1" + + + // $ANTLR start "rule__ParameterStructType__ParameterstructypetmemberAssignment_3" + // InternalRos1Parser.g:13855:1: rule__ParameterStructType__ParameterstructypetmemberAssignment_3 : ( ruleParameterStructTypeMember ) ; + public final void rule__ParameterStructType__ParameterstructypetmemberAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13859:1: ( ( ruleParameterStructTypeMember ) ) + // InternalRos1Parser.g:13860:2: ( ruleParameterStructTypeMember ) + { + // InternalRos1Parser.g:13860:2: ( ruleParameterStructTypeMember ) + // InternalRos1Parser.g:13861:3: ruleParameterStructTypeMember + { + before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); + pushFollow(FOLLOW_2); + ruleParameterStructTypeMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__ParameterstructypetmemberAssignment_3" + + + // $ANTLR start "rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1" + // InternalRos1Parser.g:13870:1: rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 : ( ruleParameterStructTypeMember ) ; + public final void rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13874:1: ( ( ruleParameterStructTypeMember ) ) + // InternalRos1Parser.g:13875:2: ( ruleParameterStructTypeMember ) + { + // InternalRos1Parser.g:13875:2: ( ruleParameterStructTypeMember ) + // InternalRos1Parser.g:13876:3: ruleParameterStructTypeMember + { + before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); + pushFollow(FOLLOW_2); + ruleParameterStructTypeMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1" + + + // $ANTLR start "rule__ParameterIntegerType__DefaultAssignment_2_1" + // InternalRos1Parser.g:13885:1: rule__ParameterIntegerType__DefaultAssignment_2_1 : ( ruleParameterInteger ) ; + public final void rule__ParameterIntegerType__DefaultAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13889:1: ( ( ruleParameterInteger ) ) + // InternalRos1Parser.g:13890:2: ( ruleParameterInteger ) + { + // InternalRos1Parser.g:13890:2: ( ruleParameterInteger ) + // InternalRos1Parser.g:13891:3: ruleParameterInteger + { + before(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleParameterInteger(); + + state._fsp--; + + after(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__DefaultAssignment_2_1" + + + // $ANTLR start "rule__ParameterStringType__DefaultAssignment_2_1" + // InternalRos1Parser.g:13900:1: rule__ParameterStringType__DefaultAssignment_2_1 : ( ruleParameterString ) ; + public final void rule__ParameterStringType__DefaultAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13904:1: ( ( ruleParameterString ) ) + // InternalRos1Parser.g:13905:2: ( ruleParameterString ) + { + // InternalRos1Parser.g:13905:2: ( ruleParameterString ) + // InternalRos1Parser.g:13906:3: ruleParameterString + { + before(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleParameterString(); + + state._fsp--; + + after(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__DefaultAssignment_2_1" + + + // $ANTLR start "rule__ParameterDoubleType__DefaultAssignment_2_1" + // InternalRos1Parser.g:13915:1: rule__ParameterDoubleType__DefaultAssignment_2_1 : ( ruleParameterDouble ) ; + public final void rule__ParameterDoubleType__DefaultAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13919:1: ( ( ruleParameterDouble ) ) + // InternalRos1Parser.g:13920:2: ( ruleParameterDouble ) + { + // InternalRos1Parser.g:13920:2: ( ruleParameterDouble ) + // InternalRos1Parser.g:13921:3: ruleParameterDouble + { + before(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleParameterDouble(); + + state._fsp--; + + after(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__DefaultAssignment_2_1" + + + // $ANTLR start "rule__ParameterBooleanType__DefaultAssignment_2_1" + // InternalRos1Parser.g:13930:1: rule__ParameterBooleanType__DefaultAssignment_2_1 : ( ruleParameterBoolean ) ; + public final void rule__ParameterBooleanType__DefaultAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13934:1: ( ( ruleParameterBoolean ) ) + // InternalRos1Parser.g:13935:2: ( ruleParameterBoolean ) + { + // InternalRos1Parser.g:13935:2: ( ruleParameterBoolean ) + // InternalRos1Parser.g:13936:3: ruleParameterBoolean + { + before(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleParameterBoolean(); + + state._fsp--; + + after(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__DefaultAssignment_2_1" + + + // $ANTLR start "rule__ParameterBase64Type__DefaultAssignment_2_1" + // InternalRos1Parser.g:13945:1: rule__ParameterBase64Type__DefaultAssignment_2_1 : ( ruleParameterBase64 ) ; + public final void rule__ParameterBase64Type__DefaultAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13949:1: ( ( ruleParameterBase64 ) ) + // InternalRos1Parser.g:13950:2: ( ruleParameterBase64 ) + { + // InternalRos1Parser.g:13950:2: ( ruleParameterBase64 ) + // InternalRos1Parser.g:13951:3: ruleParameterBase64 + { + before(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleParameterBase64(); + + state._fsp--; + + after(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__DefaultAssignment_2_1" + + + // $ANTLR start "rule__ParameterArrayType__TypeAssignment_3" + // InternalRos1Parser.g:13960:1: rule__ParameterArrayType__TypeAssignment_3 : ( ruleParameterType ) ; + public final void rule__ParameterArrayType__TypeAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13964:1: ( ( ruleParameterType ) ) + // InternalRos1Parser.g:13965:2: ( ruleParameterType ) + { + // InternalRos1Parser.g:13965:2: ( ruleParameterType ) + // InternalRos1Parser.g:13966:3: ruleParameterType + { + before(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); + pushFollow(FOLLOW_2); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__TypeAssignment_3" + + + // $ANTLR start "rule__ParameterArrayType__DefaultAssignment_4_1" + // InternalRos1Parser.g:13975:1: rule__ParameterArrayType__DefaultAssignment_4_1 : ( ruleParameterList ) ; + public final void rule__ParameterArrayType__DefaultAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13979:1: ( ( ruleParameterList ) ) + // InternalRos1Parser.g:13980:2: ( ruleParameterList ) + { + // InternalRos1Parser.g:13980:2: ( ruleParameterList ) + // InternalRos1Parser.g:13981:3: ruleParameterList + { + before(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); + pushFollow(FOLLOW_2); + ruleParameterList(); + + state._fsp--; + + after(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__DefaultAssignment_4_1" + + + // $ANTLR start "rule__ParameterList__ValueAssignment_2" + // InternalRos1Parser.g:13990:1: rule__ParameterList__ValueAssignment_2 : ( ruleParameterValue ) ; + public final void rule__ParameterList__ValueAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:13994:1: ( ( ruleParameterValue ) ) + // InternalRos1Parser.g:13995:2: ( ruleParameterValue ) + { + // InternalRos1Parser.g:13995:2: ( ruleParameterValue ) + // InternalRos1Parser.g:13996:3: ruleParameterValue + { + before(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); + pushFollow(FOLLOW_2); + ruleParameterValue(); + + state._fsp--; + + after(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__ValueAssignment_2" + + + // $ANTLR start "rule__ParameterList__ValueAssignment_3_1" + // InternalRos1Parser.g:14005:1: rule__ParameterList__ValueAssignment_3_1 : ( ruleParameterValue ) ; + public final void rule__ParameterList__ValueAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14009:1: ( ( ruleParameterValue ) ) + // InternalRos1Parser.g:14010:2: ( ruleParameterValue ) + { + // InternalRos1Parser.g:14010:2: ( ruleParameterValue ) + // InternalRos1Parser.g:14011:3: ruleParameterValue + { + before(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); + pushFollow(FOLLOW_2); + ruleParameterValue(); + + state._fsp--; + + after(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__ValueAssignment_3_1" + + + // $ANTLR start "rule__ParameterAny__ValueAssignment_2_1" + // InternalRos1Parser.g:14020:1: rule__ParameterAny__ValueAssignment_2_1 : ( ruleEString ) ; + public final void rule__ParameterAny__ValueAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14024:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:14025:2: ( ruleEString ) + { + // InternalRos1Parser.g:14025:2: ( ruleEString ) + // InternalRos1Parser.g:14026:3: ruleEString + { + before(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__ValueAssignment_2_1" + + + // $ANTLR start "rule__ParameterString__ValueAssignment" + // InternalRos1Parser.g:14035:1: rule__ParameterString__ValueAssignment : ( ruleEString ) ; + public final void rule__ParameterString__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14039:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:14040:2: ( ruleEString ) + { + // InternalRos1Parser.g:14040:2: ( ruleEString ) + // InternalRos1Parser.g:14041:3: ruleEString + { + before(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterString__ValueAssignment" + + + // $ANTLR start "rule__ParameterBase64__ValueAssignment" + // InternalRos1Parser.g:14050:1: rule__ParameterBase64__ValueAssignment : ( ruleBase64Binary ) ; + public final void rule__ParameterBase64__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14054:1: ( ( ruleBase64Binary ) ) + // InternalRos1Parser.g:14055:2: ( ruleBase64Binary ) + { + // InternalRos1Parser.g:14055:2: ( ruleBase64Binary ) + // InternalRos1Parser.g:14056:3: ruleBase64Binary + { + before(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleBase64Binary(); + + state._fsp--; + + after(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64__ValueAssignment" + + + // $ANTLR start "rule__ParameterInteger__ValueAssignment" + // InternalRos1Parser.g:14065:1: rule__ParameterInteger__ValueAssignment : ( ruleInteger0 ) ; + public final void rule__ParameterInteger__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14069:1: ( ( ruleInteger0 ) ) + // InternalRos1Parser.g:14070:2: ( ruleInteger0 ) + { + // InternalRos1Parser.g:14070:2: ( ruleInteger0 ) + // InternalRos1Parser.g:14071:3: ruleInteger0 + { + before(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleInteger0(); + + state._fsp--; + + after(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterInteger__ValueAssignment" + + + // $ANTLR start "rule__ParameterDouble__ValueAssignment" + // InternalRos1Parser.g:14080:1: rule__ParameterDouble__ValueAssignment : ( ruleDouble0 ) ; + public final void rule__ParameterDouble__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14084:1: ( ( ruleDouble0 ) ) + // InternalRos1Parser.g:14085:2: ( ruleDouble0 ) + { + // InternalRos1Parser.g:14085:2: ( ruleDouble0 ) + // InternalRos1Parser.g:14086:3: ruleDouble0 + { + before(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleDouble0(); + + state._fsp--; + + after(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDouble__ValueAssignment" + + + // $ANTLR start "rule__ParameterBoolean__ValueAssignment" + // InternalRos1Parser.g:14095:1: rule__ParameterBoolean__ValueAssignment : ( ruleboolean0 ) ; + public final void rule__ParameterBoolean__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14099:1: ( ( ruleboolean0 ) ) + // InternalRos1Parser.g:14100:2: ( ruleboolean0 ) + { + // InternalRos1Parser.g:14100:2: ( ruleboolean0 ) + // InternalRos1Parser.g:14101:3: ruleboolean0 + { + before(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleboolean0(); + + state._fsp--; + + after(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBoolean__ValueAssignment" + + + // $ANTLR start "rule__ParameterStruct__ValueAssignment_1_1" + // InternalRos1Parser.g:14110:1: rule__ParameterStruct__ValueAssignment_1_1 : ( ruleParameterStructMember ) ; + public final void rule__ParameterStruct__ValueAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14114:1: ( ( ruleParameterStructMember ) ) + // InternalRos1Parser.g:14115:2: ( ruleParameterStructMember ) + { + // InternalRos1Parser.g:14115:2: ( ruleParameterStructMember ) + // InternalRos1Parser.g:14116:3: ruleParameterStructMember + { + before(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); + pushFollow(FOLLOW_2); + ruleParameterStructMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__ValueAssignment_1_1" + + + // $ANTLR start "rule__ParameterStruct__ValueAssignment_1_2_2" + // InternalRos1Parser.g:14125:1: rule__ParameterStruct__ValueAssignment_1_2_2 : ( ruleParameterStructMember ) ; + public final void rule__ParameterStruct__ValueAssignment_1_2_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14129:1: ( ( ruleParameterStructMember ) ) + // InternalRos1Parser.g:14130:2: ( ruleParameterStructMember ) + { + // InternalRos1Parser.g:14130:2: ( ruleParameterStructMember ) + // InternalRos1Parser.g:14131:3: ruleParameterStructMember + { + before(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); + pushFollow(FOLLOW_2); + ruleParameterStructMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__ValueAssignment_1_2_2" + + + // $ANTLR start "rule__ParameterDate__ValueAssignment" + // InternalRos1Parser.g:14140:1: rule__ParameterDate__ValueAssignment : ( ruleDateTime0 ) ; + public final void rule__ParameterDate__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14144:1: ( ( ruleDateTime0 ) ) + // InternalRos1Parser.g:14145:2: ( ruleDateTime0 ) + { + // InternalRos1Parser.g:14145:2: ( ruleDateTime0 ) + // InternalRos1Parser.g:14146:3: ruleDateTime0 + { + before(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleDateTime0(); + + state._fsp--; + + after(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDate__ValueAssignment" + + + // $ANTLR start "rule__ParameterStructMember__NameAssignment_1" + // InternalRos1Parser.g:14155:1: rule__ParameterStructMember__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ParameterStructMember__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14159:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:14160:2: ( ruleEString ) + { + // InternalRos1Parser.g:14160:2: ( ruleEString ) + // InternalRos1Parser.g:14161:3: ruleEString + { + before(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__NameAssignment_1" + + + // $ANTLR start "rule__ParameterStructMember__ValueAssignment_4" + // InternalRos1Parser.g:14170:1: rule__ParameterStructMember__ValueAssignment_4 : ( ruleParameterValue ) ; + public final void rule__ParameterStructMember__ValueAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14174:1: ( ( ruleParameterValue ) ) + // InternalRos1Parser.g:14175:2: ( ruleParameterValue ) + { + // InternalRos1Parser.g:14175:2: ( ruleParameterValue ) + // InternalRos1Parser.g:14176:3: ruleParameterValue + { + before(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); + pushFollow(FOLLOW_2); + ruleParameterValue(); + + state._fsp--; + + after(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__ValueAssignment_4" + + + // $ANTLR start "rule__ParameterStructTypeMember__NameAssignment_0" + // InternalRos1Parser.g:14185:1: rule__ParameterStructTypeMember__NameAssignment_0 : ( ruleEString ) ; + public final void rule__ParameterStructTypeMember__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14189:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:14190:2: ( ruleEString ) + { + // InternalRos1Parser.g:14190:2: ( ruleEString ) + // InternalRos1Parser.g:14191:3: ruleEString + { + before(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__NameAssignment_0" + + + // $ANTLR start "rule__ParameterStructTypeMember__TypeAssignment_1" + // InternalRos1Parser.g:14200:1: rule__ParameterStructTypeMember__TypeAssignment_1 : ( ruleParameterType ) ; + public final void rule__ParameterStructTypeMember__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14204:1: ( ( ruleParameterType ) ) + // InternalRos1Parser.g:14205:2: ( ruleParameterType ) + { + // InternalRos1Parser.g:14205:2: ( ruleParameterType ) + // InternalRos1Parser.g:14206:3: ruleParameterType + { + before(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__TypeAssignment_1" + + + // $ANTLR start "rule__MessagePart__TypeAssignment_0" + // InternalRos1Parser.g:14215:1: rule__MessagePart__TypeAssignment_0 : ( ruleAbstractType ) ; + public final void rule__MessagePart__TypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14219:1: ( ( ruleAbstractType ) ) + // InternalRos1Parser.g:14220:2: ( ruleAbstractType ) + { + // InternalRos1Parser.g:14220:2: ( ruleAbstractType ) + // InternalRos1Parser.g:14221:3: ruleAbstractType + { + before(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); + pushFollow(FOLLOW_2); + ruleAbstractType(); + + state._fsp--; + + after(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__TypeAssignment_0" + + + // $ANTLR start "rule__MessagePart__DataAssignment_1" + // InternalRos1Parser.g:14230:1: rule__MessagePart__DataAssignment_1 : ( ( rule__MessagePart__DataAlternatives_1_0 ) ) ; + public final void rule__MessagePart__DataAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14234:1: ( ( ( rule__MessagePart__DataAlternatives_1_0 ) ) ) + // InternalRos1Parser.g:14235:2: ( ( rule__MessagePart__DataAlternatives_1_0 ) ) + { + // InternalRos1Parser.g:14235:2: ( ( rule__MessagePart__DataAlternatives_1_0 ) ) + // InternalRos1Parser.g:14236:3: ( rule__MessagePart__DataAlternatives_1_0 ) + { + before(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0()); + // InternalRos1Parser.g:14237:3: ( rule__MessagePart__DataAlternatives_1_0 ) + // InternalRos1Parser.g:14237:4: rule__MessagePart__DataAlternatives_1_0 + { + pushFollow(FOLLOW_2); + rule__MessagePart__DataAlternatives_1_0(); + + state._fsp--; + + + } + + after(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__DataAssignment_1" + + + // $ANTLR start "rule__TopicSpecRef__TopicSpecAssignment" + // InternalRos1Parser.g:14245:1: rule__TopicSpecRef__TopicSpecAssignment : ( ( ruleEString ) ) ; + public final void rule__TopicSpecRef__TopicSpecAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14249:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:14250:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:14250:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:14251:3: ( ruleEString ) + { + before(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); + // InternalRos1Parser.g:14252:3: ( ruleEString ) + // InternalRos1Parser.g:14253:4: ruleEString + { + before(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_1()); + + } + + after(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpecRef__TopicSpecAssignment" + + + // $ANTLR start "rule__ArrayTopicSpecRef__TopicSpecAssignment_0" + // InternalRos1Parser.g:14264:1: rule__ArrayTopicSpecRef__TopicSpecAssignment_0 : ( ( ruleEString ) ) ; + public final void rule__ArrayTopicSpecRef__TopicSpecAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:14268:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:14269:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:14269:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:14270:3: ( ruleEString ) + { + before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); + // InternalRos1Parser.g:14271:3: ( ruleEString ) + // InternalRos1Parser.g:14272:4: ruleEString + { + before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_0_1()); + + } + + after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayTopicSpecRef__TopicSpecAssignment_0" + + // Delegated rules + + + protected DFA11 dfa11 = new DFA11(this); + static final String dfa_1s = "\42\uffff"; + static final String dfa_2s = "\36\uffff\2\41\2\uffff"; + static final String dfa_3s = "\1\27\35\uffff\2\32\2\uffff"; + static final String dfa_4s = "\1\140\35\uffff\2\156\2\uffff"; + static final String dfa_5s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\2\uffff\1\37\1\36"; + static final String dfa_6s = "\42\uffff}>"; + static final String[] dfa_7s = { + "\1\32\1\33\1\uffff\1\17\3\uffff\1\34\1\25\1\27\1\31\4\uffff\1\12\1\13\1\24\1\26\1\30\3\uffff\1\23\3\uffff\1\20\3\uffff\1\21\1\35\1\22\2\uffff\1\14\1\5\1\7\1\11\1\uffff\1\4\1\6\1\10\2\uffff\1\3\3\uffff\1\1\1\15\1\uffff\1\2\4\uffff\1\16\14\uffff\1\37\1\uffff\1\36", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\2\41\17\uffff\1\41\1\uffff\1\41\7\uffff\1\41\3\uffff\1\41\14\uffff\1\41\4\uffff\1\41\2\uffff\1\41\2\uffff\2\41\2\uffff\1\40\10\uffff\1\41\1\uffff\1\41\15\uffff\1\41", + "\2\41\17\uffff\1\41\1\uffff\1\41\7\uffff\1\41\3\uffff\1\41\14\uffff\1\41\4\uffff\1\41\2\uffff\1\41\2\uffff\2\41\2\uffff\1\40\10\uffff\1\41\1\uffff\1\41\15\uffff\1\41", + "", + "" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s); + static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s); + + class DFA11 extends DFA { + + public DFA11(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 11; + this.eot = dfa_1; + this.eof = dfa_2; + this.min = dfa_3; + this.max = dfa_4; + this.accept = dfa_5; + this.special = dfa_6; + this.transition = dfa_7; + } + public String getDescription() { + return "2652:1: rule__AbstractType__Alternatives : ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) );"; + } + } + + + 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[]{0x0000000000000000L,0x00000000C0008000L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000112000L,0x0000000010000000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000000L,0x0000000140000000L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000000L,0x00000000D0008000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000002L,0x00000000C0008000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000020L,0x0000000140000000L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0000000002400000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0400000000012000L,0x0000000010000000L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000001000000000L,0x0000000010012000L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000001000000002L,0x0000000000012000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000008L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x00000000000E1E00L,0x0000000010000000L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x00000000000E1E02L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000000L,0x0000000150000000L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000000002L,0x0000000140000000L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x000C000000000000L,0x0000000140000000L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000010000000L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000000000L,0x0000000018000000L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x79C447C3C5800000L,0x0000000140021627L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000020000000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000002000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000001000000000L,0x0000000000012000L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x8000000000000000L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000100000000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000400000L,0x0000000008000000L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x79C447C3C5800002L,0x0000000140021627L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x00000000000001C0L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000100L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000200000L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000040L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); + public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x001B800C00000000L,0x0000000000000100L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0010000000000000L}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000800000000L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000002000000000L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000000L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0008000000000000L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0002000000000000L}); + public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0000004000000000L}); + public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000400000000L}); + public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); + public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0001000000000000L}); + public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L}); + public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000002000000000L,0x0000000010000000L}); + public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000007941000000L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000008000L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); + public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L}); + public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x022028000C000000L,0x0000400140064840L}); + public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); + public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); + public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L}); + public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x1000000000000000L}); + public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); + public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x2000000000000000L}); + public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); + public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x4000000000000000L}); + public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000004000000000L}); + public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000008000000000L}); + public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0800000000000000L}); + public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); + public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); + public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000000004000000L}); + public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0040000000000000L}); + public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0100000000000000L}); + public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000400000000000L}); + public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000010000000000L}); + public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000080000000L}); + public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000020000000000L}); + public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000100000000L}); + public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000040000000000L}); + public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000200000000L}); + public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000800000L}); + public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000001000000L}); + public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000040000000L}); + public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0080000000000000L}); + public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0004000000000000L}); + public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); + +} \ 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..7a07c1570 --- /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,110 @@ +','=86 +':'=87 +'AmentPackage'=14 +'Any'=83 +'Array:'=47 +'Base64'=48 +'Boolean'=34 +'Date'=71 +'Double'=49 +'ExternalDependency'=5 +'GlobalNamespace'=8 +'GraphName'=21 +'Header'=50 +'Integer'=35 +'List'=72 +'ParameterAny'=15 +'ParameterStructMember'=4 +'PrivateNamespace'=7 +'RelativeNamespace'=6 +'String'=51 +'Struct'=52 +'['=88 +'[]'=85 +']'=89 +'action'=53 +'action:'=36 +'actionclient:'=11 +'actionserver:'=12 +'artifacts:'=20 +'bool'=73 +'bool[]'=54 +'byte'=74 +'byte[]'=55 +'default'=37 +'dependencies:'=13 +'duration'=26 +'feedback'=27 +'feedback:'=22 +'float32'=38 +'float32[]'=23 +'float64'=39 +'float64[]'=24 +'fromGitRepo:'=16 +'goal'=75 +'goal:'=63 +'int16'=64 +'int16[]'=40 +'int32'=65 +'int32[]'=41 +'int64'=66 +'int64[]'=42 +'int8'=76 +'int8[]'=56 +'message'=43 +'message:'=28 +'msg:'=77 +'name'=78 +'node'=79 +'node:'=67 +'ns:'=84 +'parameters:'=18 +'publishers:'=19 +'request:'=29 +'response:'=25 +'result'=57 +'result:'=44 +'service'=45 +'serviceclient:'=9 +'serviceserver:'=10 +'specs:'=58 +'srv:'=80 +'string'=59 +'string[]'=30 +'subscribers:'=17 +'time'=81 +'type'=82 +'type:'=68 +'uint16'=60 +'uint16[]'=31 +'uint32'=61 +'uint32[]'=32 +'uint64'=62 +'uint64[]'=33 +'uint8'=69 +'uint8[]'=46 +'value'=70 +'}'=90 +RULE_ANY_OTHER=113 +RULE_BEGIN=91 +RULE_BINARY=99 +RULE_BOOLEAN=100 +RULE_DATE_TIME=108 +RULE_DAY=103 +RULE_DECINT=101 +RULE_DIGIT=98 +RULE_DOUBLE=102 +RULE_END=92 +RULE_HOUR=106 +RULE_ID=94 +RULE_INT=109 +RULE_MESSAGE_ASIGMENT=110 +RULE_MIN_SEC=107 +RULE_ML_COMMENT=111 +RULE_MONTH=104 +RULE_ROS_CONVENTION_A=95 +RULE_ROS_CONVENTION_PARAM=97 +RULE_SL_COMMENT=93 +RULE_STRING=96 +RULE_WS=112 +RULE_YEAR=105 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..ce5807741 --- /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,232 @@ +/* + * 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; +} + +ParameterStructMember : 'ParameterStructMember'; + +ExternalDependency : 'ExternalDependency'; + +RelativeNamespace : 'RelativeNamespace'; + +PrivateNamespace : 'PrivateNamespace'; + +GlobalNamespace : 'GlobalNamespace'; + +Serviceclient : 'serviceclient:'; + +Serviceserver : 'serviceserver:'; + +Actionclient : 'actionclient:'; + +Actionserver : 'actionserver:'; + +Dependencies : 'dependencies:'; + +AmentPackage : 'AmentPackage'; + +ParameterAny : 'ParameterAny'; + +FromGitRepo : 'fromGitRepo:'; + +Subscribers : 'subscribers:'; + +Parameters : 'parameters:'; + +Publishers : 'publishers:'; + +Artifacts : 'artifacts:'; + +GraphName : 'GraphName'; + +Feedback_1 : 'feedback:'; + +Float32_1 : 'float32[]'; + +Float64_1 : 'float64[]'; + +Response : 'response:'; + +Duration : 'duration'; + +Feedback : 'feedback'; + +Message_1 : 'message:'; + +Request : 'request:'; + +String_2 : 'string[]'; + +Uint16_1 : 'uint16[]'; + +Uint32_1 : 'uint32[]'; + +Uint64_1 : 'uint64[]'; + +Boolean : 'Boolean'; + +Integer : 'Integer'; + +Action_1 : 'action:'; + +Default : 'default'; + +Float32 : 'float32'; + +Float64 : 'float64'; + +Int16_1 : 'int16[]'; + +Int32_1 : 'int32[]'; + +Int64_1 : 'int64[]'; + +Message : 'message'; + +Result_1 : 'result:'; + +Service : 'service'; + +Uint8_1 : 'uint8[]'; + +Array : 'Array:'; + +Base64 : 'Base64'; + +Double : 'Double'; + +Header : 'Header'; + +String : 'String'; + +Struct : 'Struct'; + +Action : 'action'; + +Bool_1 : 'bool[]'; + +Byte_1 : 'byte[]'; + +Int8_1 : 'int8[]'; + +Result : 'result'; + +Specs : 'specs:'; + +String_1 : 'string'; + +Uint16 : 'uint16'; + +Uint32 : 'uint32'; + +Uint64 : 'uint64'; + +Goal_1 : 'goal:'; + +Int16 : 'int16'; + +Int32 : 'int32'; + +Int64 : 'int64'; + +Node_1 : 'node:'; + +Type_1 : 'type:'; + +Uint8 : 'uint8'; + +Value : 'value'; + +Date : 'Date'; + +List : 'List'; + +Bool : 'bool'; + +Byte : 'byte'; + +Goal : 'goal'; + +Int8 : 'int8'; + +Msg : 'msg:'; + +Name : 'name'; + +Node : 'node'; + +Srv : 'srv:'; + +Time : 'time'; + +Type : 'type'; + +Any : 'Any'; + +Ns : 'ns:'; + +LeftSquareBracketRightSquareBracket : '[]'; + +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)*; + +fragment RULE_DIGIT : '0'..'9'; + +RULE_BINARY : ('0b'|'0B') ('0'|'1')+; + +RULE_BOOLEAN : ('true'|'false'); + +RULE_DOUBLE : RULE_DIGIT ('.' RULE_DECINT*|('.' RULE_DIGIT*)? ('E'|'e') ('-'|'+')? RULE_DIGIT); + +RULE_DECINT : ('0'|'1'..'9' RULE_DIGIT*|'-' '0'..'9' RULE_DIGIT*); + +fragment RULE_DAY : ('1'..'9'|'1'..'3' '0'..'9'); + +fragment RULE_MONTH : ('1'..'9'|'1' '0'..'2'); + +fragment RULE_YEAR : '0'..'2' '0'..'9' '0'..'9' '0'..'9'; + +fragment RULE_HOUR : ('0'..'1' '0'..'9'|'2' '0'..'3'); + +fragment RULE_MIN_SEC : '0'..'5' '0'..'9'; + +RULE_DATE_TIME : RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC; + +RULE_MESSAGE_ASIGMENT : (RULE_ID|RULE_STRING) '=' (RULE_ID|RULE_STRING|RULE_INT|'-' RULE_INT); + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + +fragment 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..7b036f2c6 --- /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,4967 @@ +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 Float32_1=23; + public static final int Node=79; + public static final int RULE_DATE_TIME=108; + public static final int Uint64_1=33; + public static final int String=51; + public static final int Int16=64; + public static final int Float32=38; + public static final int Goal=75; + public static final int Bool=73; + public static final int Uint16=60; + public static final int Boolean=34; + public static final int ExternalDependency=5; + public static final int Uint8=69; + public static final int Parameters=18; + public static final int RULE_ID=94; + public static final int AmentPackage=14; + public static final int Actionclient=11; + public static final int RULE_DIGIT=98; + public static final int GlobalNamespace=8; + public static final int Artifacts=20; + public static final int Node_1=67; + public static final int Int16_1=40; + public static final int Header=50; + public static final int RULE_INT=109; + public static final int Byte=74; + public static final int RULE_ML_COMMENT=111; + public static final int LeftSquareBracket=88; + public static final int Specs=58; + public static final int Base64=48; + public static final int Message_1=28; + public static final int Comma=86; + public static final int RULE_MESSAGE_ASIGMENT=110; + public static final int Goal_1=63; + public static final int LeftSquareBracketRightSquareBracket=85; + public static final int Int32=65; + public static final int Publishers=19; + public static final int Serviceserver=10; + public static final int RightCurlyBracket=90; + public static final int RULE_DECINT=101; + public static final int Uint32=61; + public static final int FromGitRepo=16; + public static final int Msg=77; + public static final int RULE_HOUR=106; + public static final int Int8=76; + public static final int Default=37; + public static final int Actionserver=12; + public static final int Int8_1=56; + public static final int Uint16_1=31; + public static final int Type=82; + public static final int Float64=39; + public static final int Int32_1=41; + public static final int Result_1=44; + public static final int RULE_BINARY=99; + public static final int String_1=59; + public static final int Subscribers=17; + public static final int String_2=30; + public static final int RULE_BEGIN=91; + public static final int RULE_DAY=103; + public static final int RULE_BOOLEAN=100; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=105; + public static final int Feedback_1=22; + public static final int Result=57; + public static final int Name=78; + public static final int RULE_MIN_SEC=107; + public static final int ParameterAny=15; + public static final int List=72; + public static final int Dependencies=13; + public static final int RightSquareBracket=89; + public static final int PrivateNamespace=7; + public static final int GraphName=21; + public static final int Byte_1=55; + public static final int Float64_1=24; + public static final int Duration=26; + public static final int Uint32_1=32; + public static final int Action_1=36; + public static final int Double=49; + public static final int Type_1=68; + public static final int Value=70; + public static final int Uint64=62; + public static final int Action=53; + public static final int RULE_END=92; + public static final int Message=43; + public static final int Time=81; + public static final int RULE_STRING=96; + public static final int Bool_1=54; + public static final int Any=83; + public static final int Struct=52; + public static final int RULE_SL_COMMENT=93; + public static final int Uint8_1=46; + public static final int RULE_DOUBLE=102; + public static final int Feedback=27; + public static final int ParameterStructMember=4; + public static final int Srv=80; + public static final int RULE_ROS_CONVENTION_A=95; + public static final int RULE_ROS_CONVENTION_PARAM=97; + public static final int Colon=87; + public static final int EOF=-1; + public static final int Ns=84; + public static final int RULE_WS=112; + public static final int Request=29; + public static final int Int64_1=42; + public static final int Service=45; + public static final int RULE_ANY_OTHER=113; + public static final int Date=71; + public static final int Response=25; + public static final int Integer=35; + public static final int Array=47; + public static final int Serviceclient=9; + public static final int Int64=66; + public static final int RULE_MONTH=104; + + // 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 "ParameterStructMember" + public final void mParameterStructMember() throws RecognitionException { + try { + int _type = ParameterStructMember; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:14:23: ( 'ParameterStructMember' ) + // InternalRos1Lexer.g:14:25: 'ParameterStructMember' + { + match("ParameterStructMember"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterStructMember" + + // $ANTLR start "ExternalDependency" + public final void mExternalDependency() throws RecognitionException { + try { + int _type = ExternalDependency; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:16:20: ( 'ExternalDependency' ) + // InternalRos1Lexer.g:16:22: 'ExternalDependency' + { + match("ExternalDependency"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ExternalDependency" + + // $ANTLR start "RelativeNamespace" + public final void mRelativeNamespace() throws RecognitionException { + try { + int _type = RelativeNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:18:19: ( 'RelativeNamespace' ) + // InternalRos1Lexer.g:18:21: 'RelativeNamespace' + { + match("RelativeNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RelativeNamespace" + + // $ANTLR start "PrivateNamespace" + public final void mPrivateNamespace() throws RecognitionException { + try { + int _type = PrivateNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:20:18: ( 'PrivateNamespace' ) + // InternalRos1Lexer.g:20:20: 'PrivateNamespace' + { + match("PrivateNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PrivateNamespace" + + // $ANTLR start "GlobalNamespace" + public final void mGlobalNamespace() throws RecognitionException { + try { + int _type = GlobalNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:22:17: ( 'GlobalNamespace' ) + // InternalRos1Lexer.g:22:19: 'GlobalNamespace' + { + match("GlobalNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GlobalNamespace" + + // $ANTLR start "Serviceclient" + public final void mServiceclient() throws RecognitionException { + try { + int _type = Serviceclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:24:15: ( 'serviceclient:' ) + // InternalRos1Lexer.g:24:17: 'serviceclient:' + { + match("serviceclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceclient" + + // $ANTLR start "Serviceserver" + public final void mServiceserver() throws RecognitionException { + try { + int _type = Serviceserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:26:15: ( 'serviceserver:' ) + // InternalRos1Lexer.g:26:17: 'serviceserver:' + { + match("serviceserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceserver" + + // $ANTLR start "Actionclient" + public final void mActionclient() throws RecognitionException { + try { + int _type = Actionclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:28:14: ( 'actionclient:' ) + // InternalRos1Lexer.g:28:16: 'actionclient:' + { + match("actionclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionclient" + + // $ANTLR start "Actionserver" + public final void mActionserver() throws RecognitionException { + try { + int _type = Actionserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:30:14: ( 'actionserver:' ) + // InternalRos1Lexer.g:30:16: 'actionserver:' + { + match("actionserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionserver" + + // $ANTLR start "Dependencies" + public final void mDependencies() throws RecognitionException { + try { + int _type = Dependencies; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:32:14: ( 'dependencies:' ) + // InternalRos1Lexer.g:32:16: 'dependencies:' + { + match("dependencies:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Dependencies" + + // $ANTLR start "AmentPackage" + public final void mAmentPackage() throws RecognitionException { + try { + int _type = AmentPackage; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:34:14: ( 'AmentPackage' ) + // InternalRos1Lexer.g:34:16: 'AmentPackage' + { + match("AmentPackage"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AmentPackage" + + // $ANTLR start "ParameterAny" + public final void mParameterAny() throws RecognitionException { + try { + int _type = ParameterAny; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:36:14: ( 'ParameterAny' ) + // InternalRos1Lexer.g:36:16: 'ParameterAny' + { + match("ParameterAny"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterAny" + + // $ANTLR start "FromGitRepo" + public final void mFromGitRepo() throws RecognitionException { + try { + int _type = FromGitRepo; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:38:13: ( 'fromGitRepo:' ) + // InternalRos1Lexer.g:38: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:40:13: ( 'subscribers:' ) + // InternalRos1Lexer.g:40: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:42:12: ( 'parameters:' ) + // InternalRos1Lexer.g:42: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:44:12: ( 'publishers:' ) + // InternalRos1Lexer.g:44: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:46:11: ( 'artifacts:' ) + // InternalRos1Lexer.g:46:13: 'artifacts:' + { + match("artifacts:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Artifacts" + + // $ANTLR start "GraphName" + public final void mGraphName() throws RecognitionException { + try { + int _type = GraphName; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:48:11: ( 'GraphName' ) + // InternalRos1Lexer.g:48:13: 'GraphName' + { + match("GraphName"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GraphName" + + // $ANTLR start "Feedback_1" + public final void mFeedback_1() throws RecognitionException { + try { + int _type = Feedback_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:50:12: ( 'feedback:' ) + // InternalRos1Lexer.g:50:14: 'feedback:' + { + match("feedback:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback_1" + + // $ANTLR start "Float32_1" + public final void mFloat32_1() throws RecognitionException { + try { + int _type = Float32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:52:11: ( 'float32[]' ) + // InternalRos1Lexer.g:52:13: 'float32[]' + { + match("float32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32_1" + + // $ANTLR start "Float64_1" + public final void mFloat64_1() throws RecognitionException { + try { + int _type = Float64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:54:11: ( 'float64[]' ) + // InternalRos1Lexer.g:54:13: 'float64[]' + { + match("float64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64_1" + + // $ANTLR start "Response" + public final void mResponse() throws RecognitionException { + try { + int _type = Response; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:56:10: ( 'response:' ) + // InternalRos1Lexer.g:56:12: 'response:' + { + match("response:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Response" + + // $ANTLR start "Duration" + public final void mDuration() throws RecognitionException { + try { + int _type = Duration; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:58:10: ( 'duration' ) + // InternalRos1Lexer.g:58:12: 'duration' + { + match("duration"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Duration" + + // $ANTLR start "Feedback" + public final void mFeedback() throws RecognitionException { + try { + int _type = Feedback; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:60:10: ( 'feedback' ) + // InternalRos1Lexer.g:60:12: 'feedback' + { + match("feedback"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback" + + // $ANTLR start "Message_1" + public final void mMessage_1() throws RecognitionException { + try { + int _type = Message_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:62:11: ( 'message:' ) + // InternalRos1Lexer.g:62:13: 'message:' + { + match("message:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message_1" + + // $ANTLR start "Request" + public final void mRequest() throws RecognitionException { + try { + int _type = Request; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:64:9: ( 'request:' ) + // InternalRos1Lexer.g:64:11: 'request:' + { + match("request:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Request" + + // $ANTLR start "String_2" + public final void mString_2() throws RecognitionException { + try { + int _type = String_2; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:66:10: ( 'string[]' ) + // InternalRos1Lexer.g:66:12: 'string[]' + { + match("string[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_2" + + // $ANTLR start "Uint16_1" + public final void mUint16_1() throws RecognitionException { + try { + int _type = Uint16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:68:10: ( 'uint16[]' ) + // InternalRos1Lexer.g:68:12: 'uint16[]' + { + match("uint16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16_1" + + // $ANTLR start "Uint32_1" + public final void mUint32_1() throws RecognitionException { + try { + int _type = Uint32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:70:10: ( 'uint32[]' ) + // InternalRos1Lexer.g:70:12: 'uint32[]' + { + match("uint32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32_1" + + // $ANTLR start "Uint64_1" + public final void mUint64_1() throws RecognitionException { + try { + int _type = Uint64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:72:10: ( 'uint64[]' ) + // InternalRos1Lexer.g:72:12: 'uint64[]' + { + match("uint64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64_1" + + // $ANTLR start "Boolean" + public final void mBoolean() throws RecognitionException { + try { + int _type = Boolean; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:74:9: ( 'Boolean' ) + // InternalRos1Lexer.g:74:11: 'Boolean' + { + match("Boolean"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Boolean" + + // $ANTLR start "Integer" + public final void mInteger() throws RecognitionException { + try { + int _type = Integer; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:76:9: ( 'Integer' ) + // InternalRos1Lexer.g:76:11: 'Integer' + { + match("Integer"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Integer" + + // $ANTLR start "Action_1" + public final void mAction_1() throws RecognitionException { + try { + int _type = Action_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:78:10: ( 'action:' ) + // InternalRos1Lexer.g:78:12: 'action:' + { + match("action:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action_1" + + // $ANTLR start "Default" + public final void mDefault() throws RecognitionException { + try { + int _type = Default; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:80:9: ( 'default' ) + // InternalRos1Lexer.g:80:11: 'default' + { + match("default"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Default" + + // $ANTLR start "Float32" + public final void mFloat32() throws RecognitionException { + try { + int _type = Float32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:82:9: ( 'float32' ) + // InternalRos1Lexer.g:82:11: 'float32' + { + match("float32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32" + + // $ANTLR start "Float64" + public final void mFloat64() throws RecognitionException { + try { + int _type = Float64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:84:9: ( 'float64' ) + // InternalRos1Lexer.g:84:11: 'float64' + { + match("float64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64" + + // $ANTLR start "Int16_1" + public final void mInt16_1() throws RecognitionException { + try { + int _type = Int16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:86:9: ( 'int16[]' ) + // InternalRos1Lexer.g:86:11: 'int16[]' + { + match("int16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16_1" + + // $ANTLR start "Int32_1" + public final void mInt32_1() throws RecognitionException { + try { + int _type = Int32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:88:9: ( 'int32[]' ) + // InternalRos1Lexer.g:88:11: 'int32[]' + { + match("int32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32_1" + + // $ANTLR start "Int64_1" + public final void mInt64_1() throws RecognitionException { + try { + int _type = Int64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:90:9: ( 'int64[]' ) + // InternalRos1Lexer.g:90:11: 'int64[]' + { + match("int64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64_1" + + // $ANTLR start "Message" + public final void mMessage() throws RecognitionException { + try { + int _type = Message; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:92:9: ( 'message' ) + // InternalRos1Lexer.g:92:11: 'message' + { + match("message"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message" + + // $ANTLR start "Result_1" + public final void mResult_1() throws RecognitionException { + try { + int _type = Result_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:94:10: ( 'result:' ) + // InternalRos1Lexer.g:94:12: 'result:' + { + match("result:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result_1" + + // $ANTLR start "Service" + public final void mService() throws RecognitionException { + try { + int _type = Service; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:96:9: ( 'service' ) + // InternalRos1Lexer.g:96:11: 'service' + { + match("service"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Service" + + // $ANTLR start "Uint8_1" + public final void mUint8_1() throws RecognitionException { + try { + int _type = Uint8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:98:9: ( 'uint8[]' ) + // InternalRos1Lexer.g:98:11: 'uint8[]' + { + match("uint8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8_1" + + // $ANTLR start "Array" + public final void mArray() throws RecognitionException { + try { + int _type = Array; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:100:7: ( 'Array:' ) + // InternalRos1Lexer.g:100:9: 'Array:' + { + match("Array:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Array" + + // $ANTLR start "Base64" + public final void mBase64() throws RecognitionException { + try { + int _type = Base64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:102:8: ( 'Base64' ) + // InternalRos1Lexer.g:102:10: 'Base64' + { + match("Base64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Base64" + + // $ANTLR start "Double" + public final void mDouble() throws RecognitionException { + try { + int _type = Double; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:104:8: ( 'Double' ) + // InternalRos1Lexer.g:104:10: 'Double' + { + match("Double"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Double" + + // $ANTLR start "Header" + public final void mHeader() throws RecognitionException { + try { + int _type = Header; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:106:8: ( 'Header' ) + // InternalRos1Lexer.g:106:10: 'Header' + { + match("Header"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Header" + + // $ANTLR start "String" + public final void mString() throws RecognitionException { + try { + int _type = String; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:108:8: ( 'String' ) + // InternalRos1Lexer.g:108:10: 'String' + { + match("String"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String" + + // $ANTLR start "Struct" + public final void mStruct() throws RecognitionException { + try { + int _type = Struct; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:110:8: ( 'Struct' ) + // InternalRos1Lexer.g:110:10: 'Struct' + { + match("Struct"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Struct" + + // $ANTLR start "Action" + public final void mAction() throws RecognitionException { + try { + int _type = Action; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:112:8: ( 'action' ) + // InternalRos1Lexer.g:112:10: 'action' + { + match("action"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action" + + // $ANTLR start "Bool_1" + public final void mBool_1() throws RecognitionException { + try { + int _type = Bool_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:114:8: ( 'bool[]' ) + // InternalRos1Lexer.g:114:10: 'bool[]' + { + match("bool[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool_1" + + // $ANTLR start "Byte_1" + public final void mByte_1() throws RecognitionException { + try { + int _type = Byte_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:116:8: ( 'byte[]' ) + // InternalRos1Lexer.g:116:10: 'byte[]' + { + match("byte[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte_1" + + // $ANTLR start "Int8_1" + public final void mInt8_1() throws RecognitionException { + try { + int _type = Int8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:118:8: ( 'int8[]' ) + // InternalRos1Lexer.g:118:10: 'int8[]' + { + match("int8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8_1" + + // $ANTLR start "Result" + public final void mResult() throws RecognitionException { + try { + int _type = Result; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:120:8: ( 'result' ) + // InternalRos1Lexer.g:120:10: 'result' + { + match("result"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result" + + // $ANTLR start "Specs" + public final void mSpecs() throws RecognitionException { + try { + int _type = Specs; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:122:7: ( 'specs:' ) + // InternalRos1Lexer.g:122:9: 'specs:' + { + match("specs:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Specs" + + // $ANTLR start "String_1" + public final void mString_1() throws RecognitionException { + try { + int _type = String_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:124:10: ( 'string' ) + // InternalRos1Lexer.g:124:12: 'string' + { + match("string"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_1" + + // $ANTLR start "Uint16" + public final void mUint16() throws RecognitionException { + try { + int _type = Uint16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:126:8: ( 'uint16' ) + // InternalRos1Lexer.g:126:10: 'uint16' + { + match("uint16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16" + + // $ANTLR start "Uint32" + public final void mUint32() throws RecognitionException { + try { + int _type = Uint32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:128:8: ( 'uint32' ) + // InternalRos1Lexer.g:128:10: 'uint32' + { + match("uint32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32" + + // $ANTLR start "Uint64" + public final void mUint64() throws RecognitionException { + try { + int _type = Uint64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:130:8: ( 'uint64' ) + // InternalRos1Lexer.g:130:10: 'uint64' + { + match("uint64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64" + + // $ANTLR start "Goal_1" + public final void mGoal_1() throws RecognitionException { + try { + int _type = Goal_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:132:8: ( 'goal:' ) + // InternalRos1Lexer.g:132:10: 'goal:' + { + match("goal:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal_1" + + // $ANTLR start "Int16" + public final void mInt16() throws RecognitionException { + try { + int _type = Int16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:134:7: ( 'int16' ) + // InternalRos1Lexer.g:134:9: 'int16' + { + match("int16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16" + + // $ANTLR start "Int32" + public final void mInt32() throws RecognitionException { + try { + int _type = Int32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:136:7: ( 'int32' ) + // InternalRos1Lexer.g:136:9: 'int32' + { + match("int32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32" + + // $ANTLR start "Int64" + public final void mInt64() throws RecognitionException { + try { + int _type = Int64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:138:7: ( 'int64' ) + // InternalRos1Lexer.g:138:9: 'int64' + { + match("int64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64" + + // $ANTLR start "Node_1" + public final void mNode_1() throws RecognitionException { + try { + int _type = Node_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:140:8: ( 'node:' ) + // InternalRos1Lexer.g:140:10: 'node:' + { + match("node:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node_1" + + // $ANTLR start "Type_1" + public final void mType_1() throws RecognitionException { + try { + int _type = Type_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:142:8: ( 'type:' ) + // InternalRos1Lexer.g:142:10: 'type:' + { + match("type:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type_1" + + // $ANTLR start "Uint8" + public final void mUint8() throws RecognitionException { + try { + int _type = Uint8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:144:7: ( 'uint8' ) + // InternalRos1Lexer.g:144:9: 'uint8' + { + match("uint8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8" + + // $ANTLR start "Value" + public final void mValue() throws RecognitionException { + try { + int _type = Value; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:146:7: ( 'value' ) + // InternalRos1Lexer.g:146:9: 'value' + { + match("value"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Value" + + // $ANTLR start "Date" + public final void mDate() throws RecognitionException { + try { + int _type = Date; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:148:6: ( 'Date' ) + // InternalRos1Lexer.g:148:8: 'Date' + { + match("Date"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Date" + + // $ANTLR start "List" + public final void mList() throws RecognitionException { + try { + int _type = List; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:150:6: ( 'List' ) + // InternalRos1Lexer.g:150:8: 'List' + { + match("List"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "List" + + // $ANTLR start "Bool" + public final void mBool() throws RecognitionException { + try { + int _type = Bool; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:152:6: ( 'bool' ) + // InternalRos1Lexer.g:152:8: 'bool' + { + match("bool"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool" + + // $ANTLR start "Byte" + public final void mByte() throws RecognitionException { + try { + int _type = Byte; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:154:6: ( 'byte' ) + // InternalRos1Lexer.g:154:8: 'byte' + { + match("byte"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte" + + // $ANTLR start "Goal" + public final void mGoal() throws RecognitionException { + try { + int _type = Goal; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:156:6: ( 'goal' ) + // InternalRos1Lexer.g:156:8: 'goal' + { + match("goal"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal" + + // $ANTLR start "Int8" + public final void mInt8() throws RecognitionException { + try { + int _type = Int8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:158:6: ( 'int8' ) + // InternalRos1Lexer.g:158:8: 'int8' + { + match("int8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8" + + // $ANTLR start "Msg" + public final void mMsg() throws RecognitionException { + try { + int _type = Msg; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:160:5: ( 'msg:' ) + // InternalRos1Lexer.g:160:7: 'msg:' + { + match("msg:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Msg" + + // $ANTLR start "Name" + public final void mName() throws RecognitionException { + try { + int _type = Name; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:162:6: ( 'name' ) + // InternalRos1Lexer.g:162:8: 'name' + { + match("name"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Name" + + // $ANTLR start "Node" + public final void mNode() throws RecognitionException { + try { + int _type = Node; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:164:6: ( 'node' ) + // InternalRos1Lexer.g:164:8: 'node' + { + match("node"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node" + + // $ANTLR start "Srv" + public final void mSrv() throws RecognitionException { + try { + int _type = Srv; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:166:5: ( 'srv:' ) + // InternalRos1Lexer.g:166:7: 'srv:' + { + match("srv:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Srv" + + // $ANTLR start "Time" + public final void mTime() throws RecognitionException { + try { + int _type = Time; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:168:6: ( 'time' ) + // InternalRos1Lexer.g:168:8: 'time' + { + match("time"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Time" + + // $ANTLR start "Type" + public final void mType() throws RecognitionException { + try { + int _type = Type; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:170:6: ( 'type' ) + // InternalRos1Lexer.g:170:8: 'type' + { + match("type"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type" + + // $ANTLR start "Any" + public final void mAny() throws RecognitionException { + try { + int _type = Any; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:172:5: ( 'Any' ) + // InternalRos1Lexer.g:172:7: 'Any' + { + match("Any"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Any" + + // $ANTLR start "Ns" + public final void mNs() throws RecognitionException { + try { + int _type = Ns; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:174:4: ( 'ns:' ) + // InternalRos1Lexer.g:174:6: 'ns:' + { + match("ns:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Ns" + + // $ANTLR start "LeftSquareBracketRightSquareBracket" + public final void mLeftSquareBracketRightSquareBracket() throws RecognitionException { + try { + int _type = LeftSquareBracketRightSquareBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:176:37: ( '[]' ) + // InternalRos1Lexer.g:176:39: '[]' + { + match("[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LeftSquareBracketRightSquareBracket" + + // $ANTLR start "Comma" + public final void mComma() throws RecognitionException { + try { + int _type = Comma; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:178:7: ( ',' ) + // InternalRos1Lexer.g:178: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:180:7: ( ':' ) + // InternalRos1Lexer.g:180: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:182:19: ( '[' ) + // InternalRos1Lexer.g:182: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:184:20: ( ']' ) + // InternalRos1Lexer.g:184: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:186:19: ( '}' ) + // InternalRos1Lexer.g:186: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:188:21: () + // InternalRos1Lexer.g:188:23: + { + } + + } + finally { + } + } + // $ANTLR end "RULE_BEGIN" + + // $ANTLR start "RULE_END" + public final void mRULE_END() throws RecognitionException { + try { + // InternalRos1Lexer.g:190:19: () + // InternalRos1Lexer.g:190: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:192:17: ( '#' (~ ( ( '\\n' | '\\r' ) ) )* ) + // InternalRos1Lexer.g:192:19: '#' (~ ( ( '\\n' | '\\r' ) ) )* + { + match('#'); + // InternalRos1Lexer.g:192: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:192: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:194:23: ( ( '/' RULE_ID | RULE_ID '/' )* ) + // InternalRos1Lexer.g:194:25: ( '/' RULE_ID | RULE_ID '/' )* + { + // InternalRos1Lexer.g:194: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:194:26: '/' RULE_ID + { + match('/'); + mRULE_ID(); + + } + break; + case 2 : + // InternalRos1Lexer.g:194: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:196:27: ( ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* ) + // InternalRos1Lexer.g:196:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* + { + // InternalRos1Lexer.g:196: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:196:30: '/' RULE_STRING + { + match('/'); + mRULE_STRING(); + + } + break; + case 2 : + // InternalRos1Lexer.g:196:46: RULE_STRING '/' + { + mRULE_STRING(); + match('/'); + + } + break; + case 3 : + // InternalRos1Lexer.g:196: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_DIGIT" + public final void mRULE_DIGIT() throws RecognitionException { + try { + // InternalRos1Lexer.g:198:21: ( '0' .. '9' ) + // InternalRos1Lexer.g:198:23: '0' .. '9' + { + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_DIGIT" + + // $ANTLR start "RULE_BINARY" + public final void mRULE_BINARY() throws RecognitionException { + try { + int _type = RULE_BINARY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:200:13: ( ( '0b' | '0B' ) ( '0' | '1' )+ ) + // InternalRos1Lexer.g:200:15: ( '0b' | '0B' ) ( '0' | '1' )+ + { + // InternalRos1Lexer.g:200:15: ( '0b' | '0B' ) + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0=='0') ) { + int LA4_1 = input.LA(2); + + if ( (LA4_1=='b') ) { + alt4=1; + } + else if ( (LA4_1=='B') ) { + alt4=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + switch (alt4) { + case 1 : + // InternalRos1Lexer.g:200:16: '0b' + { + match("0b"); + + + } + break; + case 2 : + // InternalRos1Lexer.g:200:21: '0B' + { + match("0B"); + + + } + break; + + } + + // InternalRos1Lexer.g:200:27: ( '0' | '1' )+ + int cnt5=0; + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( ((LA5_0>='0' && LA5_0<='1')) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalRos1Lexer.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='1') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt5 >= 1 ) break loop5; + EarlyExitException eee = + new EarlyExitException(5, input); + throw eee; + } + cnt5++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BINARY" + + // $ANTLR start "RULE_BOOLEAN" + public final void mRULE_BOOLEAN() throws RecognitionException { + try { + int _type = RULE_BOOLEAN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:202:14: ( ( 'true' | 'false' ) ) + // InternalRos1Lexer.g:202:16: ( 'true' | 'false' ) + { + // InternalRos1Lexer.g:202:16: ( 'true' | 'false' ) + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='t') ) { + alt6=1; + } + else if ( (LA6_0=='f') ) { + alt6=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + switch (alt6) { + case 1 : + // InternalRos1Lexer.g:202:17: 'true' + { + match("true"); + + + } + break; + case 2 : + // InternalRos1Lexer.g:202:24: 'false' + { + match("false"); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BOOLEAN" + + // $ANTLR start "RULE_DOUBLE" + public final void mRULE_DOUBLE() throws RecognitionException { + try { + int _type = RULE_DOUBLE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:204:13: ( RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) ) + // InternalRos1Lexer.g:204:15: RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + { + mRULE_DIGIT(); + // InternalRos1Lexer.g:204:26: ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + int alt11=2; + alt11 = dfa11.predict(input); + switch (alt11) { + case 1 : + // InternalRos1Lexer.g:204:27: '.' ( RULE_DECINT )* + { + match('.'); + // InternalRos1Lexer.g:204:31: ( RULE_DECINT )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0=='-'||(LA7_0>='0' && LA7_0<='9')) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalRos1Lexer.g:204:31: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + + default : + break loop7; + } + } while (true); + + + } + break; + case 2 : + // InternalRos1Lexer.g:204:44: ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT + { + // InternalRos1Lexer.g:204:44: ( '.' ( RULE_DIGIT )* )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='.') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalRos1Lexer.g:204:45: '.' ( RULE_DIGIT )* + { + match('.'); + // InternalRos1Lexer.g:204:49: ( RULE_DIGIT )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( ((LA8_0>='0' && LA8_0<='9')) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // InternalRos1Lexer.g:204:49: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop8; + } + } while (true); + + + } + break; + + } + + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalRos1Lexer.g:204:73: ( '-' | '+' )? + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='+'||LA10_0=='-') ) { + alt10=1; + } + switch (alt10) { + case 1 : + // InternalRos1Lexer.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_DIGIT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DOUBLE" + + // $ANTLR start "RULE_DECINT" + public final void mRULE_DECINT() throws RecognitionException { + try { + int _type = RULE_DECINT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:206:13: ( ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) ) + // InternalRos1Lexer.g:206:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + { + // InternalRos1Lexer.g:206:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + int alt14=3; + switch ( input.LA(1) ) { + case '0': + { + alt14=1; + } + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt14=2; + } + break; + case '-': + { + alt14=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + + throw nvae; + } + + switch (alt14) { + case 1 : + // InternalRos1Lexer.g:206:16: '0' + { + match('0'); + + } + break; + case 2 : + // InternalRos1Lexer.g:206:20: '1' .. '9' ( RULE_DIGIT )* + { + matchRange('1','9'); + // InternalRos1Lexer.g:206:29: ( RULE_DIGIT )* + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( ((LA12_0>='0' && LA12_0<='9')) ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalRos1Lexer.g:206:29: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop12; + } + } while (true); + + + } + break; + case 3 : + // InternalRos1Lexer.g:206:41: '-' '0' .. '9' ( RULE_DIGIT )* + { + match('-'); + matchRange('0','9'); + // InternalRos1Lexer.g:206:54: ( RULE_DIGIT )* + loop13: + do { + int alt13=2; + int LA13_0 = input.LA(1); + + if ( ((LA13_0>='0' && LA13_0<='9')) ) { + alt13=1; + } + + + switch (alt13) { + case 1 : + // InternalRos1Lexer.g:206:54: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop13; + } + } while (true); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DECINT" + + // $ANTLR start "RULE_DAY" + public final void mRULE_DAY() throws RecognitionException { + try { + // InternalRos1Lexer.g:208:19: ( ( '1' .. '9' | '1' .. '3' '0' .. '9' ) ) + // InternalRos1Lexer.g:208:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + { + // InternalRos1Lexer.g:208:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + int alt15=2; + int LA15_0 = input.LA(1); + + if ( ((LA15_0>='1' && LA15_0<='3')) ) { + int LA15_1 = input.LA(2); + + if ( ((LA15_1>='0' && LA15_1<='9')) ) { + alt15=2; + } + else { + alt15=1;} + } + else if ( ((LA15_0>='4' && LA15_0<='9')) ) { + alt15=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + + throw nvae; + } + switch (alt15) { + case 1 : + // InternalRos1Lexer.g:208:22: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRos1Lexer.g:208:31: '1' .. '3' '0' .. '9' + { + matchRange('1','3'); + matchRange('0','9'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_DAY" + + // $ANTLR start "RULE_MONTH" + public final void mRULE_MONTH() throws RecognitionException { + try { + // InternalRos1Lexer.g:210:21: ( ( '1' .. '9' | '1' '0' .. '2' ) ) + // InternalRos1Lexer.g:210:23: ( '1' .. '9' | '1' '0' .. '2' ) + { + // InternalRos1Lexer.g:210:23: ( '1' .. '9' | '1' '0' .. '2' ) + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='1') ) { + int LA16_1 = input.LA(2); + + if ( ((LA16_1>='0' && LA16_1<='2')) ) { + alt16=2; + } + else { + alt16=1;} + } + else if ( ((LA16_0>='2' && LA16_0<='9')) ) { + alt16=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + + throw nvae; + } + switch (alt16) { + case 1 : + // InternalRos1Lexer.g:210:24: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRos1Lexer.g:210:33: '1' '0' .. '2' + { + match('1'); + matchRange('0','2'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_MONTH" + + // $ANTLR start "RULE_YEAR" + public final void mRULE_YEAR() throws RecognitionException { + try { + // InternalRos1Lexer.g:212:20: ( '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' ) + // InternalRos1Lexer.g:212:22: '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' + { + matchRange('0','2'); + matchRange('0','9'); + matchRange('0','9'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_YEAR" + + // $ANTLR start "RULE_HOUR" + public final void mRULE_HOUR() throws RecognitionException { + try { + // InternalRos1Lexer.g:214:20: ( ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) ) + // InternalRos1Lexer.g:214:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + { + // InternalRos1Lexer.g:214:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + int alt17=2; + int LA17_0 = input.LA(1); + + if ( ((LA17_0>='0' && LA17_0<='1')) ) { + alt17=1; + } + else if ( (LA17_0=='2') ) { + alt17=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); + + throw nvae; + } + switch (alt17) { + case 1 : + // InternalRos1Lexer.g:214:23: '0' .. '1' '0' .. '9' + { + matchRange('0','1'); + matchRange('0','9'); + + } + break; + case 2 : + // InternalRos1Lexer.g:214:41: '2' '0' .. '3' + { + match('2'); + matchRange('0','3'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_HOUR" + + // $ANTLR start "RULE_MIN_SEC" + public final void mRULE_MIN_SEC() throws RecognitionException { + try { + // InternalRos1Lexer.g:216:23: ( '0' .. '5' '0' .. '9' ) + // InternalRos1Lexer.g:216:25: '0' .. '5' '0' .. '9' + { + matchRange('0','5'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_MIN_SEC" + + // $ANTLR start "RULE_DATE_TIME" + public final void mRULE_DATE_TIME() throws RecognitionException { + try { + int _type = RULE_DATE_TIME; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:218:16: ( RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC ) + // InternalRos1Lexer.g:218:18: RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC + { + mRULE_YEAR(); + match('-'); + mRULE_MONTH(); + match('-'); + mRULE_DAY(); + match('T'); + mRULE_HOUR(); + match(':'); + mRULE_MIN_SEC(); + match(':'); + mRULE_MIN_SEC(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DATE_TIME" + + // $ANTLR start "RULE_MESSAGE_ASIGMENT" + public final void mRULE_MESSAGE_ASIGMENT() throws RecognitionException { + try { + int _type = RULE_MESSAGE_ASIGMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:220:23: ( ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) ) + // InternalRos1Lexer.g:220:25: ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + { + // InternalRos1Lexer.g:220:25: ( RULE_ID | RULE_STRING ) + int alt18=2; + int LA18_0 = input.LA(1); + + if ( ((LA18_0>='A' && LA18_0<='Z')||(LA18_0>='^' && LA18_0<='_')||(LA18_0>='a' && LA18_0<='z')) ) { + alt18=1; + } + else if ( (LA18_0=='\"'||LA18_0=='\'') ) { + alt18=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + + throw nvae; + } + switch (alt18) { + case 1 : + // InternalRos1Lexer.g:220:26: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRos1Lexer.g:220:34: RULE_STRING + { + mRULE_STRING(); + + } + break; + + } + + match('='); + // InternalRos1Lexer.g:220:51: ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + int alt19=4; + switch ( input.LA(1) ) { + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + case 'G': + case 'H': + case 'I': + case 'J': + case 'K': + case 'L': + case 'M': + case 'N': + case 'O': + case 'P': + case 'Q': + case 'R': + case 'S': + case 'T': + case 'U': + case 'V': + case 'W': + case 'X': + case 'Y': + case 'Z': + case '^': + case '_': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'g': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': + { + alt19=1; + } + break; + case '\"': + case '\'': + { + alt19=2; + } + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt19=3; + } + break; + case '-': + { + alt19=4; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 19, 0, input); + + throw nvae; + } + + switch (alt19) { + case 1 : + // InternalRos1Lexer.g:220:52: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRos1Lexer.g:220:60: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 3 : + // InternalRos1Lexer.g:220:72: RULE_INT + { + mRULE_INT(); + + } + break; + case 4 : + // InternalRos1Lexer.g:220:81: '-' RULE_INT + { + match('-'); + mRULE_INT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_MESSAGE_ASIGMENT" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:222:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // InternalRos1Lexer.g:222:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + // InternalRos1Lexer.g:222:11: ( '^' )? + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0=='^') ) { + alt20=1; + } + switch (alt20) { + case 1 : + // InternalRos1Lexer.g:222: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:222:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop21: + do { + int alt21=2; + int LA21_0 = input.LA(1); + + if ( ((LA21_0>='0' && LA21_0<='9')||(LA21_0>='A' && LA21_0<='Z')||LA21_0=='_'||(LA21_0>='a' && LA21_0<='z')) ) { + alt21=1; + } + + + switch (alt21) { + 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 loop21; + } + } 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 { + // InternalRos1Lexer.g:224:19: ( ( '0' .. '9' )+ ) + // InternalRos1Lexer.g:224:21: ( '0' .. '9' )+ + { + // InternalRos1Lexer.g:224:21: ( '0' .. '9' )+ + int cnt22=0; + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( ((LA22_0>='0' && LA22_0<='9')) ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalRos1Lexer.g:224:22: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt22 >= 1 ) break loop22; + EarlyExitException eee = + new EarlyExitException(22, input); + throw eee; + } + cnt22++; + } while (true); + + + } + + } + 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:226:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) + // InternalRos1Lexer.g:226:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + { + // InternalRos1Lexer.g:226:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0=='\"') ) { + alt25=1; + } + else if ( (LA25_0=='\'') ) { + alt25=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); + + throw nvae; + } + switch (alt25) { + case 1 : + // InternalRos1Lexer.g:226:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + { + match('\"'); + // InternalRos1Lexer.g:226:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop23: + do { + int alt23=3; + int LA23_0 = input.LA(1); + + if ( (LA23_0=='\\') ) { + alt23=1; + } + else if ( ((LA23_0>='\u0000' && LA23_0<='!')||(LA23_0>='#' && LA23_0<='[')||(LA23_0>=']' && LA23_0<='\uFFFF')) ) { + alt23=2; + } + + + switch (alt23) { + case 1 : + // InternalRos1Lexer.g:226:21: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos1Lexer.g:226: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 loop23; + } + } while (true); + + match('\"'); + + } + break; + case 2 : + // InternalRos1Lexer.g:226:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + { + match('\''); + // InternalRos1Lexer.g:226:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop24: + do { + int alt24=3; + int LA24_0 = input.LA(1); + + if ( (LA24_0=='\\') ) { + alt24=1; + } + else if ( ((LA24_0>='\u0000' && LA24_0<='&')||(LA24_0>='(' && LA24_0<='[')||(LA24_0>=']' && LA24_0<='\uFFFF')) ) { + alt24=2; + } + + + switch (alt24) { + case 1 : + // InternalRos1Lexer.g:226:54: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos1Lexer.g:226: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 loop24; + } + } 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:228:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalRos1Lexer.g:228:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalRos1Lexer.g:228:24: ( options {greedy=false; } : . )* + loop26: + do { + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0=='*') ) { + int LA26_1 = input.LA(2); + + if ( (LA26_1=='/') ) { + alt26=2; + } + else if ( ((LA26_1>='\u0000' && LA26_1<='.')||(LA26_1>='0' && LA26_1<='\uFFFF')) ) { + alt26=1; + } + + + } + else if ( ((LA26_0>='\u0000' && LA26_0<=')')||(LA26_0>='+' && LA26_0<='\uFFFF')) ) { + alt26=1; + } + + + switch (alt26) { + case 1 : + // InternalRos1Lexer.g:228:52: . + { + matchAny(); + + } + break; + + default : + break loop26; + } + } 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:230:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalRos1Lexer.g:230:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalRos1Lexer.g:230:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt27=0; + loop27: + do { + int alt27=2; + int LA27_0 = input.LA(1); + + if ( ((LA27_0>='\t' && LA27_0<='\n')||LA27_0=='\r'||LA27_0==' ') ) { + alt27=1; + } + + + switch (alt27) { + 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 ( cnt27 >= 1 ) break loop27; + EarlyExitException eee = + new EarlyExitException(27, input); + throw eee; + } + cnt27++; + } 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:232:16: ( . ) + // InternalRos1Lexer.g:232:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalRos1Lexer.g:1:8: ( ParameterStructMember | ExternalDependency | RelativeNamespace | PrivateNamespace | GlobalNamespace | Serviceclient | Serviceserver | Actionclient | Actionserver | Dependencies | AmentPackage | ParameterAny | FromGitRepo | Subscribers | Parameters | Publishers | Artifacts | GraphName | Feedback_1 | Float32_1 | Float64_1 | Response | Duration | Feedback | Message_1 | Request | String_2 | Uint16_1 | Uint32_1 | Uint64_1 | Boolean | Integer | Action_1 | Default | Float32 | Float64 | Int16_1 | Int32_1 | Int64_1 | Message | Result_1 | Service | Uint8_1 | Array | Base64 | Double | Header | String | Struct | Action | Bool_1 | Byte_1 | Int8_1 | Result | Specs | String_1 | Uint16 | Uint32 | Uint64 | Goal_1 | Int16 | Int32 | Int64 | Node_1 | Type_1 | Uint8 | Value | Date | List | Bool | Byte | Goal | Int8 | Msg | Name | Node | Srv | Time | Type | Any | Ns | LeftSquareBracketRightSquareBracket | Comma | Colon | LeftSquareBracket | RightSquareBracket | RightCurlyBracket | RULE_SL_COMMENT | RULE_ROS_CONVENTION_A | RULE_ROS_CONVENTION_PARAM | RULE_BINARY | RULE_BOOLEAN | RULE_DOUBLE | RULE_DECINT | RULE_DATE_TIME | RULE_MESSAGE_ASIGMENT | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt28=101; + alt28 = dfa28.predict(input); + switch (alt28) { + case 1 : + // InternalRos1Lexer.g:1:10: ParameterStructMember + { + mParameterStructMember(); + + } + break; + case 2 : + // InternalRos1Lexer.g:1:32: ExternalDependency + { + mExternalDependency(); + + } + break; + case 3 : + // InternalRos1Lexer.g:1:51: RelativeNamespace + { + mRelativeNamespace(); + + } + break; + case 4 : + // InternalRos1Lexer.g:1:69: PrivateNamespace + { + mPrivateNamespace(); + + } + break; + case 5 : + // InternalRos1Lexer.g:1:86: GlobalNamespace + { + mGlobalNamespace(); + + } + break; + case 6 : + // InternalRos1Lexer.g:1:102: Serviceclient + { + mServiceclient(); + + } + break; + case 7 : + // InternalRos1Lexer.g:1:116: Serviceserver + { + mServiceserver(); + + } + break; + case 8 : + // InternalRos1Lexer.g:1:130: Actionclient + { + mActionclient(); + + } + break; + case 9 : + // InternalRos1Lexer.g:1:143: Actionserver + { + mActionserver(); + + } + break; + case 10 : + // InternalRos1Lexer.g:1:156: Dependencies + { + mDependencies(); + + } + break; + case 11 : + // InternalRos1Lexer.g:1:169: AmentPackage + { + mAmentPackage(); + + } + break; + case 12 : + // InternalRos1Lexer.g:1:182: ParameterAny + { + mParameterAny(); + + } + break; + case 13 : + // InternalRos1Lexer.g:1:195: FromGitRepo + { + mFromGitRepo(); + + } + break; + case 14 : + // InternalRos1Lexer.g:1:207: Subscribers + { + mSubscribers(); + + } + break; + case 15 : + // InternalRos1Lexer.g:1:219: Parameters + { + mParameters(); + + } + break; + case 16 : + // InternalRos1Lexer.g:1:230: Publishers + { + mPublishers(); + + } + break; + case 17 : + // InternalRos1Lexer.g:1:241: Artifacts + { + mArtifacts(); + + } + break; + case 18 : + // InternalRos1Lexer.g:1:251: GraphName + { + mGraphName(); + + } + break; + case 19 : + // InternalRos1Lexer.g:1:261: Feedback_1 + { + mFeedback_1(); + + } + break; + case 20 : + // InternalRos1Lexer.g:1:272: Float32_1 + { + mFloat32_1(); + + } + break; + case 21 : + // InternalRos1Lexer.g:1:282: Float64_1 + { + mFloat64_1(); + + } + break; + case 22 : + // InternalRos1Lexer.g:1:292: Response + { + mResponse(); + + } + break; + case 23 : + // InternalRos1Lexer.g:1:301: Duration + { + mDuration(); + + } + break; + case 24 : + // InternalRos1Lexer.g:1:310: Feedback + { + mFeedback(); + + } + break; + case 25 : + // InternalRos1Lexer.g:1:319: Message_1 + { + mMessage_1(); + + } + break; + case 26 : + // InternalRos1Lexer.g:1:329: Request + { + mRequest(); + + } + break; + case 27 : + // InternalRos1Lexer.g:1:337: String_2 + { + mString_2(); + + } + break; + case 28 : + // InternalRos1Lexer.g:1:346: Uint16_1 + { + mUint16_1(); + + } + break; + case 29 : + // InternalRos1Lexer.g:1:355: Uint32_1 + { + mUint32_1(); + + } + break; + case 30 : + // InternalRos1Lexer.g:1:364: Uint64_1 + { + mUint64_1(); + + } + break; + case 31 : + // InternalRos1Lexer.g:1:373: Boolean + { + mBoolean(); + + } + break; + case 32 : + // InternalRos1Lexer.g:1:381: Integer + { + mInteger(); + + } + break; + case 33 : + // InternalRos1Lexer.g:1:389: Action_1 + { + mAction_1(); + + } + break; + case 34 : + // InternalRos1Lexer.g:1:398: Default + { + mDefault(); + + } + break; + case 35 : + // InternalRos1Lexer.g:1:406: Float32 + { + mFloat32(); + + } + break; + case 36 : + // InternalRos1Lexer.g:1:414: Float64 + { + mFloat64(); + + } + break; + case 37 : + // InternalRos1Lexer.g:1:422: Int16_1 + { + mInt16_1(); + + } + break; + case 38 : + // InternalRos1Lexer.g:1:430: Int32_1 + { + mInt32_1(); + + } + break; + case 39 : + // InternalRos1Lexer.g:1:438: Int64_1 + { + mInt64_1(); + + } + break; + case 40 : + // InternalRos1Lexer.g:1:446: Message + { + mMessage(); + + } + break; + case 41 : + // InternalRos1Lexer.g:1:454: Result_1 + { + mResult_1(); + + } + break; + case 42 : + // InternalRos1Lexer.g:1:463: Service + { + mService(); + + } + break; + case 43 : + // InternalRos1Lexer.g:1:471: Uint8_1 + { + mUint8_1(); + + } + break; + case 44 : + // InternalRos1Lexer.g:1:479: Array + { + mArray(); + + } + break; + case 45 : + // InternalRos1Lexer.g:1:485: Base64 + { + mBase64(); + + } + break; + case 46 : + // InternalRos1Lexer.g:1:492: Double + { + mDouble(); + + } + break; + case 47 : + // InternalRos1Lexer.g:1:499: Header + { + mHeader(); + + } + break; + case 48 : + // InternalRos1Lexer.g:1:506: String + { + mString(); + + } + break; + case 49 : + // InternalRos1Lexer.g:1:513: Struct + { + mStruct(); + + } + break; + case 50 : + // InternalRos1Lexer.g:1:520: Action + { + mAction(); + + } + break; + case 51 : + // InternalRos1Lexer.g:1:527: Bool_1 + { + mBool_1(); + + } + break; + case 52 : + // InternalRos1Lexer.g:1:534: Byte_1 + { + mByte_1(); + + } + break; + case 53 : + // InternalRos1Lexer.g:1:541: Int8_1 + { + mInt8_1(); + + } + break; + case 54 : + // InternalRos1Lexer.g:1:548: Result + { + mResult(); + + } + break; + case 55 : + // InternalRos1Lexer.g:1:555: Specs + { + mSpecs(); + + } + break; + case 56 : + // InternalRos1Lexer.g:1:561: String_1 + { + mString_1(); + + } + break; + case 57 : + // InternalRos1Lexer.g:1:570: Uint16 + { + mUint16(); + + } + break; + case 58 : + // InternalRos1Lexer.g:1:577: Uint32 + { + mUint32(); + + } + break; + case 59 : + // InternalRos1Lexer.g:1:584: Uint64 + { + mUint64(); + + } + break; + case 60 : + // InternalRos1Lexer.g:1:591: Goal_1 + { + mGoal_1(); + + } + break; + case 61 : + // InternalRos1Lexer.g:1:598: Int16 + { + mInt16(); + + } + break; + case 62 : + // InternalRos1Lexer.g:1:604: Int32 + { + mInt32(); + + } + break; + case 63 : + // InternalRos1Lexer.g:1:610: Int64 + { + mInt64(); + + } + break; + case 64 : + // InternalRos1Lexer.g:1:616: Node_1 + { + mNode_1(); + + } + break; + case 65 : + // InternalRos1Lexer.g:1:623: Type_1 + { + mType_1(); + + } + break; + case 66 : + // InternalRos1Lexer.g:1:630: Uint8 + { + mUint8(); + + } + break; + case 67 : + // InternalRos1Lexer.g:1:636: Value + { + mValue(); + + } + break; + case 68 : + // InternalRos1Lexer.g:1:642: Date + { + mDate(); + + } + break; + case 69 : + // InternalRos1Lexer.g:1:647: List + { + mList(); + + } + break; + case 70 : + // InternalRos1Lexer.g:1:652: Bool + { + mBool(); + + } + break; + case 71 : + // InternalRos1Lexer.g:1:657: Byte + { + mByte(); + + } + break; + case 72 : + // InternalRos1Lexer.g:1:662: Goal + { + mGoal(); + + } + break; + case 73 : + // InternalRos1Lexer.g:1:667: Int8 + { + mInt8(); + + } + break; + case 74 : + // InternalRos1Lexer.g:1:672: Msg + { + mMsg(); + + } + break; + case 75 : + // InternalRos1Lexer.g:1:676: Name + { + mName(); + + } + break; + case 76 : + // InternalRos1Lexer.g:1:681: Node + { + mNode(); + + } + break; + case 77 : + // InternalRos1Lexer.g:1:686: Srv + { + mSrv(); + + } + break; + case 78 : + // InternalRos1Lexer.g:1:690: Time + { + mTime(); + + } + break; + case 79 : + // InternalRos1Lexer.g:1:695: Type + { + mType(); + + } + break; + case 80 : + // InternalRos1Lexer.g:1:700: Any + { + mAny(); + + } + break; + case 81 : + // InternalRos1Lexer.g:1:704: Ns + { + mNs(); + + } + break; + case 82 : + // InternalRos1Lexer.g:1:707: LeftSquareBracketRightSquareBracket + { + mLeftSquareBracketRightSquareBracket(); + + } + break; + case 83 : + // InternalRos1Lexer.g:1:743: Comma + { + mComma(); + + } + break; + case 84 : + // InternalRos1Lexer.g:1:749: Colon + { + mColon(); + + } + break; + case 85 : + // InternalRos1Lexer.g:1:755: LeftSquareBracket + { + mLeftSquareBracket(); + + } + break; + case 86 : + // InternalRos1Lexer.g:1:773: RightSquareBracket + { + mRightSquareBracket(); + + } + break; + case 87 : + // InternalRos1Lexer.g:1:792: RightCurlyBracket + { + mRightCurlyBracket(); + + } + break; + case 88 : + // InternalRos1Lexer.g:1:810: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 89 : + // InternalRos1Lexer.g:1:826: RULE_ROS_CONVENTION_A + { + mRULE_ROS_CONVENTION_A(); + + } + break; + case 90 : + // InternalRos1Lexer.g:1:848: RULE_ROS_CONVENTION_PARAM + { + mRULE_ROS_CONVENTION_PARAM(); + + } + break; + case 91 : + // InternalRos1Lexer.g:1:874: RULE_BINARY + { + mRULE_BINARY(); + + } + break; + case 92 : + // InternalRos1Lexer.g:1:886: RULE_BOOLEAN + { + mRULE_BOOLEAN(); + + } + break; + case 93 : + // InternalRos1Lexer.g:1:899: RULE_DOUBLE + { + mRULE_DOUBLE(); + + } + break; + case 94 : + // InternalRos1Lexer.g:1:911: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + case 95 : + // InternalRos1Lexer.g:1:923: RULE_DATE_TIME + { + mRULE_DATE_TIME(); + + } + break; + case 96 : + // InternalRos1Lexer.g:1:938: RULE_MESSAGE_ASIGMENT + { + mRULE_MESSAGE_ASIGMENT(); + + } + break; + case 97 : + // InternalRos1Lexer.g:1:960: RULE_ID + { + mRULE_ID(); + + } + break; + case 98 : + // InternalRos1Lexer.g:1:968: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 99 : + // InternalRos1Lexer.g:1:980: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 100 : + // InternalRos1Lexer.g:1:996: RULE_WS + { + mRULE_WS(); + + } + break; + case 101 : + // InternalRos1Lexer.g:1:1004: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA11 dfa11 = new DFA11(this); + protected DFA28 dfa28 = new DFA28(this); + static final String DFA11_eotS = + "\1\uffff\1\5\1\uffff\2\5\1\uffff\2\5"; + static final String DFA11_eofS = + "\10\uffff"; + static final String DFA11_minS = + "\1\56\1\60\1\uffff\2\60\1\uffff\2\60"; + static final String DFA11_maxS = + "\2\145\1\uffff\2\145\1\uffff\2\145"; + static final String DFA11_acceptS = + "\2\uffff\1\2\2\uffff\1\1\2\uffff"; + static final String DFA11_specialS = + "\10\uffff}>"; + static final String[] DFA11_transitionS = { + "\1\1\26\uffff\1\2\37\uffff\1\2", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2" + }; + + static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); + static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); + static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); + static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); + static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); + static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); + static final short[][] DFA11_transition; + + static { + int numStates = DFA11_transitionS.length; + DFA11_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA28_transitionS = { + "\11\54\2\53\2\54\1\53\22\54\1\53\1\54\1\44\1\37\3\54\1\45\4\54\1\33\1\51\1\54\1\40\1\47\2\50\7\52\1\34\6\54\1\10\1\16\1\42\1\21\1\2\1\42\1\4\1\22\1\17\2\42\1\31\3\42\1\1\1\42\1\3\1\23\7\42\1\32\1\54\1\35\1\41\1\42\1\54\1\6\1\24\1\42\1\7\1\42\1\11\1\25\1\42\1\20\3\42\1\14\1\26\1\42\1\12\1\42\1\13\1\5\1\27\1\15\1\30\4\42\2\54\1\36\1\46\uff81\54", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\55\20\57\1\56\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\27\57\1\62\2\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\63\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\64\5\57\1\65\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\66\12\57\1\71\1\57\1\72\1\57\1\70\1\67\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\73\16\57\1\74\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\75\17\57\1\76\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\77\1\101\3\57\1\100\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\105\3\57\1\103\6\57\1\104\5\57\1\102\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\106\23\57\1\107\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\110\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\111\15\57\1\112\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\113\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\115\15\57\1\114\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\116\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\117\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\121\15\57\1\120\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\122\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\123\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\124\11\57\1\125\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\126\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\130\15\57\1\127\3\57\1\131\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\133\10\57\1\134\6\57\1\132\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\135\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\136\21\57", + "\1\137", + "", + "", + "", + "", + "", + "\1\147\4\uffff\1\147\2\uffff\1\146\26\uffff\32\43\3\uffff\2\43\1\uffff\32\43", + "\32\150\4\uffff\1\150\1\uffff\32\150", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\42\152\1\153\71\152\1\151\uffa3\152", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\1\147\4\uffff\1\147", + "\1\162\1\uffff\12\160\10\uffff\1\157\2\uffff\1\162\34\uffff\1\157\2\uffff\1\162", + "\1\162\1\uffff\12\163\13\uffff\1\162\37\uffff\1\162", + "\12\161", + "\1\162\26\uffff\1\162\37\uffff\1\162", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\165\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\166\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\167\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\170\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\171\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\172\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\173\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\174\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\175\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\176\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\177\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0080\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0081\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\5\57\1\u0083\11\57\1\u0082\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0084\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0085\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0086\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u0087\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u0088\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0089\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u008a\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u008b\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u008c\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u008d\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\20\57\1\u008f\1\57\1\u008e\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0090\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0091\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0092\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u0093\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0094\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0095\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0096\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u0097\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0098\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0099\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u009a\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u009b\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u009c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u009d\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u009e\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u009f\15\57", + "\1\43\12\57\1\u00a0\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00a1\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00a2\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00a3\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00a4\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00a5\7\57", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\0\u00a6", + "\42\152\1\153\71\152\1\151\uffa3\152", + "\1\147\15\uffff\1\61", + "\0\u00a8", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\1\147\15\uffff\1\61", + "", + "", + "", + "", + "\12\u00a9", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00aa\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u00ab\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ac\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00ad\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00ae\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00af\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u00b0\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00b1\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b2\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u00b3\27\57", + "\1\43\12\57\1\u00b4\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b5\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00b7\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00b8\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00b9\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00ba\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00bb\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00bd\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u00be\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00bf\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00c0\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00c1\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00c2\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00c3\4\57\1\u00c4\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00c5\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00c6\7\57", + "\1\43\12\57\1\u00c7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00c8\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00c9\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ca\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00cb\25\57", + "\1\43\1\57\1\u00cc\1\57\1\u00cd\2\57\1\u00ce\1\57\1\u00cf\1\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00d0\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d1\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u00d2\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00d3\13\57\1\u00d4\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00d5\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d6\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00d7\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d8\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d9\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00da\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00db\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00dc\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00dd\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00de\6\57", + "\42\152\1\153\71\152\1\151\uffa3\152", + "", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\12\u00df", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00e0\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00e1\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u00e2\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00e3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00e4\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\7\57\1\u00e5\22\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00e6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u00e7\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00e8\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00e9\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u00ea\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\5\57\1\u00eb\24\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00ec\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00ed\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00ee\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00ef\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u00f0\1\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\6\57\1\u00f1\23\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00f2\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00f3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00f4\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00f5\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00f6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u00f7\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00f8\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00f9\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00fa\31\57", + "", + "\1\43\1\57\1\u00fb\1\57\1\u00fc\2\57\1\u00fd\1\57\1\u00fe\1\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ff\25\57", + "\1\43\6\57\1\u0100\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0101\23\57", + "\1\43\6\57\1\u0102\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\2\57\1\u0103\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u0104\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0105\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0107\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0109\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u010a\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u010b\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u010c\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u010e\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0110\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0112\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0115\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0119\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\160", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u011b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u011c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u011d\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u011e\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u011f\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0120\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0121\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0122\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0123\23\57", + "\1\43\12\57\1\u0124\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0125\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0126\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u0127\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0128\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u0129\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\17\57\1\u012a\12\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u012b\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u012c\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u012d\31\57", + "\1\43\3\57\1\u012e\2\57\1\u012f\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0130\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0131\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0132\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0133\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0134\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0135\23\57", + "\1\43\6\57\1\u0136\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\2\57\1\u0137\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u0138\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0139\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u013b\31\57", + "\1\43\4\57\1\u013c\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u013d\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u013e\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0140\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0142\3\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0144\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0145\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0146\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0147\6\57", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0149\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u014a\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u014b\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u014c\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u014d\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u014e\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u014f\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u0150\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0151\3\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\1\u0155\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0153\17\57\1\u0154\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0157\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0158\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0159\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u015a\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u015b\31\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u015c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u015d\27\57", + "\1\43\2\57\1\u015e\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u015f\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0160\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\7\57\1\u0161\22\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0162\7\57", + "\1\43\12\57\1\u0163\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0165\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0166\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0167\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0169\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u016b\3\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u016d\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u016f\10\57", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0174\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0175\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0176\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0177\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0178\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u0179\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u017a\17\57\1\u017b\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u017d\30\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u017e\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u017f\25\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0180\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0181\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0183\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0184\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\21\57\1\u0185\10\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\12\57\1\u0186\17\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0187\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0189\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018c\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018d\25\57", + "", + "", + "\1\43\12\57\1\u018e\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u018f\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0193\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0194\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\3\57\1\u0195\26\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0196\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u0197\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0198\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0199\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u019a\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u019b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u019c\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u019d\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u019e\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u019f\27\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\12\57\1\u01a1\17\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01a2\25\57", + "\1\43\12\57\1\u01a3\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01a5\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01a6\10\57", + "\1\43\12\57\1\u01a7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\1\u01a9\21\57\1\u01a8\7\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01aa\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ab\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01ac\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ad\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u01af\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01b0\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01b1\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01b2\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u01b3\4\57", + "\1\43\12\57\1\u01b4\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u01b5\21\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01b6\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01b7\12\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01b8\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01b9\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01ba\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01bb\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01bc\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01bd\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01be\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01bf\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c0\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u01c1\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01c2\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01c3\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c4\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c5\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u01c6\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u01c7\13\57", + "\1\43\12\57\1\u01c8\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01c9\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01ca\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u01cb\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01cc\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01cd\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ce\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01cf\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01d0\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01d1\25\57", + "\1\43\12\57\1\u01d2\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01d3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01d4\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01d5\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01d6\25\57", + "\1\43\12\57\1\u01d7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u01d8\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01da\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01db\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01dc\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01dd\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01de\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01df\10\57", + "", + "\1\43\12\57\1\u01e0\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01e1\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01e2\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01e4\27\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01e5\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u01e6\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01e7\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01e8\27\57", + "\1\43\12\57\1\u01e9\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01ea\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01eb\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01ec\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ed\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01ee\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ef\25\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\14\57\1\u01f0\15\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f1\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01f2\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01f3\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f5\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01f7\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f8\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01f9\15\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u01fa\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u01fc\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01fe\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01ff\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "" + }; + + static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS); + static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS); + static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS); + static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS); + static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS); + static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS); + static final short[][] DFA28_transition; + + static { + int numStates = DFA28_transitionS.length; + DFA28_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA28_105<='\uFFFF')) ) {s = 166;} + + if ( s>=0 ) return s; + break; + case 1 : + int LA28_108 = input.LA(1); + + s = -1; + if ( ((LA28_108>='\u0000' && LA28_108<='\uFFFF')) ) {s = 168;} + + if ( s>=0 ) return s; + break; + case 2 : + int LA28_37 = input.LA(1); + + s = -1; + if ( (LA28_37=='\\') ) {s = 108;} + + else if ( ((LA28_37>='\u0000' && LA28_37<='&')||(LA28_37>='(' && LA28_37<='[')||(LA28_37>=']' && LA28_37<='\uFFFF')) ) {s = 109;} + + else if ( (LA28_37=='\'') ) {s = 110;} + + else s = 44; + + if ( s>=0 ) return s; + break; + case 3 : + int LA28_0 = input.LA(1); + + s = -1; + if ( (LA28_0=='P') ) {s = 1;} + + else if ( (LA28_0=='E') ) {s = 2;} + + else if ( (LA28_0=='R') ) {s = 3;} + + else if ( (LA28_0=='G') ) {s = 4;} + + else if ( (LA28_0=='s') ) {s = 5;} + + else if ( (LA28_0=='a') ) {s = 6;} + + else if ( (LA28_0=='d') ) {s = 7;} + + else if ( (LA28_0=='A') ) {s = 8;} + + else if ( (LA28_0=='f') ) {s = 9;} + + else if ( (LA28_0=='p') ) {s = 10;} + + else if ( (LA28_0=='r') ) {s = 11;} + + else if ( (LA28_0=='m') ) {s = 12;} + + else if ( (LA28_0=='u') ) {s = 13;} + + else if ( (LA28_0=='B') ) {s = 14;} + + else if ( (LA28_0=='I') ) {s = 15;} + + else if ( (LA28_0=='i') ) {s = 16;} + + else if ( (LA28_0=='D') ) {s = 17;} + + else if ( (LA28_0=='H') ) {s = 18;} + + else if ( (LA28_0=='S') ) {s = 19;} + + else if ( (LA28_0=='b') ) {s = 20;} + + else if ( (LA28_0=='g') ) {s = 21;} + + else if ( (LA28_0=='n') ) {s = 22;} + + else if ( (LA28_0=='t') ) {s = 23;} + + else if ( (LA28_0=='v') ) {s = 24;} + + else if ( (LA28_0=='L') ) {s = 25;} + + else if ( (LA28_0=='[') ) {s = 26;} + + else if ( (LA28_0==',') ) {s = 27;} + + else if ( (LA28_0==':') ) {s = 28;} + + else if ( (LA28_0==']') ) {s = 29;} + + else if ( (LA28_0=='}') ) {s = 30;} + + else if ( (LA28_0=='#') ) {s = 31;} + + else if ( (LA28_0=='/') ) {s = 32;} + + else if ( (LA28_0=='^') ) {s = 33;} + + else if ( (LA28_0=='C'||LA28_0=='F'||(LA28_0>='J' && LA28_0<='K')||(LA28_0>='M' && LA28_0<='O')||LA28_0=='Q'||(LA28_0>='T' && LA28_0<='Z')||LA28_0=='_'||LA28_0=='c'||LA28_0=='e'||LA28_0=='h'||(LA28_0>='j' && LA28_0<='l')||LA28_0=='o'||LA28_0=='q'||(LA28_0>='w' && LA28_0<='z')) ) {s = 34;} + + else if ( (LA28_0=='\"') ) {s = 36;} + + else if ( (LA28_0=='\'') ) {s = 37;} + + else if ( (LA28_0=='~') ) {s = 38;} + + else if ( (LA28_0=='0') ) {s = 39;} + + else if ( ((LA28_0>='1' && LA28_0<='2')) ) {s = 40;} + + else if ( (LA28_0=='-') ) {s = 41;} + + else if ( ((LA28_0>='3' && LA28_0<='9')) ) {s = 42;} + + else if ( ((LA28_0>='\t' && LA28_0<='\n')||LA28_0=='\r'||LA28_0==' ') ) {s = 43;} + + else if ( ((LA28_0>='\u0000' && LA28_0<='\b')||(LA28_0>='\u000B' && LA28_0<='\f')||(LA28_0>='\u000E' && LA28_0<='\u001F')||LA28_0=='!'||(LA28_0>='$' && LA28_0<='&')||(LA28_0>='(' && LA28_0<='+')||LA28_0=='.'||(LA28_0>=';' && LA28_0<='@')||LA28_0=='\\'||LA28_0=='`'||(LA28_0>='{' && LA28_0<='|')||(LA28_0>='\u007F' && LA28_0<='\uFFFF')) ) {s = 44;} + + else s = 35; + + if ( s>=0 ) return s; + break; + case 4 : + int LA28_166 = input.LA(1); + + s = -1; + if ( (LA28_166=='\"') ) {s = 107;} + + else if ( (LA28_166=='\\') ) {s = 105;} + + else if ( ((LA28_166>='\u0000' && LA28_166<='!')||(LA28_166>='#' && LA28_166<='[')||(LA28_166>=']' && LA28_166<='\uFFFF')) ) {s = 106;} + + if ( s>=0 ) return s; + break; + case 5 : + int LA28_106 = input.LA(1); + + s = -1; + if ( (LA28_106=='\"') ) {s = 107;} + + else if ( (LA28_106=='\\') ) {s = 105;} + + else if ( ((LA28_106>='\u0000' && LA28_106<='!')||(LA28_106>='#' && LA28_106<='[')||(LA28_106>=']' && LA28_106<='\uFFFF')) ) {s = 106;} + + if ( s>=0 ) return s; + break; + case 6 : + int LA28_36 = input.LA(1); + + s = -1; + if ( (LA28_36=='\\') ) {s = 105;} + + else if ( ((LA28_36>='\u0000' && LA28_36<='!')||(LA28_36>='#' && LA28_36<='[')||(LA28_36>=']' && LA28_36<='\uFFFF')) ) {s = 106;} + + else if ( (LA28_36=='\"') ) {s = 107;} + + else s = 44; + + if ( s>=0 ) return s; + break; + case 7 : + int LA28_168 = input.LA(1); + + s = -1; + if ( (LA28_168=='\'') ) {s = 110;} + + else if ( (LA28_168=='\\') ) {s = 108;} + + else if ( ((LA28_168>='\u0000' && LA28_168<='&')||(LA28_168>='(' && LA28_168<='[')||(LA28_168>=']' && LA28_168<='\uFFFF')) ) {s = 109;} + + if ( s>=0 ) return s; + break; + case 8 : + int LA28_109 = input.LA(1); + + s = -1; + if ( (LA28_109=='\'') ) {s = 110;} + + else if ( (LA28_109=='\\') ) {s = 108;} + + else if ( ((LA28_109>='\u0000' && LA28_109<='&')||(LA28_109>='(' && LA28_109<='[')||(LA28_109>=']' && LA28_109<='\uFFFF')) ) {s = 109;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 28, _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..135670e45 --- /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,110 @@ +Action=53 +Action_1=36 +Actionclient=11 +Actionserver=12 +AmentPackage=14 +Any=83 +Array=47 +Artifacts=20 +Base64=48 +Bool=73 +Bool_1=54 +Boolean=34 +Byte=74 +Byte_1=55 +Colon=87 +Comma=86 +Date=71 +Default=37 +Dependencies=13 +Double=49 +Duration=26 +ExternalDependency=5 +Feedback=27 +Feedback_1=22 +Float32=38 +Float32_1=23 +Float64=39 +Float64_1=24 +FromGitRepo=16 +GlobalNamespace=8 +Goal=75 +Goal_1=63 +GraphName=21 +Header=50 +Int16=64 +Int16_1=40 +Int32=65 +Int32_1=41 +Int64=66 +Int64_1=42 +Int8=76 +Int8_1=56 +Integer=35 +LeftSquareBracket=88 +LeftSquareBracketRightSquareBracket=85 +List=72 +Message=43 +Message_1=28 +Msg=77 +Name=78 +Node=79 +Node_1=67 +Ns=84 +ParameterAny=15 +ParameterStructMember=4 +Parameters=18 +PrivateNamespace=7 +Publishers=19 +RULE_ANY_OTHER=113 +RULE_BEGIN=91 +RULE_BINARY=99 +RULE_BOOLEAN=100 +RULE_DATE_TIME=108 +RULE_DAY=103 +RULE_DECINT=101 +RULE_DIGIT=98 +RULE_DOUBLE=102 +RULE_END=92 +RULE_HOUR=106 +RULE_ID=94 +RULE_INT=109 +RULE_MESSAGE_ASIGMENT=110 +RULE_MIN_SEC=107 +RULE_ML_COMMENT=111 +RULE_MONTH=104 +RULE_ROS_CONVENTION_A=95 +RULE_ROS_CONVENTION_PARAM=97 +RULE_SL_COMMENT=93 +RULE_STRING=96 +RULE_WS=112 +RULE_YEAR=105 +RelativeNamespace=6 +Request=29 +Response=25 +Result=57 +Result_1=44 +RightCurlyBracket=90 +RightSquareBracket=89 +Service=45 +Serviceclient=9 +Serviceserver=10 +Specs=58 +Srv=80 +String=51 +String_1=59 +String_2=30 +Struct=52 +Subscribers=17 +Time=81 +Type=82 +Type_1=68 +Uint16=60 +Uint16_1=31 +Uint32=61 +Uint32_1=32 +Uint64=62 +Uint64_1=33 +Uint8=69 +Uint8_1=46 +Value=70 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..c8ce63a08 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/META-INF/MANIFEST.MF @@ -0,0 +1,27 @@ +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: Fraunhofer IPA +Bundle-Version: 2.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, + de.fraunhofer.ipa.ros.xtext, + de.fraunhofer.ipa.ros.xtext.ui +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/pom.xml b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/pom.xml new file mode 100644 index 000000000..831c7fb61 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/pom.xml @@ -0,0 +1,33 @@ + + 4.0.0 + + de.fraunhofer.ipa.ros + de.fraunhofer.ipa.ros.parent + 2.0.0-SNAPSHOT + ../de.fraunhofer.ipa.ros.parent/pom.xml + + de.fraunhofer.ipa.ros1.xtext.ui + eclipse-plugin + + + + + org.eclipse.xtend + xtend-maven-plugin + + + org.apache.maven.plugins + maven-clean-plugin + + + xtend-gen-clean + clean + + + + + + + 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..f386bfc74 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/contentassist/AbstractRos1ProposalProvider.java @@ -0,0 +1,15 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ui.contentassist; + +import de.fraunhofer.ipa.ros.ui.contentassist.RosProposalProvider; + +/** + * Represents a generated, default implementation of superclass {@link RosProposalProvider}. + * Methods are dynamically dispatched on the first parameter, i.e., you can override them + * with a more concrete subtype. + */ +public abstract class AbstractRos1ProposalProvider extends RosProposalProvider { + +} 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..e25e62230 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/META-INF/MANIFEST.MF @@ -0,0 +1,29 @@ +Manifest-Version: 1.0 +Automatic-Module-Name: de.fraunhofer.ipa.ros1.xtext +Bundle-ManifestVersion: 2 +Bundle-Name: de.fraunhofer.ipa.ros1.xtext +Bundle-Vendor: Fraunhofer IPA +Bundle-Version: 2.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)", + de.fraunhofer.ipa.ros.xtext;bundle-version="2.0.0", + de.fraunhofer.ipa.ros.xtext.ui;bundle-version="2.0.0" +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/pom.xml b/plugins/de.fraunhofer.ipa.ros1.xtext/pom.xml new file mode 100644 index 000000000..ce5f5381f --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/pom.xml @@ -0,0 +1,105 @@ + + 4.0.0 + + de.fraunhofer.ipa.ros + de.fraunhofer.ipa.ros.parent + 2.0.0-SNAPSHOT + ../de.fraunhofer.ipa.ros.parent/pom.xml + + de.fraunhofer.ipa.ros1.xtext + eclipse-plugin + + + + + org.codehaus.mojo + exec-maven-plugin + 1.4.0 + + + mwe2Launcher + generate-sources + + java + + + + + org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher + + /${project.basedir}/src/de/fraunhofer/ipa/ros1/GenerateRos1.mwe2 + -p + rootPath=/${project.basedir}/.. + + compile + true + false + + + + org.eclipse.emf + org.eclipse.emf.mwe2.launch + 2.9.1.201705291010 + + + org.eclipse.xtext + org.eclipse.xtext.common.types + ${xtextVersion} + + + org.eclipse.xtext + org.eclipse.xtext.xtext.generator + ${xtextVersion} + + + org.eclipse.xtext + org.eclipse.xtext.xbase + ${xtextVersion} + + + org.eclipse.xtext + xtext-antlr-generator + [2.1.1, 3) + + + + + org.eclipse.xtend + xtend-maven-plugin + + + + org.apache.maven.plugins + maven-clean-plugin + + + + ${basedir}/../de.fraunhofer.ipa.ros1.xtext/src-gen/ + + **/* + + + + ${basedir}/../de.fraunhofer.ipa.ros1.xtext.ide/src-gen/ + + **/* + + + + ${basedir}/../de.fraunhofer.ipa.ros1.xtext.ui/src-gen/ + + **/* + + + + ${basedir}/model/generated/ + + + + + + + + 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 000000000..944dd9797 Binary files /dev/null and b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/Ros1.xtextbin differ diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/Ros1StandaloneSetupGenerated.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/Ros1StandaloneSetupGenerated.java new file mode 100644 index 000000000..07f6a56fc --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/Ros1StandaloneSetupGenerated.java @@ -0,0 +1,37 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1; + +import com.google.inject.Guice; +import com.google.inject.Injector; +import de.fraunhofer.ipa.ros.RosStandaloneSetup; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.xtext.ISetup; +import org.eclipse.xtext.resource.IResourceFactory; +import org.eclipse.xtext.resource.IResourceServiceProvider; + +@SuppressWarnings("all") +public class Ros1StandaloneSetupGenerated implements ISetup { + + @Override + public Injector createInjectorAndDoEMFRegistration() { + RosStandaloneSetup.doSetup(); + + Injector injector = createInjector(); + register(injector); + return injector; + } + + public Injector createInjector() { + return Guice.createInjector(new Ros1RuntimeModule()); + } + + public void register(Injector injector) { + IResourceFactory resourceFactory = injector.getInstance(IResourceFactory.class); + IResourceServiceProvider serviceProvider = injector.getInstance(IResourceServiceProvider.class); + + Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("ros1", resourceFactory); + IResourceServiceProvider.Registry.INSTANCE.getExtensionToFactoryMap().put("ros1", serviceProvider); + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/Ros1AntlrTokenFileProvider.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/Ros1AntlrTokenFileProvider.java new file mode 100644 index 000000000..356579eb1 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/Ros1AntlrTokenFileProvider.java @@ -0,0 +1,16 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.parser.antlr; + +import java.io.InputStream; +import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider; + +public class Ros1AntlrTokenFileProvider implements IAntlrTokenFileProvider { + + @Override + public InputStream getAntlrTokenFile() { + ClassLoader classLoader = getClass().getClassLoader(); + return classLoader.getResourceAsStream("de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.tokens"); + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/Ros1Parser.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/Ros1Parser.java new file mode 100644 index 000000000..ea24c78cf --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/Ros1Parser.java @@ -0,0 +1,55 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.parser.antlr; + +import com.google.inject.Inject; +import de.fraunhofer.ipa.ros1.parser.antlr.internal.InternalRos1Parser; +import de.fraunhofer.ipa.ros1.services.Ros1GrammarAccess; +import org.antlr.runtime.CharStream; +import org.antlr.runtime.TokenSource; +import org.eclipse.xtext.parser.antlr.AbstractAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; + +public class Ros1Parser extends AbstractAntlrParser { + + @Inject + private Ros1GrammarAccess grammarAccess; + + @Override + protected void setInitialHiddenTokens(XtextTokenStream tokenStream) { + tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT"); + } + + @Override + protected TokenSource createLexer(CharStream stream) { + return new Ros1TokenSource(super.createLexer(stream)); + } + + /** + * Indentation aware languages do not support partial parsing since the lexer is inherently stateful. + * Override and return {@code true} if your terminal splitting is stateless. + */ + @Override + protected boolean isReparseSupported() { + return false; + } + + @Override + protected InternalRos1Parser createParser(XtextTokenStream stream) { + return new InternalRos1Parser(stream, getGrammarAccess()); + } + + @Override + protected String getDefaultRuleName() { + return "Package"; + } + + public Ros1GrammarAccess getGrammarAccess() { + return this.grammarAccess; + } + + public void setGrammarAccess(Ros1GrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.g b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.g new file mode 100644 index 000000000..9b8b44da3 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.g @@ -0,0 +1,5294 @@ +/* + * generated by Xtext 2.25.0 + */ +parser grammar InternalRos1Parser; + +options { + tokenVocab=InternalRos1Lexer; + superClass=AbstractInternalAntlrParser; +} + +@header { +package de.fraunhofer.ipa.ros1.parser.antlr.internal; + +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; +import de.fraunhofer.ipa.ros1.services.Ros1GrammarAccess; + +} + +@members { + + private Ros1GrammarAccess grammarAccess; + + public InternalRos1Parser(TokenStream input, Ros1GrammarAccess grammarAccess) { + this(input); + this.grammarAccess = grammarAccess; + registerRules(grammarAccess.getGrammar()); + } + + @Override + protected String getFirstRuleName() { + return "Package"; + } + + @Override + protected Ros1GrammarAccess getGrammarAccess() { + return grammarAccess; + } + +} + +@rulecatch { + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } +} + +// Entry rule entryRulePackage +entryRulePackage returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPackageRule()); } + iv_rulePackage=rulePackage + { $current=$iv_rulePackage.current; } + EOF; + +// Rule Package +rulePackage returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + { + newCompositeNode(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall()); + } + this_CatkinPackage_0=ruleCatkinPackage + { + $current = $this_CatkinPackage_0.current; + afterParserOrEnumRuleCall(); + } +; + +// Entry rule entryRuleCatkinPackage +entryRuleCatkinPackage returns [EObject current=null]: + { newCompositeNode(grammarAccess.getCatkinPackageRule()); } + iv_ruleCatkinPackage=ruleCatkinPackage + { $current=$iv_ruleCatkinPackage.current; } + EOF; + +// Rule CatkinPackage +ruleCatkinPackage returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_1_0()); + } + lv_name_1_0=ruleRosNames + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getCatkinPackageAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_3()); + } + ( + otherlv_4=FromGitRepo + { + newLeafNode(otherlv_4, grammarAccess.getCatkinPackageAccess().getFromGitRepoKeyword_4_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + } + lv_fromGitRepo_5_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + } + set( + $current, + "fromGitRepo", + lv_fromGitRepo_5_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ( + otherlv_6=Artifacts + { + newLeafNode(otherlv_6, grammarAccess.getCatkinPackageAccess().getArtifactsKeyword_5_0()); + } + this_BEGIN_7=RULE_BEGIN + { + newLeafNode(this_BEGIN_7, grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_5_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); + } + lv_artifact_8_0=ruleArtifact + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + } + add( + $current, + "artifact", + lv_artifact_8_0, + "de.fraunhofer.ipa.ros.Ros.Artifact"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_9=RULE_END + { + newLeafNode(this_END_9, grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_5_3()); + } + )? + ( + otherlv_10=Dependencies + { + newLeafNode(otherlv_10, grammarAccess.getCatkinPackageAccess().getDependenciesKeyword_6_0()); + } + otherlv_11=LeftSquareBracket + { + newLeafNode(otherlv_11, grammarAccess.getCatkinPackageAccess().getLeftSquareBracketKeyword_6_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); + } + lv_dependency_12_0=ruleDependency + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + } + add( + $current, + "dependency", + lv_dependency_12_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_13=Comma + { + newLeafNode(otherlv_13, grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + } + lv_dependency_14_0=ruleDependency + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + } + add( + $current, + "dependency", + lv_dependency_14_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_15=RightSquareBracket + { + newLeafNode(otherlv_15, grammarAccess.getCatkinPackageAccess().getRightSquareBracketKeyword_6_4()); + } + )? + this_END_16=RULE_END + { + newLeafNode(this_END_16, grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleEString +entryRuleEString returns [String current=null]: + { newCompositeNode(grammarAccess.getEStringRule()); } + iv_ruleEString=ruleEString + { $current=$iv_ruleEString.current.getText(); } + EOF; + +// Rule EString +ruleEString returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + this_STRING_0=RULE_STRING + { + $current.merge(this_STRING_0); + } + { + newLeafNode(this_STRING_0, grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + } + | + this_ID_1=RULE_ID + { + $current.merge(this_ID_1); + } + { + newLeafNode(this_ID_1, grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); + } + ) +; + +// Entry rule entryRuleRosNames +entryRuleRosNames returns [String current=null]: + { newCompositeNode(grammarAccess.getRosNamesRule()); } + iv_ruleRosNames=ruleRosNames + { $current=$iv_ruleRosNames.current.getText(); } + EOF; + +// Rule RosNames +ruleRosNames returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + this_ROS_CONVENTION_A_0=RULE_ROS_CONVENTION_A + { + $current.merge(this_ROS_CONVENTION_A_0); + } + { + newLeafNode(this_ROS_CONVENTION_A_0, grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); + } + | + this_ID_1=RULE_ID + { + $current.merge(this_ID_1); + } + { + newLeafNode(this_ID_1, grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); + } + | + kw=Node + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getRosNamesAccess().getNodeKeyword_2()); + } + ) +; + +// Entry rule entryRulePackage_Impl +entryRulePackage_Impl returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPackage_ImplRule()); } + iv_rulePackage_Impl=rulePackage_Impl + { $current=$iv_rulePackage_Impl.current; } + EOF; + +// Rule Package_Impl +rulePackage_Impl returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getPackage_ImplAccess().getPackageAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); + } + lv_name_1_0=ruleRosNames + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); + } + ( + otherlv_4=FromGitRepo + { + newLeafNode(otherlv_4, grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + } + lv_fromGitRepo_5_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + set( + $current, + "fromGitRepo", + lv_fromGitRepo_5_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ( + otherlv_6=Specs + { + newLeafNode(otherlv_6, grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + } + this_BEGIN_7=RULE_BEGIN + { + newLeafNode(this_BEGIN_7, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); + } + lv_spec_8_0=ruleSpecBase + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + $current, + "spec", + lv_spec_8_0, + "de.fraunhofer.ipa.ros.Ros.SpecBase"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_9=RULE_END + { + newLeafNode(this_END_9, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); + } + )? + ( + otherlv_10=Dependencies + { + newLeafNode(otherlv_10, grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); + } + otherlv_11=LeftSquareBracket + { + newLeafNode(otherlv_11, grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); + } + lv_dependency_12_0=ruleDependency + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + $current, + "dependency", + lv_dependency_12_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_13=Comma + { + newLeafNode(otherlv_13, grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + } + lv_dependency_14_0=ruleDependency + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + $current, + "dependency", + lv_dependency_14_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_15=RightSquareBracket + { + newLeafNode(otherlv_15, grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); + } + )? + this_END_16=RULE_END + { + newLeafNode(this_END_16, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleArtifact +entryRuleArtifact returns [EObject current=null]: + { newCompositeNode(grammarAccess.getArtifactRule()); } + iv_ruleArtifact=ruleArtifact + { $current=$iv_ruleArtifact.current; } + EOF; + +// Rule Artifact +ruleArtifact returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getArtifactAccess().getArtifactAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); + } + lv_name_1_0=ruleRosNames + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getArtifactRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getArtifactAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); + } + ( + ( + { + newCompositeNode(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); + } + lv_node_4_0=ruleNode + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getArtifactRule()); + } + set( + $current, + "node", + lv_node_4_0, + "de.fraunhofer.ipa.ros.Ros.Node"); + afterParserOrEnumRuleCall(); + } + ) + )? + this_END_5=RULE_END + { + newLeafNode(this_END_5, grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); + } + ) +; + +// Entry rule entryRuleNode +entryRuleNode returns [EObject current=null]: + { newCompositeNode(grammarAccess.getNodeRule()); } + iv_ruleNode=ruleNode + { $current=$iv_ruleNode.current; } + EOF; + +// Rule Node +ruleNode returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0=Node_1 + { + newLeafNode(otherlv_0, grammarAccess.getNodeAccess().getNodeKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); + } + lv_name_1_0=ruleRosNames + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_BEGIN_2=RULE_BEGIN + { + newLeafNode(this_BEGIN_2, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); + } + ( + ( + otherlv_3=Publishers + { + newLeafNode(otherlv_3, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); + } + this_BEGIN_4=RULE_BEGIN + { + newLeafNode(this_BEGIN_4, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); + } + lv_publisher_5_0=rulePublisher + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "publisher", + lv_publisher_5_0, + "de.fraunhofer.ipa.ros.Ros.Publisher"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_6=RULE_END + { + newLeafNode(this_END_6, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); + } + ) + | + ( + otherlv_7=Subscribers + { + newLeafNode(otherlv_7, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); + } + this_BEGIN_8=RULE_BEGIN + { + newLeafNode(this_BEGIN_8, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); + } + lv_subscriber_9_0=ruleSubscriber + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "subscriber", + lv_subscriber_9_0, + "de.fraunhofer.ipa.ros.Ros.Subscriber"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_10=RULE_END + { + newLeafNode(this_END_10, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); + } + ) + | + ( + otherlv_11=Serviceserver + { + newLeafNode(otherlv_11, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); + } + this_BEGIN_12=RULE_BEGIN + { + newLeafNode(this_BEGIN_12, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); + } + lv_serviceserver_13_0=ruleServiceServer + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "serviceserver", + lv_serviceserver_13_0, + "de.fraunhofer.ipa.ros.Ros.ServiceServer"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_14=RULE_END + { + newLeafNode(this_END_14, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); + } + ) + | + ( + otherlv_15=Serviceclient + { + newLeafNode(otherlv_15, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); + } + this_BEGIN_16=RULE_BEGIN + { + newLeafNode(this_BEGIN_16, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); + } + lv_serviceclient_17_0=ruleServiceClient + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "serviceclient", + lv_serviceclient_17_0, + "de.fraunhofer.ipa.ros.Ros.ServiceClient"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_18=RULE_END + { + newLeafNode(this_END_18, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); + } + ) + | + ( + otherlv_19=Actionserver + { + newLeafNode(otherlv_19, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); + } + this_BEGIN_20=RULE_BEGIN + { + newLeafNode(this_BEGIN_20, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); + } + lv_actionserver_21_0=ruleActionServer + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "actionserver", + lv_actionserver_21_0, + "de.fraunhofer.ipa.ros.Ros.ActionServer"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_22=RULE_END + { + newLeafNode(this_END_22, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); + } + ) + | + ( + otherlv_23=Actionclient + { + newLeafNode(otherlv_23, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); + } + this_BEGIN_24=RULE_BEGIN + { + newLeafNode(this_BEGIN_24, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); + } + lv_actionclient_25_0=ruleActionClient + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "actionclient", + lv_actionclient_25_0, + "de.fraunhofer.ipa.ros.Ros.ActionClient"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_26=RULE_END + { + newLeafNode(this_END_26, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); + } + ) + | + ( + otherlv_27=Parameters + { + newLeafNode(otherlv_27, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); + } + this_BEGIN_28=RULE_BEGIN + { + newLeafNode(this_BEGIN_28, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); + } + lv_parameter_29_0=ruleParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + $current, + "parameter", + lv_parameter_29_0, + "de.fraunhofer.ipa.ros.Ros.Parameter"); + afterParserOrEnumRuleCall(); + } + ) + )* + this_END_30=RULE_END + { + newLeafNode(this_END_30, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); + } + ) + )* + this_END_31=RULE_END + { + newLeafNode(this_END_31, grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); + } + ) +; + +// Entry rule entryRuleSpecBase +entryRuleSpecBase returns [EObject current=null]: + { newCompositeNode(grammarAccess.getSpecBaseRule()); } + iv_ruleSpecBase=ruleSpecBase + { $current=$iv_ruleSpecBase.current; } + EOF; + +// Rule SpecBase +ruleSpecBase returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); + } + this_TopicSpec_0=ruleTopicSpec + { + $current = $this_TopicSpec_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); + } + this_ServiceSpec_1=ruleServiceSpec + { + $current = $this_ServiceSpec_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); + } + this_ActionSpec_2=ruleActionSpec + { + $current = $this_ActionSpec_2.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleTopicSpec +entryRuleTopicSpec returns [EObject current=null]: + { newCompositeNode(grammarAccess.getTopicSpecRule()); } + iv_ruleTopicSpec=ruleTopicSpec + { $current=$iv_ruleTopicSpec.current; } + EOF; + +// Rule TopicSpec +ruleTopicSpec returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getTopicSpecAccess().getTopicSpecAction_0(), + $current); + } + ) + otherlv_1=Msg + { + newLeafNode(otherlv_1, grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + } + lv_name_2_1=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getTopicSpecRule()); + } + set( + $current, + "name", + lv_name_2_1, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + | + lv_name_2_2=Header + { + newLeafNode(lv_name_2_2, grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getTopicSpecRule()); + } + setWithLastConsumed($current, "name", lv_name_2_2, null); + } + | + lv_name_2_3=String + { + newLeafNode(lv_name_2_3, grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getTopicSpecRule()); + } + setWithLastConsumed($current, "name", lv_name_2_3, null); + } + ) + ) + ) + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Message_1 + { + newLeafNode(otherlv_4, grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); + } + ( + this_BEGIN_5=RULE_BEGIN + { + newLeafNode(this_BEGIN_5, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); + } + lv_message_6_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getTopicSpecRule()); + } + set( + $current, + "message", + lv_message_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_7=RULE_END + { + newLeafNode(this_END_7, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); + } + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); + } + ) +; + +// Entry rule entryRuleServiceSpec +entryRuleServiceSpec returns [EObject current=null]: + { newCompositeNode(grammarAccess.getServiceSpecRule()); } + iv_ruleServiceSpec=ruleServiceSpec + { $current=$iv_ruleServiceSpec.current; } + EOF; + +// Rule ServiceSpec +ruleServiceSpec returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getServiceSpecAccess().getServiceSpecAction_0(), + $current); + } + ) + otherlv_1=Srv + { + newLeafNode(otherlv_1, grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); + } + lv_name_2_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + $current, + "name", + lv_name_2_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Request + { + newLeafNode(otherlv_4, grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); + } + ( + this_BEGIN_5=RULE_BEGIN + { + newLeafNode(this_BEGIN_5, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); + } + lv_request_6_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + $current, + "request", + lv_request_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_7=RULE_END + { + newLeafNode(this_END_7, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); + } + )? + otherlv_8=Response + { + newLeafNode(otherlv_8, grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); + } + ( + this_BEGIN_9=RULE_BEGIN + { + newLeafNode(this_BEGIN_9, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); + } + lv_response_10_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + $current, + "response", + lv_response_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_11=RULE_END + { + newLeafNode(this_END_11, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); + } + )? + this_END_12=RULE_END + { + newLeafNode(this_END_12, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); + } + ) +; + +// Entry rule entryRuleActionSpec +entryRuleActionSpec returns [EObject current=null]: + { newCompositeNode(grammarAccess.getActionSpecRule()); } + iv_ruleActionSpec=ruleActionSpec + { $current=$iv_ruleActionSpec.current; } + EOF; + +// Rule ActionSpec +ruleActionSpec returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getActionSpecAccess().getActionSpecAction_0(), + $current); + } + ) + otherlv_1=Action_1 + { + newLeafNode(otherlv_1, grammarAccess.getActionSpecAccess().getActionKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + } + lv_name_2_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + $current, + "name", + lv_name_2_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Goal_1 + { + newLeafNode(otherlv_4, grammarAccess.getActionSpecAccess().getGoalKeyword_4()); + } + ( + this_BEGIN_5=RULE_BEGIN + { + newLeafNode(this_BEGIN_5, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); + } + lv_goal_6_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + $current, + "goal", + lv_goal_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_7=RULE_END + { + newLeafNode(this_END_7, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); + } + )? + otherlv_8=Result_1 + { + newLeafNode(otherlv_8, grammarAccess.getActionSpecAccess().getResultKeyword_6()); + } + ( + this_BEGIN_9=RULE_BEGIN + { + newLeafNode(this_BEGIN_9, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); + } + lv_result_10_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + $current, + "result", + lv_result_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_11=RULE_END + { + newLeafNode(this_END_11, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); + } + )? + otherlv_12=Feedback_1 + { + newLeafNode(otherlv_12, grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + } + ( + this_BEGIN_13=RULE_BEGIN + { + newLeafNode(this_BEGIN_13, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); + } + lv_feedback_14_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + $current, + "feedback", + lv_feedback_14_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_15=RULE_END + { + newLeafNode(this_END_15, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); + } + )? + this_END_16=RULE_END + { + newLeafNode(this_END_16, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); + } + ) +; + +// Entry rule entryRuleMessageDefinition +entryRuleMessageDefinition returns [EObject current=null]: + { newCompositeNode(grammarAccess.getMessageDefinitionRule()); } + iv_ruleMessageDefinition=ruleMessageDefinition + { $current=$iv_ruleMessageDefinition.current; } + EOF; + +// Rule MessageDefinition +ruleMessageDefinition returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); + } + lv_MessagePart_1_0=ruleMessagePart + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getMessageDefinitionRule()); + } + add( + $current, + "MessagePart", + lv_MessagePart_1_0, + "de.fraunhofer.ipa.ros.Ros.MessagePart"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) +; + +// Entry rule entryRulePublisher +entryRulePublisher returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPublisherRule()); } + iv_rulePublisher=rulePublisher + { $current=$iv_rulePublisher.current; } + EOF; + +// Rule Publisher +rulePublisher returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getPublisherAccess().getPublisherAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPublisherRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getPublisherAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getPublisherAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getPublisherRule()); + } + } + { + newCompositeNode(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getPublisherAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPublisherRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleSubscriber +entryRuleSubscriber returns [EObject current=null]: + { newCompositeNode(grammarAccess.getSubscriberRule()); } + iv_ruleSubscriber=ruleSubscriber + { $current=$iv_ruleSubscriber.current; } + EOF; + +// Rule Subscriber +ruleSubscriber returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getSubscriberAccess().getSubscriberAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getSubscriberRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getSubscriberAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getSubscriberAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getSubscriberRule()); + } + } + { + newCompositeNode(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getSubscriberRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleServiceServer +entryRuleServiceServer returns [EObject current=null]: + { newCompositeNode(grammarAccess.getServiceServerRule()); } + iv_ruleServiceServer=ruleServiceServer + { $current=$iv_ruleServiceServer.current; } + EOF; + +// Rule ServiceServer +ruleServiceServer returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getServiceServerAccess().getServiceServerAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceServerRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getServiceServerAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getServiceServerAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getServiceServerRule()); + } + } + { + newCompositeNode(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceServerRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleServiceClient +entryRuleServiceClient returns [EObject current=null]: + { newCompositeNode(grammarAccess.getServiceClientRule()); } + iv_ruleServiceClient=ruleServiceClient + { $current=$iv_ruleServiceClient.current; } + EOF; + +// Rule ServiceClient +ruleServiceClient returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getServiceClientAccess().getServiceClientAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceClientRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getServiceClientAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getServiceClientAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getServiceClientRule()); + } + } + { + newCompositeNode(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceClientRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleActionServer +entryRuleActionServer returns [EObject current=null]: + { newCompositeNode(grammarAccess.getActionServerRule()); } + iv_ruleActionServer=ruleActionServer + { $current=$iv_ruleActionServer.current; } + EOF; + +// Rule ActionServer +ruleActionServer returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getActionServerAccess().getActionServerAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionServerRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getActionServerAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getActionServerAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getActionServerRule()); + } + } + { + newCompositeNode(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getActionServerAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionServerRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleActionClient +entryRuleActionClient returns [EObject current=null]: + { newCompositeNode(grammarAccess.getActionClientRule()); } + iv_ruleActionClient=ruleActionClient + { $current=$iv_ruleActionClient.current; } + EOF; + +// Rule ActionClient +ruleActionClient returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getActionClientAccess().getActionClientAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionClientRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getActionClientAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getActionClientAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getActionClientRule()); + } + } + { + newCompositeNode(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getActionClientAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionClientRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); + } + ) +; + +// Entry rule entryRuleDependency +entryRuleDependency returns [EObject current=null]: + { newCompositeNode(grammarAccess.getDependencyRule()); } + iv_ruleDependency=ruleDependency + { $current=$iv_ruleDependency.current; } + EOF; + +// Rule Dependency +ruleDependency returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + } + this_PackageDependency_0=rulePackageDependency + { + $current = $this_PackageDependency_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); + } + this_ExternalDependency_1=ruleExternalDependency + { + $current = $this_ExternalDependency_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRulePackageDependency +entryRulePackageDependency returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPackageDependencyRule()); } + iv_rulePackageDependency=rulePackageDependency + { $current=$iv_rulePackageDependency.current; } + EOF; + +// Rule PackageDependency +rulePackageDependency returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getPackageDependencyRule()); + } + } + { + newCompositeNode(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleExternalDependency +entryRuleExternalDependency returns [EObject current=null]: + { newCompositeNode(grammarAccess.getExternalDependencyRule()); } + iv_ruleExternalDependency=ruleExternalDependency + { $current=$iv_ruleExternalDependency.current; } + EOF; + +// Rule ExternalDependency +ruleExternalDependency returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0(), + $current); + } + ) + otherlv_1=ExternalDependency + { + newLeafNode(otherlv_1, grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getExternalDependencyAccess().getNameEStringParserRuleCall_2_0()); + } + lv_name_2_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getExternalDependencyRule()); + } + set( + $current, + "name", + lv_name_2_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleNamespace +entryRuleNamespace returns [EObject current=null]: + { newCompositeNode(grammarAccess.getNamespaceRule()); } + iv_ruleNamespace=ruleNamespace + { $current=$iv_ruleNamespace.current; } + EOF; + +// Rule Namespace +ruleNamespace returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + } + this_GlobalNamespace_0=ruleGlobalNamespace + { + $current = $this_GlobalNamespace_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + } + this_RelativeNamespace_Impl_1=ruleRelativeNamespace_Impl + { + $current = $this_RelativeNamespace_Impl_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + } + this_PrivateNamespace_2=rulePrivateNamespace + { + $current = $this_PrivateNamespace_2.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleGraphName +entryRuleGraphName returns [String current=null]: + { newCompositeNode(grammarAccess.getGraphNameRule()); } + iv_ruleGraphName=ruleGraphName + { $current=$iv_ruleGraphName.current.getText(); } + EOF; + +// Rule GraphName +ruleGraphName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw=GraphName + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + } +; + +// Entry rule entryRuleGlobalNamespace +entryRuleGlobalNamespace returns [EObject current=null]: + { newCompositeNode(grammarAccess.getGlobalNamespaceRule()); } + iv_ruleGlobalNamespace=ruleGlobalNamespace + { $current=$iv_ruleGlobalNamespace.current; } + EOF; + +// Rule GlobalNamespace +ruleGlobalNamespace returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0(), + $current); + } + ) + otherlv_1=GlobalNamespace + { + newLeafNode(otherlv_1, grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); + } + ( + otherlv_2=LeftSquareBracket + { + newLeafNode(otherlv_2, grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + } + lv_parts_3_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getGlobalNamespaceRule()); + } + add( + $current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Comma + { + newLeafNode(otherlv_4, grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + } + lv_parts_5_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getGlobalNamespaceRule()); + } + add( + $current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); + } + )? + ) +; + +// Entry rule entryRuleRelativeNamespace_Impl +entryRuleRelativeNamespace_Impl returns [EObject current=null]: + { newCompositeNode(grammarAccess.getRelativeNamespace_ImplRule()); } + iv_ruleRelativeNamespace_Impl=ruleRelativeNamespace_Impl + { $current=$iv_ruleRelativeNamespace_Impl.current; } + EOF; + +// Rule RelativeNamespace_Impl +ruleRelativeNamespace_Impl returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0(), + $current); + } + ) + otherlv_1=RelativeNamespace + { + newLeafNode(otherlv_1, grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); + } + ( + otherlv_2=LeftSquareBracket + { + newLeafNode(otherlv_2, grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); + } + lv_parts_3_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getRelativeNamespace_ImplRule()); + } + add( + $current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Comma + { + newLeafNode(otherlv_4, grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + } + lv_parts_5_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getRelativeNamespace_ImplRule()); + } + add( + $current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); + } + )? + ) +; + +// Entry rule entryRulePrivateNamespace +entryRulePrivateNamespace returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPrivateNamespaceRule()); } + iv_rulePrivateNamespace=rulePrivateNamespace + { $current=$iv_rulePrivateNamespace.current; } + EOF; + +// Rule PrivateNamespace +rulePrivateNamespace returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0(), + $current); + } + ) + otherlv_1=PrivateNamespace + { + newLeafNode(otherlv_1, grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); + } + ( + otherlv_2=LeftSquareBracket + { + newLeafNode(otherlv_2, grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + } + lv_parts_3_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPrivateNamespaceRule()); + } + add( + $current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Comma + { + newLeafNode(otherlv_4, grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + } + lv_parts_5_0=ruleGraphName + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPrivateNamespaceRule()); + } + add( + $current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); + } + )? + ) +; + +// Entry rule entryRuleParameter +entryRuleParameter returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterRule()); } + iv_ruleParameter=ruleParameter + { $current=$iv_ruleParameter.current; } + EOF; + +// Rule Parameter +ruleParameter returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterAccess().getParameterAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getParameterAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type + { + newLeafNode(otherlv_4, grammarAccess.getParameterAccess().getTypeKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); + } + lv_type_5_0=ruleParameterType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + $current, + "type", + lv_type_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getParameterAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_8=RULE_END + { + newLeafNode(this_END_8, grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); + } + otherlv_9=RightCurlyBracket + { + newLeafNode(otherlv_9, grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); + } + ) +; + +// Entry rule entryRuleParameterType +entryRuleParameterType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterTypeRule()); } + iv_ruleParameterType=ruleParameterType + { $current=$iv_ruleParameterType.current; } + EOF; + +// Rule ParameterType +ruleParameterType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); + } + this_ParameterListType_0=ruleParameterListType + { + $current = $this_ParameterListType_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); + } + this_ParameterStructType_1=ruleParameterStructType + { + $current = $this_ParameterStructType_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); + } + this_ParameterIntegerType_2=ruleParameterIntegerType + { + $current = $this_ParameterIntegerType_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); + } + this_ParameterStringType_3=ruleParameterStringType + { + $current = $this_ParameterStringType_3.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); + } + this_ParameterDoubleType_4=ruleParameterDoubleType + { + $current = $this_ParameterDoubleType_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); + } + this_ParameterBooleanType_5=ruleParameterBooleanType + { + $current = $this_ParameterBooleanType_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); + } + this_ParameterBase64Type_6=ruleParameterBase64Type + { + $current = $this_ParameterBase64Type_6.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); + } + this_ParameterArrayType_7=ruleParameterArrayType + { + $current = $this_ParameterArrayType_7.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleParameterValue +entryRuleParameterValue returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterValueRule()); } + iv_ruleParameterValue=ruleParameterValue + { $current=$iv_ruleParameterValue.current; } + EOF; + +// Rule ParameterValue +ruleParameterValue returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); + } + this_ParameterString_0=ruleParameterString + { + $current = $this_ParameterString_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); + } + this_ParameterBase64_1=ruleParameterBase64 + { + $current = $this_ParameterBase64_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); + } + this_ParameterInteger_2=ruleParameterInteger + { + $current = $this_ParameterInteger_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); + } + this_ParameterDouble_3=ruleParameterDouble + { + $current = $this_ParameterDouble_3.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); + } + this_ParameterBoolean_4=ruleParameterBoolean + { + $current = $this_ParameterBoolean_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); + } + this_ParameterList_5=ruleParameterList + { + $current = $this_ParameterList_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); + } + this_ParameterStruct_6=ruleParameterStruct + { + $current = $this_ParameterStruct_6.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleParameterListType +entryRuleParameterListType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterListTypeRule()); } + iv_ruleParameterListType=ruleParameterListType + { $current=$iv_ruleParameterListType.current; } + EOF; + +// Rule ParameterListType +ruleParameterListType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0(), + $current); + } + ) + otherlv_1=List + { + newLeafNode(otherlv_1, grammarAccess.getParameterListTypeAccess().getListKeyword_1()); + } + otherlv_2=LeftSquareBracket + { + newLeafNode(otherlv_2, grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); + } + lv_sequence_3_0=ruleParameterType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterListTypeRule()); + } + add( + $current, + "sequence", + lv_sequence_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Comma + { + newLeafNode(otherlv_4, grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); + } + lv_sequence_5_0=ruleParameterType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterListTypeRule()); + } + add( + $current, + "sequence", + lv_sequence_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); + } + ) +; + +// Entry rule entryRuleParameterStructType +entryRuleParameterStructType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStructTypeRule()); } + iv_ruleParameterStructType=ruleParameterStructType + { $current=$iv_ruleParameterStructType.current; } + EOF; + +// Rule ParameterStructType +ruleParameterStructType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0(), + $current); + } + ) + otherlv_1=Struct + { + newLeafNode(otherlv_1, grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); + } + otherlv_2=LeftSquareBracket + { + newLeafNode(otherlv_2, grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); + } + lv_parameterstructypetmember_3_0=ruleParameterStructTypeMember + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructTypeRule()); + } + add( + $current, + "parameterstructypetmember", + lv_parameterstructypetmember_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructTypeMember"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Comma + { + newLeafNode(otherlv_4, grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); + } + lv_parameterstructypetmember_5_0=ruleParameterStructTypeMember + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructTypeRule()); + } + add( + $current, + "parameterstructypetmember", + lv_parameterstructypetmember_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructTypeMember"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); + } + ) +; + +// Entry rule entryRuleParameterIntegerType +entryRuleParameterIntegerType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterIntegerTypeRule()); } + iv_ruleParameterIntegerType=ruleParameterIntegerType + { $current=$iv_ruleParameterIntegerType.current; } + EOF; + +// Rule ParameterIntegerType +ruleParameterIntegerType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0(), + $current); + } + ) + otherlv_1=Integer + { + newLeafNode(otherlv_1, grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); + } + ( + otherlv_2=Default + { + newLeafNode(otherlv_2, grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); + } + lv_default_3_0=ruleParameterInteger + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterIntegerTypeRule()); + } + set( + $current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterInteger"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterStringType +entryRuleParameterStringType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStringTypeRule()); } + iv_ruleParameterStringType=ruleParameterStringType + { $current=$iv_ruleParameterStringType.current; } + EOF; + +// Rule ParameterStringType +ruleParameterStringType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0(), + $current); + } + ) + otherlv_1=String + { + newLeafNode(otherlv_1, grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); + } + ( + otherlv_2=Default + { + newLeafNode(otherlv_2, grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); + } + lv_default_3_0=ruleParameterString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStringTypeRule()); + } + set( + $current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterString"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterDoubleType +entryRuleParameterDoubleType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterDoubleTypeRule()); } + iv_ruleParameterDoubleType=ruleParameterDoubleType + { $current=$iv_ruleParameterDoubleType.current; } + EOF; + +// Rule ParameterDoubleType +ruleParameterDoubleType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0(), + $current); + } + ) + otherlv_1=Double + { + newLeafNode(otherlv_1, grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); + } + ( + otherlv_2=Default + { + newLeafNode(otherlv_2, grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); + } + lv_default_3_0=ruleParameterDouble + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterDoubleTypeRule()); + } + set( + $current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterDouble"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterBooleanType +entryRuleParameterBooleanType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterBooleanTypeRule()); } + iv_ruleParameterBooleanType=ruleParameterBooleanType + { $current=$iv_ruleParameterBooleanType.current; } + EOF; + +// Rule ParameterBooleanType +ruleParameterBooleanType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0(), + $current); + } + ) + otherlv_1=Boolean + { + newLeafNode(otherlv_1, grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); + } + ( + otherlv_2=Default + { + newLeafNode(otherlv_2, grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); + } + lv_default_3_0=ruleParameterBoolean + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterBooleanTypeRule()); + } + set( + $current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterBoolean"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterBase64Type +entryRuleParameterBase64Type returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterBase64TypeRule()); } + iv_ruleParameterBase64Type=ruleParameterBase64Type + { $current=$iv_ruleParameterBase64Type.current; } + EOF; + +// Rule ParameterBase64Type +ruleParameterBase64Type returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0(), + $current); + } + ) + otherlv_1=Base64 + { + newLeafNode(otherlv_1, grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); + } + ( + otherlv_2=Default + { + newLeafNode(otherlv_2, grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); + } + lv_default_3_0=ruleParameterBase64 + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterBase64TypeRule()); + } + set( + $current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterBase64"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterArrayType +entryRuleParameterArrayType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterArrayTypeRule()); } + iv_ruleParameterArrayType=ruleParameterArrayType + { $current=$iv_ruleParameterArrayType.current; } + EOF; + +// Rule ParameterArrayType +ruleParameterArrayType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0=Array + { + newLeafNode(otherlv_0, grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); + } + this_BEGIN_1=RULE_BEGIN + { + newLeafNode(this_BEGIN_1, grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); + } + otherlv_2=Type + { + newLeafNode(otherlv_2, grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); + } + lv_type_3_0=ruleParameterType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterArrayTypeRule()); + } + set( + $current, + "type", + lv_type_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=Default + { + newLeafNode(otherlv_4, grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); + } + lv_default_5_0=ruleParameterList + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterArrayTypeRule()); + } + set( + $current, + "default", + lv_default_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterList"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + this_END_6=RULE_END + { + newLeafNode(this_END_6, grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); + } + ) +; + +// Entry rule entryRuleParameterList +entryRuleParameterList returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterListRule()); } + iv_ruleParameterList=ruleParameterList + { $current=$iv_ruleParameterList.current; } + EOF; + +// Rule ParameterList +ruleParameterList returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterListAccess().getParameterSequenceAction_0(), + $current); + } + ) + otherlv_1=LeftSquareBracket + { + newLeafNode(otherlv_1, grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); + } + lv_value_2_0=ruleParameterValue + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterListRule()); + } + add( + $current, + "value", + lv_value_2_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=Comma + { + newLeafNode(otherlv_3, grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); + } + lv_value_4_0=ruleParameterValue + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterListRule()); + } + add( + $current, + "value", + lv_value_4_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_5=RightSquareBracket + { + newLeafNode(otherlv_5, grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); + } + ) +; + +// Entry rule entryRuleParameterAny +entryRuleParameterAny returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterAnyRule()); } + iv_ruleParameterAny=ruleParameterAny + { $current=$iv_ruleParameterAny.current; } + EOF; + +// Rule ParameterAny +ruleParameterAny returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterAnyAccess().getParameterAnyAction_0(), + $current); + } + ) + otherlv_1=ParameterAny + { + newLeafNode(otherlv_1, grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); + } + ( + otherlv_2=Value + { + newLeafNode(otherlv_2, grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); + } + lv_value_3_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterAnyRule()); + } + set( + $current, + "value", + lv_value_3_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleParameterString +entryRuleParameterString returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStringRule()); } + iv_ruleParameterString=ruleParameterString + { $current=$iv_ruleParameterString.current; } + EOF; + +// Rule ParameterString +ruleParameterString returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); + } + lv_value_0_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStringRule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterBase64 +entryRuleParameterBase64 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterBase64Rule()); } + iv_ruleParameterBase64=ruleParameterBase64 + { $current=$iv_ruleParameterBase64.current; } + EOF; + +// Rule ParameterBase64 +ruleParameterBase64 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); + } + lv_value_0_0=ruleBase64Binary + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterBase64Rule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Base64Binary"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterInteger +entryRuleParameterInteger returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterIntegerRule()); } + iv_ruleParameterInteger=ruleParameterInteger + { $current=$iv_ruleParameterInteger.current; } + EOF; + +// Rule ParameterInteger +ruleParameterInteger returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); + } + lv_value_0_0=ruleInteger0 + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterIntegerRule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Integer0"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterDouble +entryRuleParameterDouble returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterDoubleRule()); } + iv_ruleParameterDouble=ruleParameterDouble + { $current=$iv_ruleParameterDouble.current; } + EOF; + +// Rule ParameterDouble +ruleParameterDouble returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); + } + lv_value_0_0=ruleDouble0 + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterDoubleRule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Double0"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterBoolean +entryRuleParameterBoolean returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterBooleanRule()); } + iv_ruleParameterBoolean=ruleParameterBoolean + { $current=$iv_ruleParameterBoolean.current; } + EOF; + +// Rule ParameterBoolean +ruleParameterBoolean returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); + } + lv_value_0_0=ruleboolean0 + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterBooleanRule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.boolean0"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterStruct +entryRuleParameterStruct returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStructRule()); } + iv_ruleParameterStruct=ruleParameterStruct + { $current=$iv_ruleParameterStruct.current; } + EOF; + +// Rule ParameterStruct +ruleParameterStruct returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getParameterStructAccess().getParameterStructAction_0(), + $current); + } + ) + ( + otherlv_1=LeftSquareBracket + { + newLeafNode(otherlv_1, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); + } + lv_value_2_0=ruleParameterStructMember + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructRule()); + } + add( + $current, + "value", + lv_value_2_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructMember"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=Comma + { + newLeafNode(otherlv_3, grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); + } + otherlv_4=LeftSquareBracket + { + newLeafNode(otherlv_4, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); + } + lv_value_5_0=ruleParameterStructMember + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructRule()); + } + add( + $current, + "value", + lv_value_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructMember"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6=RightSquareBracket + { + newLeafNode(otherlv_6, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); + } + )* + otherlv_7=RightSquareBracket + { + newLeafNode(otherlv_7, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); + } + )? + ) +; + +// Entry rule entryRuleParameterDate +entryRuleParameterDate returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterDateRule()); } + iv_ruleParameterDate=ruleParameterDate + { $current=$iv_ruleParameterDate.current; } + EOF; + +// Rule ParameterDate +ruleParameterDate returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); + } + lv_value_0_0=ruleDateTime0 + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterDateRule()); + } + set( + $current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.DateTime0"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleParameterStructMember +entryRuleParameterStructMember returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStructMemberRule()); } + iv_ruleParameterStructMember=ruleParameterStructMember + { $current=$iv_ruleParameterStructMember.current; } + EOF; + +// Rule ParameterStructMember +ruleParameterStructMember returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0=ParameterStructMember + { + newLeafNode(otherlv_0, grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructMemberRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); + } + lv_value_4_0=ruleParameterValue + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructMemberRule()); + } + set( + $current, + "value", + lv_value_4_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_5=RULE_END + { + newLeafNode(this_END_5, grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); + } + ) +; + +// Entry rule entryRuleParameterStructTypeMember +entryRuleParameterStructTypeMember returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterStructTypeMemberRule()); } + iv_ruleParameterStructTypeMember=ruleParameterStructTypeMember + { $current=$iv_ruleParameterStructTypeMember.current; } + EOF; + +// Rule ParameterStructTypeMember +ruleParameterStructTypeMember returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); + } + lv_name_0_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructTypeMemberRule()); + } + set( + $current, + "name", + lv_name_0_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); + } + lv_type_1_0=ruleParameterType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterStructTypeMemberRule()); + } + set( + $current, + "type", + lv_type_1_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleBase64Binary +entryRuleBase64Binary returns [String current=null]: + { newCompositeNode(grammarAccess.getBase64BinaryRule()); } + iv_ruleBase64Binary=ruleBase64Binary + { $current=$iv_ruleBase64Binary.current.getText(); } + EOF; + +// Rule Base64Binary +ruleBase64Binary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_BINARY_0=RULE_BINARY + { + $current.merge(this_BINARY_0); + } + { + newLeafNode(this_BINARY_0, grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); + } +; + +// Entry rule entryRuleboolean0 +entryRuleboolean0 returns [String current=null]: + { newCompositeNode(grammarAccess.getBoolean0Rule()); } + iv_ruleboolean0=ruleboolean0 + { $current=$iv_ruleboolean0.current.getText(); } + EOF; + +// Rule boolean0 +ruleboolean0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_BOOLEAN_0=RULE_BOOLEAN + { + $current.merge(this_BOOLEAN_0); + } + { + newLeafNode(this_BOOLEAN_0, grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); + } +; + +// Entry rule entryRuleDouble0 +entryRuleDouble0 returns [String current=null]: + { newCompositeNode(grammarAccess.getDouble0Rule()); } + iv_ruleDouble0=ruleDouble0 + { $current=$iv_ruleDouble0.current.getText(); } + EOF; + +// Rule Double0 +ruleDouble0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_DOUBLE_0=RULE_DOUBLE + { + $current.merge(this_DOUBLE_0); + } + { + newLeafNode(this_DOUBLE_0, grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); + } +; + +// Entry rule entryRuleInteger0 +entryRuleInteger0 returns [String current=null]: + { newCompositeNode(grammarAccess.getInteger0Rule()); } + iv_ruleInteger0=ruleInteger0 + { $current=$iv_ruleInteger0.current.getText(); } + EOF; + +// Rule Integer0 +ruleInteger0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_DECINT_0=RULE_DECINT + { + $current.merge(this_DECINT_0); + } + { + newLeafNode(this_DECINT_0, grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); + } +; + +// Entry rule entryRuleDateTime0 +entryRuleDateTime0 returns [String current=null]: + { newCompositeNode(grammarAccess.getDateTime0Rule()); } + iv_ruleDateTime0=ruleDateTime0 + { $current=$iv_ruleDateTime0.current.getText(); } + EOF; + +// Rule DateTime0 +ruleDateTime0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_DATE_TIME_0=RULE_DATE_TIME + { + $current.merge(this_DATE_TIME_0); + } + { + newLeafNode(this_DATE_TIME_0, grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); + } +; + +// Entry rule entryRuleMessagePart +entryRuleMessagePart returns [EObject current=null]: + { newCompositeNode(grammarAccess.getMessagePartRule()); } + iv_ruleMessagePart=ruleMessagePart + { $current=$iv_ruleMessagePart.current; } + EOF; + +// Rule MessagePart +ruleMessagePart returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); + } + lv_Type_0_0=ruleAbstractType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + $current, + "Type", + lv_Type_0_0, + "de.fraunhofer.ipa.ros.Ros.AbstractType"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ( + { + newCompositeNode(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); + } + lv_Data_1_1=ruleKEYWORD + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + $current, + "Data", + lv_Data_1_1, + "de.fraunhofer.ipa.ros.Ros.KEYWORD"); + afterParserOrEnumRuleCall(); + } + | + lv_Data_1_2=RULE_MESSAGE_ASIGMENT + { + newLeafNode(lv_Data_1_2, grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getMessagePartRule()); + } + setWithLastConsumed( + $current, + "Data", + lv_Data_1_2, + "de.fraunhofer.ipa.ros.Ros.MESSAGE_ASIGMENT"); + } + | + { + newCompositeNode(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); + } + lv_Data_1_3=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + $current, + "Data", + lv_Data_1_3, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) +; + +// Entry rule entryRuleAbstractType +entryRuleAbstractType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getAbstractTypeRule()); } + iv_ruleAbstractType=ruleAbstractType + { $current=$iv_ruleAbstractType.current; } + EOF; + +// Rule AbstractType +ruleAbstractType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); + } + this_bool_0=rulebool + { + $current = $this_bool_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); + } + this_int8_1=ruleint8 + { + $current = $this_int8_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); + } + this_uint8_2=ruleuint8 + { + $current = $this_uint8_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); + } + this_int16_3=ruleint16 + { + $current = $this_int16_3.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); + } + this_uint16_4=ruleuint16 + { + $current = $this_uint16_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); + } + this_int32_5=ruleint32 + { + $current = $this_int32_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); + } + this_uint32_6=ruleuint32 + { + $current = $this_uint32_6.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); + } + this_int64_7=ruleint64 + { + $current = $this_int64_7.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); + } + this_uint64_8=ruleuint64 + { + $current = $this_uint64_8.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); + } + this_float32_9=rulefloat32 + { + $current = $this_float32_9.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); + } + this_float64_10=rulefloat64 + { + $current = $this_float64_10.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); + } + this_string0_11=rulestring0 + { + $current = $this_string0_11.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); + } + this_byte_12=rulebyte + { + $current = $this_byte_12.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); + } + this_time_13=ruletime + { + $current = $this_time_13.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); + } + this_duration_14=ruleduration + { + $current = $this_duration_14.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); + } + this_Header_15=ruleHeader + { + $current = $this_Header_15.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); + } + this_boolArray_16=ruleboolArray + { + $current = $this_boolArray_16.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); + } + this_int8Array_17=ruleint8Array + { + $current = $this_int8Array_17.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); + } + this_uint8Array_18=ruleuint8Array + { + $current = $this_uint8Array_18.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); + } + this_int16Array_19=ruleint16Array + { + $current = $this_int16Array_19.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); + } + this_uint16Array_20=ruleuint16Array + { + $current = $this_uint16Array_20.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); + } + this_int32Array_21=ruleint32Array + { + $current = $this_int32Array_21.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); + } + this_uint32Array_22=ruleuint32Array + { + $current = $this_uint32Array_22.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); + } + this_int64Array_23=ruleint64Array + { + $current = $this_int64Array_23.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); + } + this_uint64Array_24=ruleuint64Array + { + $current = $this_uint64Array_24.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); + } + this_float32Array_25=rulefloat32Array + { + $current = $this_float32Array_25.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); + } + this_float64Array_26=rulefloat64Array + { + $current = $this_float64Array_26.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); + } + this_string0Array_27=rulestring0Array + { + $current = $this_string0Array_27.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); + } + this_byteArray_28=rulebyteArray + { + $current = $this_byteArray_28.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); + } + this_TopicSpecRef_29=ruleTopicSpecRef + { + $current = $this_TopicSpecRef_29.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); + } + this_ArrayTopicSpecRef_30=ruleArrayTopicSpecRef + { + $current = $this_ArrayTopicSpecRef_30.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRulebool +entryRulebool returns [EObject current=null]: + { newCompositeNode(grammarAccess.getBoolRule()); } + iv_rulebool=rulebool + { $current=$iv_rulebool.current; } + EOF; + +// Rule bool +rulebool returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getBoolAccess().getBoolAction_0(), + $current); + } + ) + otherlv_1=Bool + { + newLeafNode(otherlv_1, grammarAccess.getBoolAccess().getBoolKeyword_1()); + } + ) +; + +// Entry rule entryRuleint8 +entryRuleint8 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt8Rule()); } + iv_ruleint8=ruleint8 + { $current=$iv_ruleint8.current; } + EOF; + +// Rule int8 +ruleint8 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt8Access().getInt8Action_0(), + $current); + } + ) + otherlv_1=Int8 + { + newLeafNode(otherlv_1, grammarAccess.getInt8Access().getInt8Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint8 +entryRuleuint8 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint8Rule()); } + iv_ruleuint8=ruleuint8 + { $current=$iv_ruleuint8.current; } + EOF; + +// Rule uint8 +ruleuint8 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint8Access().getUint8Action_0(), + $current); + } + ) + otherlv_1=Uint8 + { + newLeafNode(otherlv_1, grammarAccess.getUint8Access().getUint8Keyword_1()); + } + ) +; + +// Entry rule entryRuleint16 +entryRuleint16 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt16Rule()); } + iv_ruleint16=ruleint16 + { $current=$iv_ruleint16.current; } + EOF; + +// Rule int16 +ruleint16 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt16Access().getInt16Action_0(), + $current); + } + ) + otherlv_1=Int16 + { + newLeafNode(otherlv_1, grammarAccess.getInt16Access().getInt16Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint16 +entryRuleuint16 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint16Rule()); } + iv_ruleuint16=ruleuint16 + { $current=$iv_ruleuint16.current; } + EOF; + +// Rule uint16 +ruleuint16 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint16Access().getUint16Action_0(), + $current); + } + ) + otherlv_1=Uint16 + { + newLeafNode(otherlv_1, grammarAccess.getUint16Access().getUint16Keyword_1()); + } + ) +; + +// Entry rule entryRuleint32 +entryRuleint32 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt32Rule()); } + iv_ruleint32=ruleint32 + { $current=$iv_ruleint32.current; } + EOF; + +// Rule int32 +ruleint32 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt32Access().getInt32Action_0(), + $current); + } + ) + otherlv_1=Int32 + { + newLeafNode(otherlv_1, grammarAccess.getInt32Access().getInt32Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint32 +entryRuleuint32 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint32Rule()); } + iv_ruleuint32=ruleuint32 + { $current=$iv_ruleuint32.current; } + EOF; + +// Rule uint32 +ruleuint32 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint32Access().getUint32Action_0(), + $current); + } + ) + otherlv_1=Uint32 + { + newLeafNode(otherlv_1, grammarAccess.getUint32Access().getUint32Keyword_1()); + } + ) +; + +// Entry rule entryRuleint64 +entryRuleint64 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt64Rule()); } + iv_ruleint64=ruleint64 + { $current=$iv_ruleint64.current; } + EOF; + +// Rule int64 +ruleint64 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt64Access().getInt64Action_0(), + $current); + } + ) + otherlv_1=Int64 + { + newLeafNode(otherlv_1, grammarAccess.getInt64Access().getInt64Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint64 +entryRuleuint64 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint64Rule()); } + iv_ruleuint64=ruleuint64 + { $current=$iv_ruleuint64.current; } + EOF; + +// Rule uint64 +ruleuint64 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint64Access().getUint64Action_0(), + $current); + } + ) + otherlv_1=Uint64 + { + newLeafNode(otherlv_1, grammarAccess.getUint64Access().getUint64Keyword_1()); + } + ) +; + +// Entry rule entryRulefloat32 +entryRulefloat32 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFloat32Rule()); } + iv_rulefloat32=rulefloat32 + { $current=$iv_rulefloat32.current; } + EOF; + +// Rule float32 +rulefloat32 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getFloat32Access().getFloat32Action_0(), + $current); + } + ) + otherlv_1=Float32 + { + newLeafNode(otherlv_1, grammarAccess.getFloat32Access().getFloat32Keyword_1()); + } + ) +; + +// Entry rule entryRulefloat64 +entryRulefloat64 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFloat64Rule()); } + iv_rulefloat64=rulefloat64 + { $current=$iv_rulefloat64.current; } + EOF; + +// Rule float64 +rulefloat64 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getFloat64Access().getFloat64Action_0(), + $current); + } + ) + otherlv_1=Float64 + { + newLeafNode(otherlv_1, grammarAccess.getFloat64Access().getFloat64Keyword_1()); + } + ) +; + +// Entry rule entryRulestring0 +entryRulestring0 returns [EObject current=null]: + { newCompositeNode(grammarAccess.getString0Rule()); } + iv_rulestring0=rulestring0 + { $current=$iv_rulestring0.current; } + EOF; + +// Rule string0 +rulestring0 returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getString0Access().getStringAction_0(), + $current); + } + ) + otherlv_1=String_1 + { + newLeafNode(otherlv_1, grammarAccess.getString0Access().getStringKeyword_1()); + } + ) +; + +// Entry rule entryRulebyte +entryRulebyte returns [EObject current=null]: + { newCompositeNode(grammarAccess.getByteRule()); } + iv_rulebyte=rulebyte + { $current=$iv_rulebyte.current; } + EOF; + +// Rule byte +rulebyte returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getByteAccess().getByteAction_0(), + $current); + } + ) + otherlv_1=Byte + { + newLeafNode(otherlv_1, grammarAccess.getByteAccess().getByteKeyword_1()); + } + ) +; + +// Entry rule entryRuletime +entryRuletime returns [EObject current=null]: + { newCompositeNode(grammarAccess.getTimeRule()); } + iv_ruletime=ruletime + { $current=$iv_ruletime.current; } + EOF; + +// Rule time +ruletime returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getTimeAccess().getTimeAction_0(), + $current); + } + ) + otherlv_1=Time + { + newLeafNode(otherlv_1, grammarAccess.getTimeAccess().getTimeKeyword_1()); + } + ) +; + +// Entry rule entryRuleduration +entryRuleduration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getDurationRule()); } + iv_ruleduration=ruleduration + { $current=$iv_ruleduration.current; } + EOF; + +// Rule duration +ruleduration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getDurationAccess().getDurationAction_0(), + $current); + } + ) + otherlv_1=Duration + { + newLeafNode(otherlv_1, grammarAccess.getDurationAccess().getDurationKeyword_1()); + } + ) +; + +// Entry rule entryRuleboolArray +entryRuleboolArray returns [EObject current=null]: + { newCompositeNode(grammarAccess.getBoolArrayRule()); } + iv_ruleboolArray=ruleboolArray + { $current=$iv_ruleboolArray.current; } + EOF; + +// Rule boolArray +ruleboolArray returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getBoolArrayAccess().getBoolArrayAction_0(), + $current); + } + ) + otherlv_1=Bool_1 + { + newLeafNode(otherlv_1, grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); + } + ) +; + +// Entry rule entryRuleint8Array +entryRuleint8Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt8ArrayRule()); } + iv_ruleint8Array=ruleint8Array + { $current=$iv_ruleint8Array.current; } + EOF; + +// Rule int8Array +ruleint8Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0(), + $current); + } + ) + otherlv_1=Int8_1 + { + newLeafNode(otherlv_1, grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint8Array +entryRuleuint8Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint8ArrayRule()); } + iv_ruleuint8Array=ruleuint8Array + { $current=$iv_ruleuint8Array.current; } + EOF; + +// Rule uint8Array +ruleuint8Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0(), + $current); + } + ) + otherlv_1=Uint8_1 + { + newLeafNode(otherlv_1, grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); + } + ) +; + +// Entry rule entryRuleint16Array +entryRuleint16Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt16ArrayRule()); } + iv_ruleint16Array=ruleint16Array + { $current=$iv_ruleint16Array.current; } + EOF; + +// Rule int16Array +ruleint16Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0(), + $current); + } + ) + otherlv_1=Int16_1 + { + newLeafNode(otherlv_1, grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint16Array +entryRuleuint16Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint16ArrayRule()); } + iv_ruleuint16Array=ruleuint16Array + { $current=$iv_ruleuint16Array.current; } + EOF; + +// Rule uint16Array +ruleuint16Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0(), + $current); + } + ) + otherlv_1=Uint16_1 + { + newLeafNode(otherlv_1, grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); + } + ) +; + +// Entry rule entryRuleint32Array +entryRuleint32Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt32ArrayRule()); } + iv_ruleint32Array=ruleint32Array + { $current=$iv_ruleint32Array.current; } + EOF; + +// Rule int32Array +ruleint32Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0(), + $current); + } + ) + otherlv_1=Int32_1 + { + newLeafNode(otherlv_1, grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint32Array +entryRuleuint32Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint32ArrayRule()); } + iv_ruleuint32Array=ruleuint32Array + { $current=$iv_ruleuint32Array.current; } + EOF; + +// Rule uint32Array +ruleuint32Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0(), + $current); + } + ) + otherlv_1=Uint32_1 + { + newLeafNode(otherlv_1, grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); + } + ) +; + +// Entry rule entryRuleint64Array +entryRuleint64Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInt64ArrayRule()); } + iv_ruleint64Array=ruleint64Array + { $current=$iv_ruleint64Array.current; } + EOF; + +// Rule int64Array +ruleint64Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0(), + $current); + } + ) + otherlv_1=Int64_1 + { + newLeafNode(otherlv_1, grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); + } + ) +; + +// Entry rule entryRuleuint64Array +entryRuleuint64Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUint64ArrayRule()); } + iv_ruleuint64Array=ruleuint64Array + { $current=$iv_ruleuint64Array.current; } + EOF; + +// Rule uint64Array +ruleuint64Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0(), + $current); + } + ) + otherlv_1=Uint64_1 + { + newLeafNode(otherlv_1, grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); + } + ) +; + +// Entry rule entryRulefloat32Array +entryRulefloat32Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFloat32ArrayRule()); } + iv_rulefloat32Array=rulefloat32Array + { $current=$iv_rulefloat32Array.current; } + EOF; + +// Rule float32Array +rulefloat32Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0(), + $current); + } + ) + otherlv_1=Float32_1 + { + newLeafNode(otherlv_1, grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); + } + ) +; + +// Entry rule entryRulefloat64Array +entryRulefloat64Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFloat64ArrayRule()); } + iv_rulefloat64Array=rulefloat64Array + { $current=$iv_rulefloat64Array.current; } + EOF; + +// Rule float64Array +rulefloat64Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0(), + $current); + } + ) + otherlv_1=Float64_1 + { + newLeafNode(otherlv_1, grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); + } + ) +; + +// Entry rule entryRulestring0Array +entryRulestring0Array returns [EObject current=null]: + { newCompositeNode(grammarAccess.getString0ArrayRule()); } + iv_rulestring0Array=rulestring0Array + { $current=$iv_rulestring0Array.current; } + EOF; + +// Rule string0Array +rulestring0Array returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getString0ArrayAccess().getStringArrayAction_0(), + $current); + } + ) + otherlv_1=String_2 + { + newLeafNode(otherlv_1, grammarAccess.getString0ArrayAccess().getStringKeyword_1()); + } + ) +; + +// Entry rule entryRulebyteArray +entryRulebyteArray returns [EObject current=null]: + { newCompositeNode(grammarAccess.getByteArrayRule()); } + iv_rulebyteArray=rulebyteArray + { $current=$iv_rulebyteArray.current; } + EOF; + +// Rule byteArray +rulebyteArray returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getByteArrayAccess().getByteArrayAction_0(), + $current); + } + ) + otherlv_1=Byte_1 + { + newLeafNode(otherlv_1, grammarAccess.getByteArrayAccess().getByteKeyword_1()); + } + ) +; + +// Entry rule entryRuleHeader +entryRuleHeader returns [EObject current=null]: + { newCompositeNode(grammarAccess.getHeaderRule()); } + iv_ruleHeader=ruleHeader + { $current=$iv_ruleHeader.current; } + EOF; + +// Rule Header +ruleHeader returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getHeaderAccess().getHeaderAction_0(), + $current); + } + ) + otherlv_1=Header + { + newLeafNode(otherlv_1, grammarAccess.getHeaderAccess().getHeaderKeyword_1()); + } + ) +; + +// Entry rule entryRuleTopicSpecRef +entryRuleTopicSpecRef returns [EObject current=null]: + { newCompositeNode(grammarAccess.getTopicSpecRefRule()); } + iv_ruleTopicSpecRef=ruleTopicSpecRef + { $current=$iv_ruleTopicSpecRef.current; } + EOF; + +// Rule TopicSpecRef +ruleTopicSpecRef returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getTopicSpecRefRule()); + } + } + { + newCompositeNode(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleArrayTopicSpecRef +entryRuleArrayTopicSpecRef returns [EObject current=null]: + { newCompositeNode(grammarAccess.getArrayTopicSpecRefRule()); } + iv_ruleArrayTopicSpecRef=ruleArrayTopicSpecRef + { $current=$iv_ruleArrayTopicSpecRef.current; } + EOF; + +// Rule ArrayTopicSpecRef +ruleArrayTopicSpecRef returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getArrayTopicSpecRefRule()); + } + } + { + newCompositeNode(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_1=LeftSquareBracketRightSquareBracket + { + newLeafNode(otherlv_1, grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); + } + ) +; + +// Entry rule entryRuleKEYWORD +entryRuleKEYWORD returns [String current=null]: + { newCompositeNode(grammarAccess.getKEYWORDRule()); } + iv_ruleKEYWORD=ruleKEYWORD + { $current=$iv_ruleKEYWORD.current.getText(); } + EOF; + +// Rule KEYWORD +ruleKEYWORD returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw=Goal + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); + } + | + kw=Message + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); + } + | + kw=Result + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getResultKeyword_2()); + } + | + kw=Feedback + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); + } + | + kw=Name + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getNameKeyword_4()); + } + | + kw=Value + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getValueKeyword_5()); + } + | + kw=Service + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); + } + | + kw=Type + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); + } + | + kw=Action + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getActionKeyword_8()); + } + | + kw=Duration + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); + } + | + kw=Time + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); + } + ) +; diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.java new file mode 100644 index 000000000..c803c449e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.java @@ -0,0 +1,13963 @@ +package de.fraunhofer.ipa.ros1.parser.antlr.internal; + +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; +import 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 AbstractInternalAntlrParser { + public static final String[] tokenNames = new String[] { + "", "", "", "", "ParameterStructMember", "ExternalDependency", "RelativeNamespace", "PrivateNamespace", "GlobalNamespace", "Serviceclient", "Serviceserver", "Actionclient", "Actionserver", "Dependencies", "AmentPackage", "ParameterAny", "FromGitRepo", "Subscribers", "Parameters", "Publishers", "Artifacts", "GraphName", "Feedback_1", "Float32_1", "Float64_1", "Response", "Duration", "Feedback", "Message_1", "Request", "String_2", "Uint16_1", "Uint32_1", "Uint64_1", "Boolean", "Integer", "Action_1", "Default", "Float32", "Float64", "Int16_1", "Int32_1", "Int64_1", "Message", "Result_1", "Service", "Uint8_1", "Array", "Base64", "Double", "Header", "String", "Struct", "Action", "Bool_1", "Byte_1", "Int8_1", "Result", "Specs", "String_1", "Uint16", "Uint32", "Uint64", "Goal_1", "Int16", "Int32", "Int64", "Node_1", "Type_1", "Uint8", "Value", "Date", "List", "Bool", "Byte", "Goal", "Int8", "Msg", "Name", "Node", "Srv", "Time", "Type", "Any", "Ns", "LeftSquareBracketRightSquareBracket", "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_DIGIT", "RULE_BINARY", "RULE_BOOLEAN", "RULE_DECINT", "RULE_DOUBLE", "RULE_DAY", "RULE_MONTH", "RULE_YEAR", "RULE_HOUR", "RULE_MIN_SEC", "RULE_DATE_TIME", "RULE_INT", "RULE_MESSAGE_ASIGMENT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER" + }; + public static final int Float32_1=23; + public static final int Node=79; + public static final int RULE_DATE_TIME=108; + public static final int Uint64_1=33; + public static final int String=51; + public static final int Int16=64; + public static final int Float32=38; + public static final int Goal=75; + public static final int Bool=73; + public static final int Uint16=60; + public static final int Boolean=34; + public static final int ExternalDependency=5; + public static final int Uint8=69; + public static final int Parameters=18; + public static final int RULE_ID=94; + public static final int AmentPackage=14; + public static final int Actionclient=11; + public static final int RULE_DIGIT=98; + public static final int GlobalNamespace=8; + public static final int Artifacts=20; + public static final int Node_1=67; + public static final int Int16_1=40; + public static final int Header=50; + public static final int RULE_INT=109; + public static final int Byte=74; + public static final int RULE_ML_COMMENT=111; + public static final int LeftSquareBracket=88; + public static final int Specs=58; + public static final int Base64=48; + public static final int Message_1=28; + public static final int Comma=86; + public static final int RULE_MESSAGE_ASIGMENT=110; + public static final int Goal_1=63; + public static final int LeftSquareBracketRightSquareBracket=85; + public static final int Int32=65; + public static final int Publishers=19; + public static final int Serviceserver=10; + public static final int RightCurlyBracket=90; + public static final int RULE_DECINT=101; + public static final int Uint32=61; + public static final int FromGitRepo=16; + public static final int Msg=77; + public static final int RULE_HOUR=106; + public static final int Int8=76; + public static final int Default=37; + public static final int Actionserver=12; + public static final int Int8_1=56; + public static final int Uint16_1=31; + public static final int Type=82; + public static final int Float64=39; + public static final int Int32_1=41; + public static final int Result_1=44; + public static final int RULE_BINARY=99; + public static final int String_1=59; + public static final int Subscribers=17; + public static final int String_2=30; + public static final int RULE_BEGIN=91; + public static final int RULE_DAY=103; + public static final int RULE_BOOLEAN=100; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=105; + public static final int Feedback_1=22; + public static final int Result=57; + public static final int Name=78; + public static final int RULE_MIN_SEC=107; + public static final int ParameterAny=15; + public static final int List=72; + public static final int Dependencies=13; + public static final int RightSquareBracket=89; + public static final int PrivateNamespace=7; + public static final int GraphName=21; + public static final int Byte_1=55; + public static final int Float64_1=24; + public static final int Duration=26; + public static final int Uint32_1=32; + public static final int Action_1=36; + public static final int Double=49; + public static final int Type_1=68; + public static final int Value=70; + public static final int Uint64=62; + public static final int Action=53; + public static final int RULE_END=92; + public static final int Message=43; + public static final int Time=81; + public static final int RULE_STRING=96; + public static final int Bool_1=54; + public static final int Any=83; + public static final int Struct=52; + public static final int RULE_SL_COMMENT=93; + public static final int Uint8_1=46; + public static final int RULE_DOUBLE=102; + public static final int Feedback=27; + public static final int ParameterStructMember=4; + public static final int Srv=80; + public static final int RULE_ROS_CONVENTION_A=95; + public static final int RULE_ROS_CONVENTION_PARAM=97; + public static final int Colon=87; + public static final int EOF=-1; + public static final int Ns=84; + public static final int RULE_WS=112; + public static final int Request=29; + public static final int Int64_1=42; + public static final int Service=45; + public static final int RULE_ANY_OTHER=113; + public static final int Date=71; + public static final int Response=25; + public static final int Integer=35; + public static final int Array=47; + public static final int Serviceclient=9; + public static final int Int64=66; + public static final int RULE_MONTH=104; + + // 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 "Package"; + } + + @Override + protected Ros1GrammarAccess getGrammarAccess() { + return grammarAccess; + } + + + + + // $ANTLR start "entryRulePackage" + // InternalRos1Parser.g:57:1: entryRulePackage returns [EObject current=null] : iv_rulePackage= rulePackage EOF ; + public final EObject entryRulePackage() throws RecognitionException { + EObject current = null; + + EObject iv_rulePackage = null; + + + try { + // InternalRos1Parser.g:57:48: (iv_rulePackage= rulePackage EOF ) + // InternalRos1Parser.g:58:2: iv_rulePackage= rulePackage EOF + { + newCompositeNode(grammarAccess.getPackageRule()); + pushFollow(FOLLOW_1); + iv_rulePackage=rulePackage(); + + state._fsp--; + + current =iv_rulePackage; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePackage" + + + // $ANTLR start "rulePackage" + // InternalRos1Parser.g:64:1: rulePackage returns [EObject current=null] : this_CatkinPackage_0= ruleCatkinPackage ; + public final EObject rulePackage() throws RecognitionException { + EObject current = null; + + EObject this_CatkinPackage_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:70:2: (this_CatkinPackage_0= ruleCatkinPackage ) + // InternalRos1Parser.g:71:2: this_CatkinPackage_0= ruleCatkinPackage + { + + newCompositeNode(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall()); + + pushFollow(FOLLOW_2); + this_CatkinPackage_0=ruleCatkinPackage(); + + state._fsp--; + + + current = this_CatkinPackage_0; + afterParserOrEnumRuleCall(); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePackage" + + + // $ANTLR start "entryRuleCatkinPackage" + // InternalRos1Parser.g:82: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:82:54: (iv_ruleCatkinPackage= ruleCatkinPackage EOF ) + // InternalRos1Parser.g:83: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:89: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:95: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:96: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:96: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:97: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:97:3: () + // InternalRos1Parser.g:98:4: + { + + current = forceCreateModelElement( + grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0(), + current); + + + } + + // InternalRos1Parser.g:104:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRos1Parser.g:105:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRos1Parser.g:105:4: (lv_name_1_0= ruleRosNames ) + // InternalRos1Parser.g:106: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.ros.Ros.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:131: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:132: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:136:4: ( (lv_fromGitRepo_5_0= ruleEString ) ) + // InternalRos1Parser.g:137:5: (lv_fromGitRepo_5_0= ruleEString ) + { + // InternalRos1Parser.g:137:5: (lv_fromGitRepo_5_0= ruleEString ) + // InternalRos1Parser.g:138: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.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos1Parser.g:156: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:157: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:165: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:166:5: (lv_artifact_8_0= ruleArtifact ) + { + // InternalRos1Parser.g:166:5: (lv_artifact_8_0= ruleArtifact ) + // InternalRos1Parser.g:167: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.ros.Ros.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:189: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:190: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:198:4: ( (lv_dependency_12_0= ruleDependency ) ) + // InternalRos1Parser.g:199:5: (lv_dependency_12_0= ruleDependency ) + { + // InternalRos1Parser.g:199:5: (lv_dependency_12_0= ruleDependency ) + // InternalRos1Parser.g:200: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.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:217: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:218: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:222:5: ( (lv_dependency_14_0= ruleDependency ) ) + // InternalRos1Parser.g:223:6: (lv_dependency_14_0= ruleDependency ) + { + // InternalRos1Parser.g:223:6: (lv_dependency_14_0= ruleDependency ) + // InternalRos1Parser.g:224: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.ros.Ros.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 "entryRuleEString" + // InternalRos1Parser.g:255: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:255:47: (iv_ruleEString= ruleEString EOF ) + // InternalRos1Parser.g:256: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:262: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:268:2: ( (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) ) + // InternalRos1Parser.g:269:2: (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) + { + // InternalRos1Parser.g:269:2: (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==RULE_STRING) ) { + alt6=1; + } + else if ( (LA6_0==RULE_ID) ) { + alt6=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + switch (alt6) { + case 1 : + // InternalRos1Parser.g:270: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:278: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" + + + // $ANTLR start "entryRuleRosNames" + // InternalRos1Parser.g:289: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:289:48: (iv_ruleRosNames= ruleRosNames EOF ) + // InternalRos1Parser.g:290: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:296: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:302:2: ( (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) ) + // InternalRos1Parser.g:303:2: (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) + { + // InternalRos1Parser.g:303:2: (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) + int alt7=3; + switch ( input.LA(1) ) { + case RULE_ROS_CONVENTION_A: + { + alt7=1; + } + break; + case RULE_ID: + { + alt7=2; + } + break; + case Node: + { + alt7=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + + throw nvae; + } + + switch (alt7) { + case 1 : + // InternalRos1Parser.g:304: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:312: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:320: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 "entryRulePackage_Impl" + // InternalRos1Parser.g:329:1: entryRulePackage_Impl returns [EObject current=null] : iv_rulePackage_Impl= rulePackage_Impl EOF ; + public final EObject entryRulePackage_Impl() throws RecognitionException { + EObject current = null; + + EObject iv_rulePackage_Impl = null; + + + try { + // InternalRos1Parser.g:329:53: (iv_rulePackage_Impl= rulePackage_Impl EOF ) + // InternalRos1Parser.g:330:2: iv_rulePackage_Impl= rulePackage_Impl EOF + { + newCompositeNode(grammarAccess.getPackage_ImplRule()); + pushFollow(FOLLOW_1); + iv_rulePackage_Impl=rulePackage_Impl(); + + state._fsp--; + + current =iv_rulePackage_Impl; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePackage_Impl" + + + // $ANTLR start "rulePackage_Impl" + // InternalRos1Parser.g:336:1: rulePackage_Impl 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= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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 rulePackage_Impl() 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_spec_8_0 = null; + + EObject lv_dependency_12_0 = null; + + EObject lv_dependency_14_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:342:2: ( ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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:343:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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:343:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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:344:3: () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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:344:3: () + // InternalRos1Parser.g:345:4: + { + + current = forceCreateModelElement( + grammarAccess.getPackage_ImplAccess().getPackageAction_0(), + current); + + + } + + // InternalRos1Parser.g:351:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRos1Parser.g:352:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRos1Parser.g:352:4: (lv_name_1_0= ruleRosNames ) + // InternalRos1Parser.g:353:5: lv_name_1_0= ruleRosNames + { + + newCompositeNode(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleRosNames(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_14); + + newLeafNode(this_BEGIN_3, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); + + // InternalRos1Parser.g:378:3: (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0==FromGitRepo) ) { + alt8=1; + } + switch (alt8) { + case 1 : + // InternalRos1Parser.g:379:4: otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) + { + otherlv_4=(Token)match(input,FromGitRepo,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); + + // InternalRos1Parser.g:383:4: ( (lv_fromGitRepo_5_0= ruleEString ) ) + // InternalRos1Parser.g:384:5: (lv_fromGitRepo_5_0= ruleEString ) + { + // InternalRos1Parser.g:384:5: (lv_fromGitRepo_5_0= ruleEString ) + // InternalRos1Parser.g:385:6: lv_fromGitRepo_5_0= ruleEString + { + + newCompositeNode(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + + pushFollow(FOLLOW_15); + lv_fromGitRepo_5_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + set( + current, + "fromGitRepo", + lv_fromGitRepo_5_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos1Parser.g:403:3: (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* this_END_9= RULE_END )? + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==Specs) ) { + alt10=1; + } + switch (alt10) { + case 1 : + // InternalRos1Parser.g:404:4: otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* this_END_9= RULE_END + { + otherlv_6=(Token)match(input,Specs,FOLLOW_4); + + newLeafNode(otherlv_6, grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + + this_BEGIN_7=(Token)match(input,RULE_BEGIN,FOLLOW_16); + + newLeafNode(this_BEGIN_7, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); + + // InternalRos1Parser.g:412:4: ( (lv_spec_8_0= ruleSpecBase ) )* + loop9: + do { + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0==Action_1||LA9_0==Msg||LA9_0==Srv) ) { + alt9=1; + } + + + switch (alt9) { + case 1 : + // InternalRos1Parser.g:413:5: (lv_spec_8_0= ruleSpecBase ) + { + // InternalRos1Parser.g:413:5: (lv_spec_8_0= ruleSpecBase ) + // InternalRos1Parser.g:414:6: lv_spec_8_0= ruleSpecBase + { + + newCompositeNode(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); + + pushFollow(FOLLOW_16); + lv_spec_8_0=ruleSpecBase(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + current, + "spec", + lv_spec_8_0, + "de.fraunhofer.ipa.ros.Ros.SpecBase"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop9; + } + } while (true); + + this_END_9=(Token)match(input,RULE_END,FOLLOW_9); + + newLeafNode(this_END_9, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); + + + } + break; + + } + + // InternalRos1Parser.g:436:3: (otherlv_10= Dependencies otherlv_11= LeftSquareBracket ( (lv_dependency_12_0= ruleDependency ) ) (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* otherlv_15= RightSquareBracket )? + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0==Dependencies) ) { + alt12=1; + } + switch (alt12) { + case 1 : + // InternalRos1Parser.g:437: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.getPackage_ImplAccess().getDependenciesKeyword_6_0()); + + otherlv_11=(Token)match(input,LeftSquareBracket,FOLLOW_11); + + newLeafNode(otherlv_11, grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); + + // InternalRos1Parser.g:445:4: ( (lv_dependency_12_0= ruleDependency ) ) + // InternalRos1Parser.g:446:5: (lv_dependency_12_0= ruleDependency ) + { + // InternalRos1Parser.g:446:5: (lv_dependency_12_0= ruleDependency ) + // InternalRos1Parser.g:447:6: lv_dependency_12_0= ruleDependency + { + + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); + + pushFollow(FOLLOW_12); + lv_dependency_12_0=ruleDependency(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + current, + "dependency", + lv_dependency_12_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:464:4: (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* + loop11: + do { + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0==Comma) ) { + alt11=1; + } + + + switch (alt11) { + case 1 : + // InternalRos1Parser.g:465:5: otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) + { + otherlv_13=(Token)match(input,Comma,FOLLOW_11); + + newLeafNode(otherlv_13, grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); + + // InternalRos1Parser.g:469:5: ( (lv_dependency_14_0= ruleDependency ) ) + // InternalRos1Parser.g:470:6: (lv_dependency_14_0= ruleDependency ) + { + // InternalRos1Parser.g:470:6: (lv_dependency_14_0= ruleDependency ) + // InternalRos1Parser.g:471:7: lv_dependency_14_0= ruleDependency + { + + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + + pushFollow(FOLLOW_12); + lv_dependency_14_0=ruleDependency(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + current, + "dependency", + lv_dependency_14_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop11; + } + } while (true); + + otherlv_15=(Token)match(input,RightSquareBracket,FOLLOW_13); + + newLeafNode(otherlv_15, grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); + + + } + break; + + } + + this_END_16=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_16, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePackage_Impl" + + + // $ANTLR start "entryRuleArtifact" + // InternalRos1Parser.g:502: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:502:49: (iv_ruleArtifact= ruleArtifact EOF ) + // InternalRos1Parser.g:503: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:509: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:515: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:516: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:516: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:517: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:517:3: () + // InternalRos1Parser.g:518:4: + { + + current = forceCreateModelElement( + grammarAccess.getArtifactAccess().getArtifactAction_0(), + current); + + + } + + // InternalRos1Parser.g:524:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRos1Parser.g:525:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRos1Parser.g:525:4: (lv_name_1_0= ruleRosNames ) + // InternalRos1Parser.g:526: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.ros.Ros.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_17); + + newLeafNode(this_BEGIN_3, grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); + + // InternalRos1Parser.g:551:3: ( (lv_node_4_0= ruleNode ) )? + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==Node_1) ) { + alt13=1; + } + switch (alt13) { + case 1 : + // InternalRos1Parser.g:552:4: (lv_node_4_0= ruleNode ) + { + // InternalRos1Parser.g:552:4: (lv_node_4_0= ruleNode ) + // InternalRos1Parser.g:553: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.ros.Ros.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:578: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:578:45: (iv_ruleNode= ruleNode EOF ) + // InternalRos1Parser.g:579: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:585: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= 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 otherlv_15=null; + Token this_BEGIN_16=null; + Token this_END_18=null; + Token otherlv_19=null; + Token this_BEGIN_20=null; + Token this_END_22=null; + Token otherlv_23=null; + Token this_BEGIN_24=null; + Token this_END_26=null; + Token otherlv_27=null; + Token this_BEGIN_28=null; + Token this_END_30=null; + Token this_END_31=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_publisher_5_0 = null; + + EObject lv_subscriber_9_0 = null; + + EObject lv_serviceserver_13_0 = null; + + EObject lv_serviceclient_17_0 = null; + + EObject lv_actionserver_21_0 = null; + + EObject lv_actionclient_25_0 = null; + + EObject lv_parameter_29_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:591: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END ) ) + // InternalRos1Parser.g:592: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END ) + { + // InternalRos1Parser.g:592: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END ) + // InternalRos1Parser.g:593: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END + { + otherlv_0=(Token)match(input,Node_1,FOLLOW_18); + + newLeafNode(otherlv_0, grammarAccess.getNodeAccess().getNodeKeyword_0()); + + // InternalRos1Parser.g:597:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRos1Parser.g:598:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRos1Parser.g:598:4: (lv_name_1_0= ruleRosNames ) + // InternalRos1Parser.g:599: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.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_BEGIN_2=(Token)match(input,RULE_BEGIN,FOLLOW_19); + + newLeafNode(this_BEGIN_2, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); + + // InternalRos1Parser.g:620:3: ( (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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* + loop21: + do { + int alt21=8; + switch ( input.LA(1) ) { + case Publishers: + { + alt21=1; + } + break; + case Subscribers: + { + alt21=2; + } + break; + case Serviceserver: + { + alt21=3; + } + break; + case Serviceclient: + { + alt21=4; + } + break; + case Actionserver: + { + alt21=5; + } + break; + case Actionclient: + { + alt21=6; + } + break; + case Parameters: + { + alt21=7; + } + break; + + } + + switch (alt21) { + case 1 : + // InternalRos1Parser.g:621:4: (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END ) + { + // InternalRos1Parser.g:621:4: (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END ) + // InternalRos1Parser.g:622:5: 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_0()); + + this_BEGIN_4=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_4, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); + + // InternalRos1Parser.g:630:5: ( (lv_publisher_5_0= rulePublisher ) )* + 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:631:6: (lv_publisher_5_0= rulePublisher ) + { + // InternalRos1Parser.g:631:6: (lv_publisher_5_0= rulePublisher ) + // InternalRos1Parser.g:632:7: lv_publisher_5_0= rulePublisher + { + + newCompositeNode(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); + + pushFollow(FOLLOW_20); + lv_publisher_5_0=rulePublisher(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "publisher", + lv_publisher_5_0, + "de.fraunhofer.ipa.ros.Ros.Publisher"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop14; + } + } while (true); + + this_END_6=(Token)match(input,RULE_END,FOLLOW_19); + + newLeafNode(this_END_6, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); + + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:655:4: (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END ) + { + // InternalRos1Parser.g:655:4: (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END ) + // InternalRos1Parser.g:656:5: 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_3_1_0()); + + this_BEGIN_8=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_8, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); + + // InternalRos1Parser.g:664:5: ( (lv_subscriber_9_0= ruleSubscriber ) )* + 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:665:6: (lv_subscriber_9_0= ruleSubscriber ) + { + // InternalRos1Parser.g:665:6: (lv_subscriber_9_0= ruleSubscriber ) + // InternalRos1Parser.g:666:7: lv_subscriber_9_0= ruleSubscriber + { + + newCompositeNode(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); + + pushFollow(FOLLOW_20); + lv_subscriber_9_0=ruleSubscriber(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "subscriber", + lv_subscriber_9_0, + "de.fraunhofer.ipa.ros.Ros.Subscriber"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop15; + } + } while (true); + + this_END_10=(Token)match(input,RULE_END,FOLLOW_19); + + newLeafNode(this_END_10, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); + + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:689:4: (otherlv_11= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) + { + // InternalRos1Parser.g:689:4: (otherlv_11= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) + // InternalRos1Parser.g:690:5: otherlv_11= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END + { + otherlv_11=(Token)match(input,Serviceserver,FOLLOW_4); + + newLeafNode(otherlv_11, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); + + this_BEGIN_12=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_12, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); + + // InternalRos1Parser.g:698:5: ( (lv_serviceserver_13_0= ruleServiceServer ) )* + loop16: + do { + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0==RULE_ID||LA16_0==RULE_STRING) ) { + alt16=1; + } + + + switch (alt16) { + case 1 : + // InternalRos1Parser.g:699:6: (lv_serviceserver_13_0= ruleServiceServer ) + { + // InternalRos1Parser.g:699:6: (lv_serviceserver_13_0= ruleServiceServer ) + // InternalRos1Parser.g:700:7: lv_serviceserver_13_0= ruleServiceServer + { + + newCompositeNode(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); + + pushFollow(FOLLOW_20); + lv_serviceserver_13_0=ruleServiceServer(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "serviceserver", + lv_serviceserver_13_0, + "de.fraunhofer.ipa.ros.Ros.ServiceServer"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop16; + } + } while (true); + + this_END_14=(Token)match(input,RULE_END,FOLLOW_19); + + newLeafNode(this_END_14, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); + + + } + + + } + break; + case 4 : + // InternalRos1Parser.g:723:4: (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) + { + // InternalRos1Parser.g:723:4: (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) + // InternalRos1Parser.g:724:5: otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END + { + otherlv_15=(Token)match(input,Serviceclient,FOLLOW_4); + + newLeafNode(otherlv_15, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); + + this_BEGIN_16=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_16, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); + + // InternalRos1Parser.g:732:5: ( (lv_serviceclient_17_0= ruleServiceClient ) )* + loop17: + do { + int alt17=2; + int LA17_0 = input.LA(1); + + if ( (LA17_0==RULE_ID||LA17_0==RULE_STRING) ) { + alt17=1; + } + + + switch (alt17) { + case 1 : + // InternalRos1Parser.g:733:6: (lv_serviceclient_17_0= ruleServiceClient ) + { + // InternalRos1Parser.g:733:6: (lv_serviceclient_17_0= ruleServiceClient ) + // InternalRos1Parser.g:734:7: lv_serviceclient_17_0= ruleServiceClient + { + + newCompositeNode(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); + + pushFollow(FOLLOW_20); + lv_serviceclient_17_0=ruleServiceClient(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "serviceclient", + lv_serviceclient_17_0, + "de.fraunhofer.ipa.ros.Ros.ServiceClient"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop17; + } + } while (true); + + this_END_18=(Token)match(input,RULE_END,FOLLOW_19); + + newLeafNode(this_END_18, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); + + + } + + + } + break; + case 5 : + // InternalRos1Parser.g:757:4: (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) + { + // InternalRos1Parser.g:757:4: (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) + // InternalRos1Parser.g:758:5: otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END + { + otherlv_19=(Token)match(input,Actionserver,FOLLOW_4); + + newLeafNode(otherlv_19, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); + + this_BEGIN_20=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_20, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); + + // InternalRos1Parser.g:766:5: ( (lv_actionserver_21_0= ruleActionServer ) )* + loop18: + do { + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0==RULE_ID||LA18_0==RULE_STRING) ) { + alt18=1; + } + + + switch (alt18) { + case 1 : + // InternalRos1Parser.g:767:6: (lv_actionserver_21_0= ruleActionServer ) + { + // InternalRos1Parser.g:767:6: (lv_actionserver_21_0= ruleActionServer ) + // InternalRos1Parser.g:768:7: lv_actionserver_21_0= ruleActionServer + { + + newCompositeNode(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); + + pushFollow(FOLLOW_20); + lv_actionserver_21_0=ruleActionServer(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "actionserver", + lv_actionserver_21_0, + "de.fraunhofer.ipa.ros.Ros.ActionServer"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop18; + } + } while (true); + + this_END_22=(Token)match(input,RULE_END,FOLLOW_19); + + newLeafNode(this_END_22, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); + + + } + + + } + break; + case 6 : + // InternalRos1Parser.g:791:4: (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) + { + // InternalRos1Parser.g:791:4: (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) + // InternalRos1Parser.g:792:5: otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END + { + otherlv_23=(Token)match(input,Actionclient,FOLLOW_4); + + newLeafNode(otherlv_23, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); + + this_BEGIN_24=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_24, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); + + // InternalRos1Parser.g:800:5: ( (lv_actionclient_25_0= ruleActionClient ) )* + loop19: + do { + int alt19=2; + int LA19_0 = input.LA(1); + + if ( (LA19_0==RULE_ID||LA19_0==RULE_STRING) ) { + alt19=1; + } + + + switch (alt19) { + case 1 : + // InternalRos1Parser.g:801:6: (lv_actionclient_25_0= ruleActionClient ) + { + // InternalRos1Parser.g:801:6: (lv_actionclient_25_0= ruleActionClient ) + // InternalRos1Parser.g:802:7: lv_actionclient_25_0= ruleActionClient + { + + newCompositeNode(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); + + pushFollow(FOLLOW_20); + lv_actionclient_25_0=ruleActionClient(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "actionclient", + lv_actionclient_25_0, + "de.fraunhofer.ipa.ros.Ros.ActionClient"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop19; + } + } while (true); + + this_END_26=(Token)match(input,RULE_END,FOLLOW_19); + + newLeafNode(this_END_26, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); + + + } + + + } + break; + case 7 : + // InternalRos1Parser.g:825:4: (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) + { + // InternalRos1Parser.g:825:4: (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) + // InternalRos1Parser.g:826:5: otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END + { + otherlv_27=(Token)match(input,Parameters,FOLLOW_4); + + newLeafNode(otherlv_27, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); + + this_BEGIN_28=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_28, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); + + // InternalRos1Parser.g:834:5: ( (lv_parameter_29_0= ruleParameter ) )* + loop20: + do { + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0==RULE_ID||LA20_0==RULE_STRING) ) { + alt20=1; + } + + + switch (alt20) { + case 1 : + // InternalRos1Parser.g:835:6: (lv_parameter_29_0= ruleParameter ) + { + // InternalRos1Parser.g:835:6: (lv_parameter_29_0= ruleParameter ) + // InternalRos1Parser.g:836:7: lv_parameter_29_0= ruleParameter + { + + newCompositeNode(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); + + pushFollow(FOLLOW_20); + lv_parameter_29_0=ruleParameter(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "parameter", + lv_parameter_29_0, + "de.fraunhofer.ipa.ros.Ros.Parameter"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop20; + } + } while (true); + + this_END_30=(Token)match(input,RULE_END,FOLLOW_19); + + newLeafNode(this_END_30, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); + + + } + + + } + break; + + default : + break loop21; + } + } while (true); + + this_END_31=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_31, grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleNode" + + + // $ANTLR start "entryRuleSpecBase" + // InternalRos1Parser.g:867:1: entryRuleSpecBase returns [EObject current=null] : iv_ruleSpecBase= ruleSpecBase EOF ; + public final EObject entryRuleSpecBase() throws RecognitionException { + EObject current = null; + + EObject iv_ruleSpecBase = null; + + + try { + // InternalRos1Parser.g:867:49: (iv_ruleSpecBase= ruleSpecBase EOF ) + // InternalRos1Parser.g:868:2: iv_ruleSpecBase= ruleSpecBase EOF + { + newCompositeNode(grammarAccess.getSpecBaseRule()); + pushFollow(FOLLOW_1); + iv_ruleSpecBase=ruleSpecBase(); + + state._fsp--; + + current =iv_ruleSpecBase; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleSpecBase" + + + // $ANTLR start "ruleSpecBase" + // InternalRos1Parser.g:874:1: ruleSpecBase returns [EObject current=null] : (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) ; + public final EObject ruleSpecBase() throws RecognitionException { + EObject current = null; + + EObject this_TopicSpec_0 = null; + + EObject this_ServiceSpec_1 = null; + + EObject this_ActionSpec_2 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:880:2: ( (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) ) + // InternalRos1Parser.g:881:2: (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) + { + // InternalRos1Parser.g:881:2: (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) + int alt22=3; + switch ( input.LA(1) ) { + case Msg: + { + alt22=1; + } + break; + case Srv: + { + alt22=2; + } + break; + case Action_1: + { + alt22=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 22, 0, input); + + throw nvae; + } + + switch (alt22) { + case 1 : + // InternalRos1Parser.g:882:3: this_TopicSpec_0= ruleTopicSpec + { + + newCompositeNode(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_TopicSpec_0=ruleTopicSpec(); + + state._fsp--; + + + current = this_TopicSpec_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos1Parser.g:891:3: this_ServiceSpec_1= ruleServiceSpec + { + + newCompositeNode(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_ServiceSpec_1=ruleServiceSpec(); + + state._fsp--; + + + current = this_ServiceSpec_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalRos1Parser.g:900:3: this_ActionSpec_2= ruleActionSpec + { + + newCompositeNode(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_ActionSpec_2=ruleActionSpec(); + + state._fsp--; + + + current = this_ActionSpec_2; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleSpecBase" + + + // $ANTLR start "entryRuleTopicSpec" + // InternalRos1Parser.g:912:1: entryRuleTopicSpec returns [EObject current=null] : iv_ruleTopicSpec= ruleTopicSpec EOF ; + public final EObject entryRuleTopicSpec() throws RecognitionException { + EObject current = null; + + EObject iv_ruleTopicSpec = null; + + + try { + // InternalRos1Parser.g:912:50: (iv_ruleTopicSpec= ruleTopicSpec EOF ) + // InternalRos1Parser.g:913:2: iv_ruleTopicSpec= ruleTopicSpec EOF + { + newCompositeNode(grammarAccess.getTopicSpecRule()); + pushFollow(FOLLOW_1); + iv_ruleTopicSpec=ruleTopicSpec(); + + state._fsp--; + + current =iv_ruleTopicSpec; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleTopicSpec" + + + // $ANTLR start "ruleTopicSpec" + // InternalRos1Parser.g:919:1: ruleTopicSpec returns [EObject current=null] : ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) ; + public final EObject ruleTopicSpec() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token lv_name_2_2=null; + Token lv_name_2_3=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token this_BEGIN_5=null; + Token this_END_7=null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_2_1 = null; + + EObject lv_message_6_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:925:2: ( ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) ) + // InternalRos1Parser.g:926:2: ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) + { + // InternalRos1Parser.g:926:2: ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) + // InternalRos1Parser.g:927:3: () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END + { + // InternalRos1Parser.g:927:3: () + // InternalRos1Parser.g:928:4: + { + + current = forceCreateModelElement( + grammarAccess.getTopicSpecAccess().getTopicSpecAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Msg,FOLLOW_21); + + newLeafNode(otherlv_1, grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); + + // InternalRos1Parser.g:938:3: ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) + // InternalRos1Parser.g:939:4: ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) + { + // InternalRos1Parser.g:939:4: ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) + // InternalRos1Parser.g:940:5: (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) + { + // InternalRos1Parser.g:940:5: (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) + int alt23=3; + switch ( input.LA(1) ) { + case RULE_ID: + case RULE_STRING: + { + alt23=1; + } + break; + case Header: + { + alt23=2; + } + break; + case String: + { + alt23=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 23, 0, input); + + throw nvae; + } + + switch (alt23) { + case 1 : + // InternalRos1Parser.g:941:6: lv_name_2_1= ruleEString + { + + newCompositeNode(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + + pushFollow(FOLLOW_4); + lv_name_2_1=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getTopicSpecRule()); + } + set( + current, + "name", + lv_name_2_1, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos1Parser.g:957:6: lv_name_2_2= Header + { + lv_name_2_2=(Token)match(input,Header,FOLLOW_4); + + newLeafNode(lv_name_2_2, grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); + + + if (current==null) { + current = createModelElement(grammarAccess.getTopicSpecRule()); + } + setWithLastConsumed(current, "name", lv_name_2_2, null); + + + } + break; + case 3 : + // InternalRos1Parser.g:968:6: lv_name_2_3= String + { + lv_name_2_3=(Token)match(input,String,FOLLOW_4); + + newLeafNode(lv_name_2_3, grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); + + + if (current==null) { + current = createModelElement(grammarAccess.getTopicSpecRule()); + } + setWithLastConsumed(current, "name", lv_name_2_3, null); + + + } + break; + + } + + + } + + + } + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_22); + + newLeafNode(this_BEGIN_3, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Message_1,FOLLOW_23); + + newLeafNode(otherlv_4, grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); + + // InternalRos1Parser.g:989:3: (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? + int alt24=2; + int LA24_0 = input.LA(1); + + if ( (LA24_0==RULE_BEGIN) ) { + alt24=1; + } + switch (alt24) { + case 1 : + // InternalRos1Parser.g:990:4: this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END + { + this_BEGIN_5=(Token)match(input,RULE_BEGIN,FOLLOW_24); + + newLeafNode(this_BEGIN_5, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); + + // InternalRos1Parser.g:994:4: ( (lv_message_6_0= ruleMessageDefinition ) ) + // InternalRos1Parser.g:995:5: (lv_message_6_0= ruleMessageDefinition ) + { + // InternalRos1Parser.g:995:5: (lv_message_6_0= ruleMessageDefinition ) + // InternalRos1Parser.g:996:6: lv_message_6_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); + + pushFollow(FOLLOW_13); + lv_message_6_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getTopicSpecRule()); + } + set( + current, + "message", + lv_message_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_7=(Token)match(input,RULE_END,FOLLOW_13); + + newLeafNode(this_END_7, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); + + + } + break; + + } + + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_8, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleTopicSpec" + + + // $ANTLR start "entryRuleServiceSpec" + // InternalRos1Parser.g:1026:1: entryRuleServiceSpec returns [EObject current=null] : iv_ruleServiceSpec= ruleServiceSpec EOF ; + public final EObject entryRuleServiceSpec() throws RecognitionException { + EObject current = null; + + EObject iv_ruleServiceSpec = null; + + + try { + // InternalRos1Parser.g:1026:52: (iv_ruleServiceSpec= ruleServiceSpec EOF ) + // InternalRos1Parser.g:1027:2: iv_ruleServiceSpec= ruleServiceSpec EOF + { + newCompositeNode(grammarAccess.getServiceSpecRule()); + pushFollow(FOLLOW_1); + iv_ruleServiceSpec=ruleServiceSpec(); + + state._fsp--; + + current =iv_ruleServiceSpec; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleServiceSpec" + + + // $ANTLR start "ruleServiceSpec" + // InternalRos1Parser.g:1033:1: ruleServiceSpec returns [EObject current=null] : ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) ; + public final EObject ruleServiceSpec() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token this_BEGIN_5=null; + Token this_END_7=null; + Token otherlv_8=null; + Token this_BEGIN_9=null; + Token this_END_11=null; + Token this_END_12=null; + AntlrDatatypeRuleToken lv_name_2_0 = null; + + EObject lv_request_6_0 = null; + + EObject lv_response_10_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:1039:2: ( ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) ) + // InternalRos1Parser.g:1040:2: ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) + { + // InternalRos1Parser.g:1040:2: ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) + // InternalRos1Parser.g:1041:3: () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END + { + // InternalRos1Parser.g:1041:3: () + // InternalRos1Parser.g:1042:4: + { + + current = forceCreateModelElement( + grammarAccess.getServiceSpecAccess().getServiceSpecAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Srv,FOLLOW_6); + + newLeafNode(otherlv_1, grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); + + // InternalRos1Parser.g:1052:3: ( (lv_name_2_0= ruleEString ) ) + // InternalRos1Parser.g:1053:4: (lv_name_2_0= ruleEString ) + { + // InternalRos1Parser.g:1053:4: (lv_name_2_0= ruleEString ) + // InternalRos1Parser.g:1054:5: lv_name_2_0= ruleEString + { + + newCompositeNode(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); + + pushFollow(FOLLOW_4); + lv_name_2_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + current, + "name", + lv_name_2_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_25); + + newLeafNode(this_BEGIN_3, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Request,FOLLOW_26); + + newLeafNode(otherlv_4, grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); + + // InternalRos1Parser.g:1079:3: (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0==RULE_BEGIN) ) { + alt25=1; + } + switch (alt25) { + case 1 : + // InternalRos1Parser.g:1080:4: this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END + { + this_BEGIN_5=(Token)match(input,RULE_BEGIN,FOLLOW_24); + + newLeafNode(this_BEGIN_5, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); + + // InternalRos1Parser.g:1084:4: ( (lv_request_6_0= ruleMessageDefinition ) ) + // InternalRos1Parser.g:1085:5: (lv_request_6_0= ruleMessageDefinition ) + { + // InternalRos1Parser.g:1085:5: (lv_request_6_0= ruleMessageDefinition ) + // InternalRos1Parser.g:1086:6: lv_request_6_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); + + pushFollow(FOLLOW_13); + lv_request_6_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + current, + "request", + lv_request_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_7=(Token)match(input,RULE_END,FOLLOW_27); + + newLeafNode(this_END_7, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); + + + } + break; + + } + + otherlv_8=(Token)match(input,Response,FOLLOW_23); + + newLeafNode(otherlv_8, grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); + + // InternalRos1Parser.g:1112:3: (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0==RULE_BEGIN) ) { + alt26=1; + } + switch (alt26) { + case 1 : + // InternalRos1Parser.g:1113:4: this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END + { + this_BEGIN_9=(Token)match(input,RULE_BEGIN,FOLLOW_24); + + newLeafNode(this_BEGIN_9, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); + + // InternalRos1Parser.g:1117:4: ( (lv_response_10_0= ruleMessageDefinition ) ) + // InternalRos1Parser.g:1118:5: (lv_response_10_0= ruleMessageDefinition ) + { + // InternalRos1Parser.g:1118:5: (lv_response_10_0= ruleMessageDefinition ) + // InternalRos1Parser.g:1119:6: lv_response_10_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_13); + lv_response_10_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + current, + "response", + lv_response_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_11=(Token)match(input,RULE_END,FOLLOW_13); + + newLeafNode(this_END_11, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); + + + } + break; + + } + + this_END_12=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_12, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleServiceSpec" + + + // $ANTLR start "entryRuleActionSpec" + // InternalRos1Parser.g:1149:1: entryRuleActionSpec returns [EObject current=null] : iv_ruleActionSpec= ruleActionSpec EOF ; + public final EObject entryRuleActionSpec() throws RecognitionException { + EObject current = null; + + EObject iv_ruleActionSpec = null; + + + try { + // InternalRos1Parser.g:1149:51: (iv_ruleActionSpec= ruleActionSpec EOF ) + // InternalRos1Parser.g:1150:2: iv_ruleActionSpec= ruleActionSpec EOF + { + newCompositeNode(grammarAccess.getActionSpecRule()); + pushFollow(FOLLOW_1); + iv_ruleActionSpec=ruleActionSpec(); + + state._fsp--; + + current =iv_ruleActionSpec; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleActionSpec" + + + // $ANTLR start "ruleActionSpec" + // InternalRos1Parser.g:1156:1: ruleActionSpec returns [EObject current=null] : ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) ; + public final EObject ruleActionSpec() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token this_BEGIN_5=null; + Token this_END_7=null; + Token otherlv_8=null; + Token this_BEGIN_9=null; + Token this_END_11=null; + Token otherlv_12=null; + Token this_BEGIN_13=null; + Token this_END_15=null; + Token this_END_16=null; + AntlrDatatypeRuleToken lv_name_2_0 = null; + + EObject lv_goal_6_0 = null; + + EObject lv_result_10_0 = null; + + EObject lv_feedback_14_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:1162:2: ( ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) ) + // InternalRos1Parser.g:1163:2: ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) + { + // InternalRos1Parser.g:1163:2: ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) + // InternalRos1Parser.g:1164:3: () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END + { + // InternalRos1Parser.g:1164:3: () + // InternalRos1Parser.g:1165:4: + { + + current = forceCreateModelElement( + grammarAccess.getActionSpecAccess().getActionSpecAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Action_1,FOLLOW_6); + + newLeafNode(otherlv_1, grammarAccess.getActionSpecAccess().getActionKeyword_1()); + + // InternalRos1Parser.g:1175:3: ( (lv_name_2_0= ruleEString ) ) + // InternalRos1Parser.g:1176:4: (lv_name_2_0= ruleEString ) + { + // InternalRos1Parser.g:1176:4: (lv_name_2_0= ruleEString ) + // InternalRos1Parser.g:1177:5: lv_name_2_0= ruleEString + { + + newCompositeNode(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + + pushFollow(FOLLOW_4); + lv_name_2_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + current, + "name", + lv_name_2_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_28); + + newLeafNode(this_BEGIN_3, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Goal_1,FOLLOW_29); + + newLeafNode(otherlv_4, grammarAccess.getActionSpecAccess().getGoalKeyword_4()); + + // InternalRos1Parser.g:1202:3: (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? + int alt27=2; + int LA27_0 = input.LA(1); + + if ( (LA27_0==RULE_BEGIN) ) { + alt27=1; + } + switch (alt27) { + case 1 : + // InternalRos1Parser.g:1203:4: this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END + { + this_BEGIN_5=(Token)match(input,RULE_BEGIN,FOLLOW_24); + + newLeafNode(this_BEGIN_5, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); + + // InternalRos1Parser.g:1207:4: ( (lv_goal_6_0= ruleMessageDefinition ) ) + // InternalRos1Parser.g:1208:5: (lv_goal_6_0= ruleMessageDefinition ) + { + // InternalRos1Parser.g:1208:5: (lv_goal_6_0= ruleMessageDefinition ) + // InternalRos1Parser.g:1209:6: lv_goal_6_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); + + pushFollow(FOLLOW_13); + lv_goal_6_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + current, + "goal", + lv_goal_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_7=(Token)match(input,RULE_END,FOLLOW_30); + + newLeafNode(this_END_7, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); + + + } + break; + + } + + otherlv_8=(Token)match(input,Result_1,FOLLOW_31); + + newLeafNode(otherlv_8, grammarAccess.getActionSpecAccess().getResultKeyword_6()); + + // InternalRos1Parser.g:1235:3: (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? + int alt28=2; + int LA28_0 = input.LA(1); + + if ( (LA28_0==RULE_BEGIN) ) { + alt28=1; + } + switch (alt28) { + case 1 : + // InternalRos1Parser.g:1236:4: this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END + { + this_BEGIN_9=(Token)match(input,RULE_BEGIN,FOLLOW_24); + + newLeafNode(this_BEGIN_9, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); + + // InternalRos1Parser.g:1240:4: ( (lv_result_10_0= ruleMessageDefinition ) ) + // InternalRos1Parser.g:1241:5: (lv_result_10_0= ruleMessageDefinition ) + { + // InternalRos1Parser.g:1241:5: (lv_result_10_0= ruleMessageDefinition ) + // InternalRos1Parser.g:1242:6: lv_result_10_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_13); + lv_result_10_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + current, + "result", + lv_result_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_11=(Token)match(input,RULE_END,FOLLOW_32); + + newLeafNode(this_END_11, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); + + + } + break; + + } + + otherlv_12=(Token)match(input,Feedback_1,FOLLOW_23); + + newLeafNode(otherlv_12, grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + + // InternalRos1Parser.g:1268:3: (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0==RULE_BEGIN) ) { + alt29=1; + } + switch (alt29) { + case 1 : + // InternalRos1Parser.g:1269:4: this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END + { + this_BEGIN_13=(Token)match(input,RULE_BEGIN,FOLLOW_24); + + newLeafNode(this_BEGIN_13, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); + + // InternalRos1Parser.g:1273:4: ( (lv_feedback_14_0= ruleMessageDefinition ) ) + // InternalRos1Parser.g:1274:5: (lv_feedback_14_0= ruleMessageDefinition ) + { + // InternalRos1Parser.g:1274:5: (lv_feedback_14_0= ruleMessageDefinition ) + // InternalRos1Parser.g:1275:6: lv_feedback_14_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); + + pushFollow(FOLLOW_13); + lv_feedback_14_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + current, + "feedback", + lv_feedback_14_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_15=(Token)match(input,RULE_END,FOLLOW_13); + + newLeafNode(this_END_15, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); + + + } + break; + + } + + this_END_16=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_16, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleActionSpec" + + + // $ANTLR start "entryRuleMessageDefinition" + // InternalRos1Parser.g:1305:1: entryRuleMessageDefinition returns [EObject current=null] : iv_ruleMessageDefinition= ruleMessageDefinition EOF ; + public final EObject entryRuleMessageDefinition() throws RecognitionException { + EObject current = null; + + EObject iv_ruleMessageDefinition = null; + + + try { + // InternalRos1Parser.g:1305:58: (iv_ruleMessageDefinition= ruleMessageDefinition EOF ) + // InternalRos1Parser.g:1306:2: iv_ruleMessageDefinition= ruleMessageDefinition EOF + { + newCompositeNode(grammarAccess.getMessageDefinitionRule()); + pushFollow(FOLLOW_1); + iv_ruleMessageDefinition=ruleMessageDefinition(); + + state._fsp--; + + current =iv_ruleMessageDefinition; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleMessageDefinition" + + + // $ANTLR start "ruleMessageDefinition" + // InternalRos1Parser.g:1312:1: ruleMessageDefinition returns [EObject current=null] : ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) ; + public final EObject ruleMessageDefinition() throws RecognitionException { + EObject current = null; + + EObject lv_MessagePart_1_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:1318:2: ( ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) ) + // InternalRos1Parser.g:1319:2: ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) + { + // InternalRos1Parser.g:1319:2: ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) + // InternalRos1Parser.g:1320:3: () ( (lv_MessagePart_1_0= ruleMessagePart ) )* + { + // InternalRos1Parser.g:1320:3: () + // InternalRos1Parser.g:1321:4: + { + + current = forceCreateModelElement( + grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0(), + current); + + + } + + // InternalRos1Parser.g:1327:3: ( (lv_MessagePart_1_0= ruleMessagePart ) )* + loop30: + do { + int alt30=2; + int LA30_0 = input.LA(1); + + if ( ((LA30_0>=Float32_1 && LA30_0<=Float64_1)||LA30_0==Duration||(LA30_0>=String_2 && LA30_0<=Uint64_1)||(LA30_0>=Float32 && LA30_0<=Int64_1)||LA30_0==Uint8_1||LA30_0==Header||(LA30_0>=Bool_1 && LA30_0<=Int8_1)||(LA30_0>=String_1 && LA30_0<=Uint64)||(LA30_0>=Int16 && LA30_0<=Int64)||LA30_0==Uint8||(LA30_0>=Bool && LA30_0<=Byte)||LA30_0==Int8||LA30_0==Time||LA30_0==RULE_ID||LA30_0==RULE_STRING) ) { + alt30=1; + } + + + switch (alt30) { + case 1 : + // InternalRos1Parser.g:1328:4: (lv_MessagePart_1_0= ruleMessagePart ) + { + // InternalRos1Parser.g:1328:4: (lv_MessagePart_1_0= ruleMessagePart ) + // InternalRos1Parser.g:1329:5: lv_MessagePart_1_0= ruleMessagePart + { + + newCompositeNode(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); + + pushFollow(FOLLOW_33); + lv_MessagePart_1_0=ruleMessagePart(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getMessageDefinitionRule()); + } + add( + current, + "MessagePart", + lv_MessagePart_1_0, + "de.fraunhofer.ipa.ros.Ros.MessagePart"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop30; + } + } while (true); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMessageDefinition" + + + // $ANTLR start "entryRulePublisher" + // InternalRos1Parser.g:1350: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:1350:50: (iv_rulePublisher= rulePublisher EOF ) + // InternalRos1Parser.g:1351: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:1357:1: rulePublisher returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= 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 otherlv_6=null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:1363:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRos1Parser.g:1364:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + { + // InternalRos1Parser.g:1364:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRos1Parser.g:1365:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END + { + // InternalRos1Parser.g:1365:3: () + // InternalRos1Parser.g:1366:4: + { + + current = forceCreateModelElement( + grammarAccess.getPublisherAccess().getPublisherAction_0(), + current); + + + } + + // InternalRos1Parser.g:1372:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos1Parser.g:1373:4: (lv_name_1_0= ruleEString ) + { + // InternalRos1Parser.g:1373:4: (lv_name_1_0= ruleEString ) + // InternalRos1Parser.g:1374: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.ros.Ros.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_34); + + newLeafNode(this_BEGIN_3, grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getPublisherAccess().getTypeKeyword_4()); + + // InternalRos1Parser.g:1403:3: ( ( ruleEString ) ) + // InternalRos1Parser.g:1404:4: ( ruleEString ) + { + // InternalRos1Parser.g:1404:4: ( ruleEString ) + // InternalRos1Parser.g:1405:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getPublisherRule()); + } + + + newCompositeNode(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + + pushFollow(FOLLOW_35); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:1419:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt31=2; + int LA31_0 = input.LA(1); + + if ( (LA31_0==Ns) ) { + alt31=1; + } + switch (alt31) { + case 1 : + // InternalRos1Parser.g:1420:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_36); + + newLeafNode(otherlv_6, grammarAccess.getPublisherAccess().getNsKeyword_6_0()); + + // InternalRos1Parser.g:1424:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos1Parser.g:1425:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos1Parser.g:1425:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos1Parser.g:1426:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_13); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPublisherRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_8, grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePublisher" + + + // $ANTLR start "entryRuleSubscriber" + // InternalRos1Parser.g:1452: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:1452:51: (iv_ruleSubscriber= ruleSubscriber EOF ) + // InternalRos1Parser.g:1453: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:1459:1: ruleSubscriber returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= 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 otherlv_6=null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:1465:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRos1Parser.g:1466:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + { + // InternalRos1Parser.g:1466:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRos1Parser.g:1467:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END + { + // InternalRos1Parser.g:1467:3: () + // InternalRos1Parser.g:1468:4: + { + + current = forceCreateModelElement( + grammarAccess.getSubscriberAccess().getSubscriberAction_0(), + current); + + + } + + // InternalRos1Parser.g:1474:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos1Parser.g:1475:4: (lv_name_1_0= ruleEString ) + { + // InternalRos1Parser.g:1475:4: (lv_name_1_0= ruleEString ) + // InternalRos1Parser.g:1476: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.ros.Ros.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_34); + + newLeafNode(this_BEGIN_3, grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getSubscriberAccess().getTypeKeyword_4()); + + // InternalRos1Parser.g:1505:3: ( ( ruleEString ) ) + // InternalRos1Parser.g:1506:4: ( ruleEString ) + { + // InternalRos1Parser.g:1506:4: ( ruleEString ) + // InternalRos1Parser.g:1507:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getSubscriberRule()); + } + + + newCompositeNode(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + + pushFollow(FOLLOW_35); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:1521:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt32=2; + int LA32_0 = input.LA(1); + + if ( (LA32_0==Ns) ) { + alt32=1; + } + switch (alt32) { + case 1 : + // InternalRos1Parser.g:1522:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_36); + + newLeafNode(otherlv_6, grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); + + // InternalRos1Parser.g:1526:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos1Parser.g:1527:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos1Parser.g:1527:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos1Parser.g:1528:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_13); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getSubscriberRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_8, grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_7()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleSubscriber" + + + // $ANTLR start "entryRuleServiceServer" + // InternalRos1Parser.g:1554:1: entryRuleServiceServer returns [EObject current=null] : iv_ruleServiceServer= ruleServiceServer EOF ; + public final EObject entryRuleServiceServer() throws RecognitionException { + EObject current = null; + + EObject iv_ruleServiceServer = null; + + + try { + // InternalRos1Parser.g:1554:54: (iv_ruleServiceServer= ruleServiceServer EOF ) + // InternalRos1Parser.g:1555:2: iv_ruleServiceServer= ruleServiceServer EOF + { + newCompositeNode(grammarAccess.getServiceServerRule()); + pushFollow(FOLLOW_1); + iv_ruleServiceServer=ruleServiceServer(); + + state._fsp--; + + current =iv_ruleServiceServer; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleServiceServer" + + + // $ANTLR start "ruleServiceServer" + // InternalRos1Parser.g:1561:1: ruleServiceServer returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ; + public final EObject ruleServiceServer() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:1567:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRos1Parser.g:1568:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + { + // InternalRos1Parser.g:1568:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRos1Parser.g:1569:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END + { + // InternalRos1Parser.g:1569:3: () + // InternalRos1Parser.g:1570:4: + { + + current = forceCreateModelElement( + grammarAccess.getServiceServerAccess().getServiceServerAction_0(), + current); + + + } + + // InternalRos1Parser.g:1576:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos1Parser.g:1577:4: (lv_name_1_0= ruleEString ) + { + // InternalRos1Parser.g:1577:4: (lv_name_1_0= ruleEString ) + // InternalRos1Parser.g:1578:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceServerRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getServiceServerAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_34); + + newLeafNode(this_BEGIN_3, grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getServiceServerAccess().getTypeKeyword_4()); + + // InternalRos1Parser.g:1607:3: ( ( ruleEString ) ) + // InternalRos1Parser.g:1608:4: ( ruleEString ) + { + // InternalRos1Parser.g:1608:4: ( ruleEString ) + // InternalRos1Parser.g:1609:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getServiceServerRule()); + } + + + newCompositeNode(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); + + pushFollow(FOLLOW_35); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:1623:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt33=2; + int LA33_0 = input.LA(1); + + if ( (LA33_0==Ns) ) { + alt33=1; + } + switch (alt33) { + case 1 : + // InternalRos1Parser.g:1624:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_36); + + newLeafNode(otherlv_6, grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); + + // InternalRos1Parser.g:1628:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos1Parser.g:1629:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos1Parser.g:1629:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos1Parser.g:1630:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_13); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceServerRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_8, grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_7()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleServiceServer" + + + // $ANTLR start "entryRuleServiceClient" + // InternalRos1Parser.g:1656:1: entryRuleServiceClient returns [EObject current=null] : iv_ruleServiceClient= ruleServiceClient EOF ; + public final EObject entryRuleServiceClient() throws RecognitionException { + EObject current = null; + + EObject iv_ruleServiceClient = null; + + + try { + // InternalRos1Parser.g:1656:54: (iv_ruleServiceClient= ruleServiceClient EOF ) + // InternalRos1Parser.g:1657:2: iv_ruleServiceClient= ruleServiceClient EOF + { + newCompositeNode(grammarAccess.getServiceClientRule()); + pushFollow(FOLLOW_1); + iv_ruleServiceClient=ruleServiceClient(); + + state._fsp--; + + current =iv_ruleServiceClient; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleServiceClient" + + + // $ANTLR start "ruleServiceClient" + // InternalRos1Parser.g:1663:1: ruleServiceClient returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ; + public final EObject ruleServiceClient() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:1669:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRos1Parser.g:1670:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + { + // InternalRos1Parser.g:1670:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRos1Parser.g:1671:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END + { + // InternalRos1Parser.g:1671:3: () + // InternalRos1Parser.g:1672:4: + { + + current = forceCreateModelElement( + grammarAccess.getServiceClientAccess().getServiceClientAction_0(), + current); + + + } + + // InternalRos1Parser.g:1678:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos1Parser.g:1679:4: (lv_name_1_0= ruleEString ) + { + // InternalRos1Parser.g:1679:4: (lv_name_1_0= ruleEString ) + // InternalRos1Parser.g:1680:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceClientRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getServiceClientAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_34); + + newLeafNode(this_BEGIN_3, grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getServiceClientAccess().getTypeKeyword_4()); + + // InternalRos1Parser.g:1709:3: ( ( ruleEString ) ) + // InternalRos1Parser.g:1710:4: ( ruleEString ) + { + // InternalRos1Parser.g:1710:4: ( ruleEString ) + // InternalRos1Parser.g:1711:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getServiceClientRule()); + } + + + newCompositeNode(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); + + pushFollow(FOLLOW_35); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:1725:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt34=2; + int LA34_0 = input.LA(1); + + if ( (LA34_0==Ns) ) { + alt34=1; + } + switch (alt34) { + case 1 : + // InternalRos1Parser.g:1726:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_36); + + newLeafNode(otherlv_6, grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); + + // InternalRos1Parser.g:1730:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos1Parser.g:1731:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos1Parser.g:1731:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos1Parser.g:1732:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_13); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceClientRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_8, grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_7()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleServiceClient" + + + // $ANTLR start "entryRuleActionServer" + // InternalRos1Parser.g:1758:1: entryRuleActionServer returns [EObject current=null] : iv_ruleActionServer= ruleActionServer EOF ; + public final EObject entryRuleActionServer() throws RecognitionException { + EObject current = null; + + EObject iv_ruleActionServer = null; + + + try { + // InternalRos1Parser.g:1758:53: (iv_ruleActionServer= ruleActionServer EOF ) + // InternalRos1Parser.g:1759:2: iv_ruleActionServer= ruleActionServer EOF + { + newCompositeNode(grammarAccess.getActionServerRule()); + pushFollow(FOLLOW_1); + iv_ruleActionServer=ruleActionServer(); + + state._fsp--; + + current =iv_ruleActionServer; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleActionServer" + + + // $ANTLR start "ruleActionServer" + // InternalRos1Parser.g:1765:1: ruleActionServer returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ; + public final EObject ruleActionServer() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:1771:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRos1Parser.g:1772:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + { + // InternalRos1Parser.g:1772:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRos1Parser.g:1773:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END + { + // InternalRos1Parser.g:1773:3: () + // InternalRos1Parser.g:1774:4: + { + + current = forceCreateModelElement( + grammarAccess.getActionServerAccess().getActionServerAction_0(), + current); + + + } + + // InternalRos1Parser.g:1780:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos1Parser.g:1781:4: (lv_name_1_0= ruleEString ) + { + // InternalRos1Parser.g:1781:4: (lv_name_1_0= ruleEString ) + // InternalRos1Parser.g:1782:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionServerRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getActionServerAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_34); + + newLeafNode(this_BEGIN_3, grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getActionServerAccess().getTypeKeyword_4()); + + // InternalRos1Parser.g:1811:3: ( ( ruleEString ) ) + // InternalRos1Parser.g:1812:4: ( ruleEString ) + { + // InternalRos1Parser.g:1812:4: ( ruleEString ) + // InternalRos1Parser.g:1813:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getActionServerRule()); + } + + + newCompositeNode(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); + + pushFollow(FOLLOW_35); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:1827:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt35=2; + int LA35_0 = input.LA(1); + + if ( (LA35_0==Ns) ) { + alt35=1; + } + switch (alt35) { + case 1 : + // InternalRos1Parser.g:1828:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_36); + + newLeafNode(otherlv_6, grammarAccess.getActionServerAccess().getNsKeyword_6_0()); + + // InternalRos1Parser.g:1832:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos1Parser.g:1833:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos1Parser.g:1833:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos1Parser.g:1834:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_13); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionServerRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_8, grammarAccess.getActionServerAccess().getENDTerminalRuleCall_7()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleActionServer" + + + // $ANTLR start "entryRuleActionClient" + // InternalRos1Parser.g:1860:1: entryRuleActionClient returns [EObject current=null] : iv_ruleActionClient= ruleActionClient EOF ; + public final EObject entryRuleActionClient() throws RecognitionException { + EObject current = null; + + EObject iv_ruleActionClient = null; + + + try { + // InternalRos1Parser.g:1860:53: (iv_ruleActionClient= ruleActionClient EOF ) + // InternalRos1Parser.g:1861:2: iv_ruleActionClient= ruleActionClient EOF + { + newCompositeNode(grammarAccess.getActionClientRule()); + pushFollow(FOLLOW_1); + iv_ruleActionClient=ruleActionClient(); + + state._fsp--; + + current =iv_ruleActionClient; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleActionClient" + + + // $ANTLR start "ruleActionClient" + // InternalRos1Parser.g:1867:1: ruleActionClient returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ; + public final EObject ruleActionClient() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:1873:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) ) + // InternalRos1Parser.g:1874:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + { + // InternalRos1Parser.g:1874:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END ) + // InternalRos1Parser.g:1875:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END + { + // InternalRos1Parser.g:1875:3: () + // InternalRos1Parser.g:1876:4: + { + + current = forceCreateModelElement( + grammarAccess.getActionClientAccess().getActionClientAction_0(), + current); + + + } + + // InternalRos1Parser.g:1882:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos1Parser.g:1883:4: (lv_name_1_0= ruleEString ) + { + // InternalRos1Parser.g:1883:4: (lv_name_1_0= ruleEString ) + // InternalRos1Parser.g:1884:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionClientRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getActionClientAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_34); + + newLeafNode(this_BEGIN_3, grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getActionClientAccess().getTypeKeyword_4()); + + // InternalRos1Parser.g:1913:3: ( ( ruleEString ) ) + // InternalRos1Parser.g:1914:4: ( ruleEString ) + { + // InternalRos1Parser.g:1914:4: ( ruleEString ) + // InternalRos1Parser.g:1915:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getActionClientRule()); + } + + + newCompositeNode(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); + + pushFollow(FOLLOW_35); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:1929:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt36=2; + int LA36_0 = input.LA(1); + + if ( (LA36_0==Ns) ) { + alt36=1; + } + switch (alt36) { + case 1 : + // InternalRos1Parser.g:1930:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_36); + + newLeafNode(otherlv_6, grammarAccess.getActionClientAccess().getNsKeyword_6_0()); + + // InternalRos1Parser.g:1934:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos1Parser.g:1935:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos1Parser.g:1935:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos1Parser.g:1936:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_13); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionClientRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_8, grammarAccess.getActionClientAccess().getENDTerminalRuleCall_7()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleActionClient" + + + // $ANTLR start "entryRuleDependency" + // InternalRos1Parser.g:1962: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:1962:51: (iv_ruleDependency= ruleDependency EOF ) + // InternalRos1Parser.g:1963: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:1969: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:1975:2: ( (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) ) + // InternalRos1Parser.g:1976:2: (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) + { + // InternalRos1Parser.g:1976:2: (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) + int alt37=2; + int LA37_0 = input.LA(1); + + if ( (LA37_0==RULE_ID||LA37_0==RULE_STRING) ) { + alt37=1; + } + else if ( (LA37_0==ExternalDependency) ) { + alt37=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 37, 0, input); + + throw nvae; + } + switch (alt37) { + case 1 : + // InternalRos1Parser.g:1977: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:1986: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:1998: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:1998:58: (iv_rulePackageDependency= rulePackageDependency EOF ) + // InternalRos1Parser.g:1999: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:2005:1: rulePackageDependency returns [EObject current=null] : ( ( ruleEString ) ) ; + public final EObject rulePackageDependency() throws RecognitionException { + EObject current = null; + + + enterRule(); + + try { + // InternalRos1Parser.g:2011:2: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:2012:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:2012:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:2013:3: ( ruleEString ) + { + // InternalRos1Parser.g:2013:3: ( ruleEString ) + // InternalRos1Parser.g:2014: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:2031: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:2031:59: (iv_ruleExternalDependency= ruleExternalDependency EOF ) + // InternalRos1Parser.g:2032: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:2038: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:2044:2: ( ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) ) + // InternalRos1Parser.g:2045:2: ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) + { + // InternalRos1Parser.g:2045:2: ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) + // InternalRos1Parser.g:2046:3: () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) + { + // InternalRos1Parser.g:2046:3: () + // InternalRos1Parser.g:2047: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:2057:3: ( (lv_name_2_0= ruleEString ) ) + // InternalRos1Parser.g:2058:4: (lv_name_2_0= ruleEString ) + { + // InternalRos1Parser.g:2058:4: (lv_name_2_0= ruleEString ) + // InternalRos1Parser.g:2059: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.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleExternalDependency" + + + // $ANTLR start "entryRuleNamespace" + // InternalRos1Parser.g:2080:1: entryRuleNamespace returns [EObject current=null] : iv_ruleNamespace= ruleNamespace EOF ; + public final EObject entryRuleNamespace() throws RecognitionException { + EObject current = null; + + EObject iv_ruleNamespace = null; + + + try { + // InternalRos1Parser.g:2080:50: (iv_ruleNamespace= ruleNamespace EOF ) + // InternalRos1Parser.g:2081:2: iv_ruleNamespace= ruleNamespace EOF + { + newCompositeNode(grammarAccess.getNamespaceRule()); + pushFollow(FOLLOW_1); + iv_ruleNamespace=ruleNamespace(); + + state._fsp--; + + current =iv_ruleNamespace; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleNamespace" + + + // $ANTLR start "ruleNamespace" + // InternalRos1Parser.g:2087:1: ruleNamespace returns [EObject current=null] : (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) ; + public final EObject ruleNamespace() throws RecognitionException { + EObject current = null; + + EObject this_GlobalNamespace_0 = null; + + EObject this_RelativeNamespace_Impl_1 = null; + + EObject this_PrivateNamespace_2 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2093:2: ( (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) ) + // InternalRos1Parser.g:2094:2: (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) + { + // InternalRos1Parser.g:2094:2: (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) + int alt38=3; + switch ( input.LA(1) ) { + case GlobalNamespace: + { + alt38=1; + } + break; + case RelativeNamespace: + { + alt38=2; + } + break; + case PrivateNamespace: + { + alt38=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 38, 0, input); + + throw nvae; + } + + switch (alt38) { + case 1 : + // InternalRos1Parser.g:2095:3: this_GlobalNamespace_0= ruleGlobalNamespace + { + + newCompositeNode(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_GlobalNamespace_0=ruleGlobalNamespace(); + + state._fsp--; + + + current = this_GlobalNamespace_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos1Parser.g:2104:3: this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl + { + + newCompositeNode(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_RelativeNamespace_Impl_1=ruleRelativeNamespace_Impl(); + + state._fsp--; + + + current = this_RelativeNamespace_Impl_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalRos1Parser.g:2113:3: this_PrivateNamespace_2= rulePrivateNamespace + { + + newCompositeNode(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_PrivateNamespace_2=rulePrivateNamespace(); + + state._fsp--; + + + current = this_PrivateNamespace_2; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleNamespace" + + + // $ANTLR start "entryRuleGraphName" + // InternalRos1Parser.g:2125:1: entryRuleGraphName returns [String current=null] : iv_ruleGraphName= ruleGraphName EOF ; + public final String entryRuleGraphName() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleGraphName = null; + + + try { + // InternalRos1Parser.g:2125:49: (iv_ruleGraphName= ruleGraphName EOF ) + // InternalRos1Parser.g:2126:2: iv_ruleGraphName= ruleGraphName EOF + { + newCompositeNode(grammarAccess.getGraphNameRule()); + pushFollow(FOLLOW_1); + iv_ruleGraphName=ruleGraphName(); + + state._fsp--; + + current =iv_ruleGraphName.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleGraphName" + + + // $ANTLR start "ruleGraphName" + // InternalRos1Parser.g:2132:1: ruleGraphName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= GraphName ; + public final AntlrDatatypeRuleToken ruleGraphName() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:2138:2: (kw= GraphName ) + // InternalRos1Parser.g:2139:2: kw= GraphName + { + kw=(Token)match(input,GraphName,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleGraphName" + + + // $ANTLR start "entryRuleGlobalNamespace" + // InternalRos1Parser.g:2147:1: entryRuleGlobalNamespace returns [EObject current=null] : iv_ruleGlobalNamespace= ruleGlobalNamespace EOF ; + public final EObject entryRuleGlobalNamespace() throws RecognitionException { + EObject current = null; + + EObject iv_ruleGlobalNamespace = null; + + + try { + // InternalRos1Parser.g:2147:56: (iv_ruleGlobalNamespace= ruleGlobalNamespace EOF ) + // InternalRos1Parser.g:2148:2: iv_ruleGlobalNamespace= ruleGlobalNamespace EOF + { + newCompositeNode(grammarAccess.getGlobalNamespaceRule()); + pushFollow(FOLLOW_1); + iv_ruleGlobalNamespace=ruleGlobalNamespace(); + + state._fsp--; + + current =iv_ruleGlobalNamespace; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleGlobalNamespace" + + + // $ANTLR start "ruleGlobalNamespace" + // InternalRos1Parser.g:2154:1: ruleGlobalNamespace returns [EObject current=null] : ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ; + public final EObject ruleGlobalNamespace() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + AntlrDatatypeRuleToken lv_parts_3_0 = null; + + AntlrDatatypeRuleToken lv_parts_5_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2160:2: ( ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ) + // InternalRos1Parser.g:2161:2: ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + { + // InternalRos1Parser.g:2161:2: ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + // InternalRos1Parser.g:2162:3: () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + { + // InternalRos1Parser.g:2162:3: () + // InternalRos1Parser.g:2163:4: + { + + current = forceCreateModelElement( + grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,GlobalNamespace,FOLLOW_37); + + newLeafNode(otherlv_1, grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); + + // InternalRos1Parser.g:2173:3: (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + int alt40=2; + int LA40_0 = input.LA(1); + + if ( (LA40_0==LeftSquareBracket) ) { + alt40=1; + } + switch (alt40) { + case 1 : + // InternalRos1Parser.g:2174:4: otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket + { + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_38); + + newLeafNode(otherlv_2, grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + + // InternalRos1Parser.g:2178:4: ( (lv_parts_3_0= ruleGraphName ) ) + // InternalRos1Parser.g:2179:5: (lv_parts_3_0= ruleGraphName ) + { + // InternalRos1Parser.g:2179:5: (lv_parts_3_0= ruleGraphName ) + // InternalRos1Parser.g:2180:6: lv_parts_3_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_3_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getGlobalNamespaceRule()); + } + add( + current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:2197:4: (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* + loop39: + do { + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0==Comma) ) { + alt39=1; + } + + + switch (alt39) { + case 1 : + // InternalRos1Parser.g:2198:5: otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) + { + otherlv_4=(Token)match(input,Comma,FOLLOW_38); + + newLeafNode(otherlv_4, grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); + + // InternalRos1Parser.g:2202:5: ( (lv_parts_5_0= ruleGraphName ) ) + // InternalRos1Parser.g:2203:6: (lv_parts_5_0= ruleGraphName ) + { + // InternalRos1Parser.g:2203:6: (lv_parts_5_0= ruleGraphName ) + // InternalRos1Parser.g:2204:7: lv_parts_5_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_5_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getGlobalNamespaceRule()); + } + add( + current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop39; + } + } while (true); + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_6, grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleGlobalNamespace" + + + // $ANTLR start "entryRuleRelativeNamespace_Impl" + // InternalRos1Parser.g:2231:1: entryRuleRelativeNamespace_Impl returns [EObject current=null] : iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF ; + public final EObject entryRuleRelativeNamespace_Impl() throws RecognitionException { + EObject current = null; + + EObject iv_ruleRelativeNamespace_Impl = null; + + + try { + // InternalRos1Parser.g:2231:63: (iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF ) + // InternalRos1Parser.g:2232:2: iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF + { + newCompositeNode(grammarAccess.getRelativeNamespace_ImplRule()); + pushFollow(FOLLOW_1); + iv_ruleRelativeNamespace_Impl=ruleRelativeNamespace_Impl(); + + state._fsp--; + + current =iv_ruleRelativeNamespace_Impl; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleRelativeNamespace_Impl" + + + // $ANTLR start "ruleRelativeNamespace_Impl" + // InternalRos1Parser.g:2238:1: ruleRelativeNamespace_Impl returns [EObject current=null] : ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ; + public final EObject ruleRelativeNamespace_Impl() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + AntlrDatatypeRuleToken lv_parts_3_0 = null; + + AntlrDatatypeRuleToken lv_parts_5_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2244:2: ( ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ) + // InternalRos1Parser.g:2245:2: ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + { + // InternalRos1Parser.g:2245:2: ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + // InternalRos1Parser.g:2246:3: () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + { + // InternalRos1Parser.g:2246:3: () + // InternalRos1Parser.g:2247:4: + { + + current = forceCreateModelElement( + grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,RelativeNamespace,FOLLOW_37); + + newLeafNode(otherlv_1, grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); + + // InternalRos1Parser.g:2257:3: (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + int alt42=2; + int LA42_0 = input.LA(1); + + if ( (LA42_0==LeftSquareBracket) ) { + alt42=1; + } + switch (alt42) { + case 1 : + // InternalRos1Parser.g:2258:4: otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket + { + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_38); + + newLeafNode(otherlv_2, grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); + + // InternalRos1Parser.g:2262:4: ( (lv_parts_3_0= ruleGraphName ) ) + // InternalRos1Parser.g:2263:5: (lv_parts_3_0= ruleGraphName ) + { + // InternalRos1Parser.g:2263:5: (lv_parts_3_0= ruleGraphName ) + // InternalRos1Parser.g:2264:6: lv_parts_3_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_3_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getRelativeNamespace_ImplRule()); + } + add( + current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:2281:4: (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* + loop41: + do { + int alt41=2; + int LA41_0 = input.LA(1); + + if ( (LA41_0==Comma) ) { + alt41=1; + } + + + switch (alt41) { + case 1 : + // InternalRos1Parser.g:2282:5: otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) + { + otherlv_4=(Token)match(input,Comma,FOLLOW_38); + + newLeafNode(otherlv_4, grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); + + // InternalRos1Parser.g:2286:5: ( (lv_parts_5_0= ruleGraphName ) ) + // InternalRos1Parser.g:2287:6: (lv_parts_5_0= ruleGraphName ) + { + // InternalRos1Parser.g:2287:6: (lv_parts_5_0= ruleGraphName ) + // InternalRos1Parser.g:2288:7: lv_parts_5_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_5_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getRelativeNamespace_ImplRule()); + } + add( + current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop41; + } + } while (true); + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_6, grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleRelativeNamespace_Impl" + + + // $ANTLR start "entryRulePrivateNamespace" + // InternalRos1Parser.g:2315:1: entryRulePrivateNamespace returns [EObject current=null] : iv_rulePrivateNamespace= rulePrivateNamespace EOF ; + public final EObject entryRulePrivateNamespace() throws RecognitionException { + EObject current = null; + + EObject iv_rulePrivateNamespace = null; + + + try { + // InternalRos1Parser.g:2315:57: (iv_rulePrivateNamespace= rulePrivateNamespace EOF ) + // InternalRos1Parser.g:2316:2: iv_rulePrivateNamespace= rulePrivateNamespace EOF + { + newCompositeNode(grammarAccess.getPrivateNamespaceRule()); + pushFollow(FOLLOW_1); + iv_rulePrivateNamespace=rulePrivateNamespace(); + + state._fsp--; + + current =iv_rulePrivateNamespace; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePrivateNamespace" + + + // $ANTLR start "rulePrivateNamespace" + // InternalRos1Parser.g:2322:1: rulePrivateNamespace returns [EObject current=null] : ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ; + public final EObject rulePrivateNamespace() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + AntlrDatatypeRuleToken lv_parts_3_0 = null; + + AntlrDatatypeRuleToken lv_parts_5_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2328:2: ( ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ) + // InternalRos1Parser.g:2329:2: ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + { + // InternalRos1Parser.g:2329:2: ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + // InternalRos1Parser.g:2330:3: () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + { + // InternalRos1Parser.g:2330:3: () + // InternalRos1Parser.g:2331:4: + { + + current = forceCreateModelElement( + grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,PrivateNamespace,FOLLOW_37); + + newLeafNode(otherlv_1, grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); + + // InternalRos1Parser.g:2341:3: (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + int alt44=2; + int LA44_0 = input.LA(1); + + if ( (LA44_0==LeftSquareBracket) ) { + alt44=1; + } + switch (alt44) { + case 1 : + // InternalRos1Parser.g:2342:4: otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket + { + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_38); + + newLeafNode(otherlv_2, grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + + // InternalRos1Parser.g:2346:4: ( (lv_parts_3_0= ruleGraphName ) ) + // InternalRos1Parser.g:2347:5: (lv_parts_3_0= ruleGraphName ) + { + // InternalRos1Parser.g:2347:5: (lv_parts_3_0= ruleGraphName ) + // InternalRos1Parser.g:2348:6: lv_parts_3_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_3_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPrivateNamespaceRule()); + } + add( + current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:2365:4: (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* + loop43: + do { + int alt43=2; + int LA43_0 = input.LA(1); + + if ( (LA43_0==Comma) ) { + alt43=1; + } + + + switch (alt43) { + case 1 : + // InternalRos1Parser.g:2366:5: otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) + { + otherlv_4=(Token)match(input,Comma,FOLLOW_38); + + newLeafNode(otherlv_4, grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); + + // InternalRos1Parser.g:2370:5: ( (lv_parts_5_0= ruleGraphName ) ) + // InternalRos1Parser.g:2371:6: (lv_parts_5_0= ruleGraphName ) + { + // InternalRos1Parser.g:2371:6: (lv_parts_5_0= ruleGraphName ) + // InternalRos1Parser.g:2372:7: lv_parts_5_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_5_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPrivateNamespaceRule()); + } + add( + current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop43; + } + } while (true); + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_6, grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePrivateNamespace" + + + // $ANTLR start "entryRuleParameter" + // InternalRos1Parser.g:2399: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:2399:50: (iv_ruleParameter= ruleParameter EOF ) + // InternalRos1Parser.g:2400: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:2406:1: ruleParameter returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END otherlv_9= RightCurlyBracket ) ; + public final EObject ruleParameter() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token this_END_8=null; + Token otherlv_9=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_type_5_0 = null; + + EObject lv_namespace_7_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2412:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END otherlv_9= RightCurlyBracket ) ) + // InternalRos1Parser.g:2413:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END otherlv_9= RightCurlyBracket ) + { + // InternalRos1Parser.g:2413:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END otherlv_9= RightCurlyBracket ) + // InternalRos1Parser.g:2414:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? this_END_8= RULE_END otherlv_9= RightCurlyBracket + { + // InternalRos1Parser.g:2414:3: () + // InternalRos1Parser.g:2415:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterAccess().getParameterAction_0(), + current); + + + } + + // InternalRos1Parser.g:2421:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos1Parser.g:2422:4: (lv_name_1_0= ruleEString ) + { + // InternalRos1Parser.g:2422:4: (lv_name_1_0= ruleEString ) + // InternalRos1Parser.g:2423: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.ros.Ros.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_39); + + newLeafNode(this_BEGIN_3, grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type,FOLLOW_40); + + newLeafNode(otherlv_4, grammarAccess.getParameterAccess().getTypeKeyword_4()); + + // InternalRos1Parser.g:2452:3: ( (lv_type_5_0= ruleParameterType ) ) + // InternalRos1Parser.g:2453:4: (lv_type_5_0= ruleParameterType ) + { + // InternalRos1Parser.g:2453:4: (lv_type_5_0= ruleParameterType ) + // InternalRos1Parser.g:2454:5: lv_type_5_0= ruleParameterType + { + + newCompositeNode(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); + + pushFollow(FOLLOW_35); + lv_type_5_0=ruleParameterType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + current, + "type", + lv_type_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:2471:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt45=2; + int LA45_0 = input.LA(1); + + if ( (LA45_0==Ns) ) { + alt45=1; + } + switch (alt45) { + case 1 : + // InternalRos1Parser.g:2472:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_36); + + newLeafNode(otherlv_6, grammarAccess.getParameterAccess().getNsKeyword_6_0()); + + // InternalRos1Parser.g:2476:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos1Parser.g:2477:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos1Parser.g:2477:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos1Parser.g:2478:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_13); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_8=(Token)match(input,RULE_END,FOLLOW_41); + + newLeafNode(this_END_8, grammarAccess.getParameterAccess().getENDTerminalRuleCall_7()); + + otherlv_9=(Token)match(input,RightCurlyBracket,FOLLOW_2); + + newLeafNode(otherlv_9, grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_8()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameter" + + + // $ANTLR start "entryRuleParameterType" + // InternalRos1Parser.g:2508:1: entryRuleParameterType returns [EObject current=null] : iv_ruleParameterType= ruleParameterType EOF ; + public final EObject entryRuleParameterType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterType = null; + + + try { + // InternalRos1Parser.g:2508:54: (iv_ruleParameterType= ruleParameterType EOF ) + // InternalRos1Parser.g:2509:2: iv_ruleParameterType= ruleParameterType EOF + { + newCompositeNode(grammarAccess.getParameterTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterType=ruleParameterType(); + + state._fsp--; + + current =iv_ruleParameterType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterType" + + + // $ANTLR start "ruleParameterType" + // InternalRos1Parser.g:2515:1: ruleParameterType returns [EObject current=null] : (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) ; + public final EObject ruleParameterType() throws RecognitionException { + EObject current = null; + + EObject this_ParameterListType_0 = null; + + EObject this_ParameterStructType_1 = null; + + EObject this_ParameterIntegerType_2 = null; + + EObject this_ParameterStringType_3 = null; + + EObject this_ParameterDoubleType_4 = null; + + EObject this_ParameterBooleanType_5 = null; + + EObject this_ParameterBase64Type_6 = null; + + EObject this_ParameterArrayType_7 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2521:2: ( (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) ) + // InternalRos1Parser.g:2522:2: (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) + { + // InternalRos1Parser.g:2522:2: (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) + int alt46=8; + switch ( input.LA(1) ) { + case List: + { + alt46=1; + } + break; + case Struct: + { + alt46=2; + } + break; + case Integer: + { + alt46=3; + } + break; + case String: + { + alt46=4; + } + break; + case Double: + { + alt46=5; + } + break; + case Boolean: + { + alt46=6; + } + break; + case Base64: + { + alt46=7; + } + break; + case Array: + { + alt46=8; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 46, 0, input); + + throw nvae; + } + + switch (alt46) { + case 1 : + // InternalRos1Parser.g:2523:3: this_ParameterListType_0= ruleParameterListType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_ParameterListType_0=ruleParameterListType(); + + state._fsp--; + + + current = this_ParameterListType_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos1Parser.g:2532:3: this_ParameterStructType_1= ruleParameterStructType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_ParameterStructType_1=ruleParameterStructType(); + + state._fsp--; + + + current = this_ParameterStructType_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalRos1Parser.g:2541:3: this_ParameterIntegerType_2= ruleParameterIntegerType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_ParameterIntegerType_2=ruleParameterIntegerType(); + + state._fsp--; + + + current = this_ParameterIntegerType_2; + afterParserOrEnumRuleCall(); + + + } + break; + case 4 : + // InternalRos1Parser.g:2550:3: this_ParameterStringType_3= ruleParameterStringType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); + + pushFollow(FOLLOW_2); + this_ParameterStringType_3=ruleParameterStringType(); + + state._fsp--; + + + current = this_ParameterStringType_3; + afterParserOrEnumRuleCall(); + + + } + break; + case 5 : + // InternalRos1Parser.g:2559:3: this_ParameterDoubleType_4= ruleParameterDoubleType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); + + pushFollow(FOLLOW_2); + this_ParameterDoubleType_4=ruleParameterDoubleType(); + + state._fsp--; + + + current = this_ParameterDoubleType_4; + afterParserOrEnumRuleCall(); + + + } + break; + case 6 : + // InternalRos1Parser.g:2568:3: this_ParameterBooleanType_5= ruleParameterBooleanType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); + + pushFollow(FOLLOW_2); + this_ParameterBooleanType_5=ruleParameterBooleanType(); + + state._fsp--; + + + current = this_ParameterBooleanType_5; + afterParserOrEnumRuleCall(); + + + } + break; + case 7 : + // InternalRos1Parser.g:2577:3: this_ParameterBase64Type_6= ruleParameterBase64Type + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); + + pushFollow(FOLLOW_2); + this_ParameterBase64Type_6=ruleParameterBase64Type(); + + state._fsp--; + + + current = this_ParameterBase64Type_6; + afterParserOrEnumRuleCall(); + + + } + break; + case 8 : + // InternalRos1Parser.g:2586:3: this_ParameterArrayType_7= ruleParameterArrayType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); + + pushFollow(FOLLOW_2); + this_ParameterArrayType_7=ruleParameterArrayType(); + + state._fsp--; + + + current = this_ParameterArrayType_7; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterType" + + + // $ANTLR start "entryRuleParameterValue" + // InternalRos1Parser.g:2598:1: entryRuleParameterValue returns [EObject current=null] : iv_ruleParameterValue= ruleParameterValue EOF ; + public final EObject entryRuleParameterValue() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterValue = null; + + + try { + // InternalRos1Parser.g:2598:55: (iv_ruleParameterValue= ruleParameterValue EOF ) + // InternalRos1Parser.g:2599:2: iv_ruleParameterValue= ruleParameterValue EOF + { + newCompositeNode(grammarAccess.getParameterValueRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterValue=ruleParameterValue(); + + state._fsp--; + + current =iv_ruleParameterValue; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterValue" + + + // $ANTLR start "ruleParameterValue" + // InternalRos1Parser.g:2605:1: ruleParameterValue returns [EObject current=null] : (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) ; + public final EObject ruleParameterValue() throws RecognitionException { + EObject current = null; + + EObject this_ParameterString_0 = null; + + EObject this_ParameterBase64_1 = null; + + EObject this_ParameterInteger_2 = null; + + EObject this_ParameterDouble_3 = null; + + EObject this_ParameterBoolean_4 = null; + + EObject this_ParameterList_5 = null; + + EObject this_ParameterStruct_6 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2611:2: ( (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) ) + // InternalRos1Parser.g:2612:2: (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) + { + // InternalRos1Parser.g:2612:2: (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) + int alt47=7; + switch ( input.LA(1) ) { + case RULE_ID: + case RULE_STRING: + { + alt47=1; + } + break; + case RULE_BINARY: + { + alt47=2; + } + break; + case RULE_DECINT: + { + alt47=3; + } + break; + case RULE_DOUBLE: + { + alt47=4; + } + break; + case RULE_BOOLEAN: + { + alt47=5; + } + break; + case LeftSquareBracket: + { + int LA47_6 = input.LA(2); + + if ( (LA47_6==ParameterStructMember) ) { + alt47=7; + } + else if ( (LA47_6==Comma||(LA47_6>=LeftSquareBracket && LA47_6<=RightSquareBracket)||LA47_6==RULE_ID||LA47_6==RULE_STRING||(LA47_6>=RULE_BINARY && LA47_6<=RULE_DOUBLE)) ) { + alt47=6; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 47, 6, input); + + throw nvae; + } + } + break; + case EOF: + case Comma: + case RightSquareBracket: + case RULE_END: + { + alt47=7; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 47, 0, input); + + throw nvae; + } + + switch (alt47) { + case 1 : + // InternalRos1Parser.g:2613:3: this_ParameterString_0= ruleParameterString + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_ParameterString_0=ruleParameterString(); + + state._fsp--; + + + current = this_ParameterString_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos1Parser.g:2622:3: this_ParameterBase64_1= ruleParameterBase64 + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_ParameterBase64_1=ruleParameterBase64(); + + state._fsp--; + + + current = this_ParameterBase64_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalRos1Parser.g:2631:3: this_ParameterInteger_2= ruleParameterInteger + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_ParameterInteger_2=ruleParameterInteger(); + + state._fsp--; + + + current = this_ParameterInteger_2; + afterParserOrEnumRuleCall(); + + + } + break; + case 4 : + // InternalRos1Parser.g:2640:3: this_ParameterDouble_3= ruleParameterDouble + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); + + pushFollow(FOLLOW_2); + this_ParameterDouble_3=ruleParameterDouble(); + + state._fsp--; + + + current = this_ParameterDouble_3; + afterParserOrEnumRuleCall(); + + + } + break; + case 5 : + // InternalRos1Parser.g:2649:3: this_ParameterBoolean_4= ruleParameterBoolean + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); + + pushFollow(FOLLOW_2); + this_ParameterBoolean_4=ruleParameterBoolean(); + + state._fsp--; + + + current = this_ParameterBoolean_4; + afterParserOrEnumRuleCall(); + + + } + break; + case 6 : + // InternalRos1Parser.g:2658:3: this_ParameterList_5= ruleParameterList + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); + + pushFollow(FOLLOW_2); + this_ParameterList_5=ruleParameterList(); + + state._fsp--; + + + current = this_ParameterList_5; + afterParserOrEnumRuleCall(); + + + } + break; + case 7 : + // InternalRos1Parser.g:2667:3: this_ParameterStruct_6= ruleParameterStruct + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); + + pushFollow(FOLLOW_2); + this_ParameterStruct_6=ruleParameterStruct(); + + state._fsp--; + + + current = this_ParameterStruct_6; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterValue" + + + // $ANTLR start "entryRuleParameterListType" + // InternalRos1Parser.g:2679:1: entryRuleParameterListType returns [EObject current=null] : iv_ruleParameterListType= ruleParameterListType EOF ; + public final EObject entryRuleParameterListType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterListType = null; + + + try { + // InternalRos1Parser.g:2679:58: (iv_ruleParameterListType= ruleParameterListType EOF ) + // InternalRos1Parser.g:2680:2: iv_ruleParameterListType= ruleParameterListType EOF + { + newCompositeNode(grammarAccess.getParameterListTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterListType=ruleParameterListType(); + + state._fsp--; + + current =iv_ruleParameterListType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterListType" + + + // $ANTLR start "ruleParameterListType" + // InternalRos1Parser.g:2686:1: ruleParameterListType returns [EObject current=null] : ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) ; + public final EObject ruleParameterListType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_sequence_3_0 = null; + + EObject lv_sequence_5_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2692:2: ( ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) ) + // InternalRos1Parser.g:2693:2: ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) + { + // InternalRos1Parser.g:2693:2: ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) + // InternalRos1Parser.g:2694:3: () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket + { + // InternalRos1Parser.g:2694:3: () + // InternalRos1Parser.g:2695:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,List,FOLLOW_10); + + newLeafNode(otherlv_1, grammarAccess.getParameterListTypeAccess().getListKeyword_1()); + + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_40); + + newLeafNode(otherlv_2, grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); + + // InternalRos1Parser.g:2709:3: ( (lv_sequence_3_0= ruleParameterType ) ) + // InternalRos1Parser.g:2710:4: (lv_sequence_3_0= ruleParameterType ) + { + // InternalRos1Parser.g:2710:4: (lv_sequence_3_0= ruleParameterType ) + // InternalRos1Parser.g:2711:5: lv_sequence_3_0= ruleParameterType + { + + newCompositeNode(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); + + pushFollow(FOLLOW_12); + lv_sequence_3_0=ruleParameterType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterListTypeRule()); + } + add( + current, + "sequence", + lv_sequence_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:2728:3: (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* + loop48: + do { + int alt48=2; + int LA48_0 = input.LA(1); + + if ( (LA48_0==Comma) ) { + alt48=1; + } + + + switch (alt48) { + case 1 : + // InternalRos1Parser.g:2729:4: otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) + { + otherlv_4=(Token)match(input,Comma,FOLLOW_40); + + newLeafNode(otherlv_4, grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); + + // InternalRos1Parser.g:2733:4: ( (lv_sequence_5_0= ruleParameterType ) ) + // InternalRos1Parser.g:2734:5: (lv_sequence_5_0= ruleParameterType ) + { + // InternalRos1Parser.g:2734:5: (lv_sequence_5_0= ruleParameterType ) + // InternalRos1Parser.g:2735:6: lv_sequence_5_0= ruleParameterType + { + + newCompositeNode(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); + + pushFollow(FOLLOW_12); + lv_sequence_5_0=ruleParameterType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterListTypeRule()); + } + add( + current, + "sequence", + lv_sequence_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop48; + } + } while (true); + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_6, grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterListType" + + + // $ANTLR start "entryRuleParameterStructType" + // InternalRos1Parser.g:2761:1: entryRuleParameterStructType returns [EObject current=null] : iv_ruleParameterStructType= ruleParameterStructType EOF ; + public final EObject entryRuleParameterStructType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterStructType = null; + + + try { + // InternalRos1Parser.g:2761:60: (iv_ruleParameterStructType= ruleParameterStructType EOF ) + // InternalRos1Parser.g:2762:2: iv_ruleParameterStructType= ruleParameterStructType EOF + { + newCompositeNode(grammarAccess.getParameterStructTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterStructType=ruleParameterStructType(); + + state._fsp--; + + current =iv_ruleParameterStructType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterStructType" + + + // $ANTLR start "ruleParameterStructType" + // InternalRos1Parser.g:2768:1: ruleParameterStructType returns [EObject current=null] : ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) ; + public final EObject ruleParameterStructType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_parameterstructypetmember_3_0 = null; + + EObject lv_parameterstructypetmember_5_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2774:2: ( ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) ) + // InternalRos1Parser.g:2775:2: ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) + { + // InternalRos1Parser.g:2775:2: ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) + // InternalRos1Parser.g:2776:3: () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket + { + // InternalRos1Parser.g:2776:3: () + // InternalRos1Parser.g:2777:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Struct,FOLLOW_10); + + newLeafNode(otherlv_1, grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); + + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_6); + + newLeafNode(otherlv_2, grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); + + // InternalRos1Parser.g:2791:3: ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) + // InternalRos1Parser.g:2792:4: (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) + { + // InternalRos1Parser.g:2792:4: (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) + // InternalRos1Parser.g:2793:5: lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember + { + + newCompositeNode(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); + + pushFollow(FOLLOW_12); + lv_parameterstructypetmember_3_0=ruleParameterStructTypeMember(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructTypeRule()); + } + add( + current, + "parameterstructypetmember", + lv_parameterstructypetmember_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructTypeMember"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:2810:3: (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* + loop49: + do { + int alt49=2; + int LA49_0 = input.LA(1); + + if ( (LA49_0==Comma) ) { + alt49=1; + } + + + switch (alt49) { + case 1 : + // InternalRos1Parser.g:2811:4: otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) + { + otherlv_4=(Token)match(input,Comma,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); + + // InternalRos1Parser.g:2815:4: ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) + // InternalRos1Parser.g:2816:5: (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) + { + // InternalRos1Parser.g:2816:5: (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) + // InternalRos1Parser.g:2817:6: lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember + { + + newCompositeNode(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); + + pushFollow(FOLLOW_12); + lv_parameterstructypetmember_5_0=ruleParameterStructTypeMember(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructTypeRule()); + } + add( + current, + "parameterstructypetmember", + lv_parameterstructypetmember_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructTypeMember"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop49; + } + } while (true); + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_6, grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterStructType" + + + // $ANTLR start "entryRuleParameterIntegerType" + // InternalRos1Parser.g:2843:1: entryRuleParameterIntegerType returns [EObject current=null] : iv_ruleParameterIntegerType= ruleParameterIntegerType EOF ; + public final EObject entryRuleParameterIntegerType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterIntegerType = null; + + + try { + // InternalRos1Parser.g:2843:61: (iv_ruleParameterIntegerType= ruleParameterIntegerType EOF ) + // InternalRos1Parser.g:2844:2: iv_ruleParameterIntegerType= ruleParameterIntegerType EOF + { + newCompositeNode(grammarAccess.getParameterIntegerTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterIntegerType=ruleParameterIntegerType(); + + state._fsp--; + + current =iv_ruleParameterIntegerType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterIntegerType" + + + // $ANTLR start "ruleParameterIntegerType" + // InternalRos1Parser.g:2850:1: ruleParameterIntegerType returns [EObject current=null] : ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) ; + public final EObject ruleParameterIntegerType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + EObject lv_default_3_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2856:2: ( ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) ) + // InternalRos1Parser.g:2857:2: ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) + { + // InternalRos1Parser.g:2857:2: ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) + // InternalRos1Parser.g:2858:3: () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? + { + // InternalRos1Parser.g:2858:3: () + // InternalRos1Parser.g:2859:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Integer,FOLLOW_42); + + newLeafNode(otherlv_1, grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); + + // InternalRos1Parser.g:2869:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? + int alt50=2; + int LA50_0 = input.LA(1); + + if ( (LA50_0==Default) ) { + int LA50_1 = input.LA(2); + + if ( (LA50_1==RULE_DECINT) ) { + alt50=1; + } + } + switch (alt50) { + case 1 : + // InternalRos1Parser.g:2870:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) + { + otherlv_2=(Token)match(input,Default,FOLLOW_43); + + newLeafNode(otherlv_2, grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); + + // InternalRos1Parser.g:2874:4: ( (lv_default_3_0= ruleParameterInteger ) ) + // InternalRos1Parser.g:2875:5: (lv_default_3_0= ruleParameterInteger ) + { + // InternalRos1Parser.g:2875:5: (lv_default_3_0= ruleParameterInteger ) + // InternalRos1Parser.g:2876:6: lv_default_3_0= ruleParameterInteger + { + + newCompositeNode(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_default_3_0=ruleParameterInteger(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterIntegerTypeRule()); + } + set( + current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterInteger"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterIntegerType" + + + // $ANTLR start "entryRuleParameterStringType" + // InternalRos1Parser.g:2898:1: entryRuleParameterStringType returns [EObject current=null] : iv_ruleParameterStringType= ruleParameterStringType EOF ; + public final EObject entryRuleParameterStringType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterStringType = null; + + + try { + // InternalRos1Parser.g:2898:60: (iv_ruleParameterStringType= ruleParameterStringType EOF ) + // InternalRos1Parser.g:2899:2: iv_ruleParameterStringType= ruleParameterStringType EOF + { + newCompositeNode(grammarAccess.getParameterStringTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterStringType=ruleParameterStringType(); + + state._fsp--; + + current =iv_ruleParameterStringType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterStringType" + + + // $ANTLR start "ruleParameterStringType" + // InternalRos1Parser.g:2905:1: ruleParameterStringType returns [EObject current=null] : ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) ; + public final EObject ruleParameterStringType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + EObject lv_default_3_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2911:2: ( ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) ) + // InternalRos1Parser.g:2912:2: ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) + { + // InternalRos1Parser.g:2912:2: ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) + // InternalRos1Parser.g:2913:3: () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? + { + // InternalRos1Parser.g:2913:3: () + // InternalRos1Parser.g:2914:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,String,FOLLOW_42); + + newLeafNode(otherlv_1, grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); + + // InternalRos1Parser.g:2924:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? + int alt51=2; + int LA51_0 = input.LA(1); + + if ( (LA51_0==Default) ) { + int LA51_1 = input.LA(2); + + if ( (LA51_1==RULE_ID||LA51_1==RULE_STRING) ) { + alt51=1; + } + } + switch (alt51) { + case 1 : + // InternalRos1Parser.g:2925:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) + { + otherlv_2=(Token)match(input,Default,FOLLOW_6); + + newLeafNode(otherlv_2, grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); + + // InternalRos1Parser.g:2929:4: ( (lv_default_3_0= ruleParameterString ) ) + // InternalRos1Parser.g:2930:5: (lv_default_3_0= ruleParameterString ) + { + // InternalRos1Parser.g:2930:5: (lv_default_3_0= ruleParameterString ) + // InternalRos1Parser.g:2931:6: lv_default_3_0= ruleParameterString + { + + newCompositeNode(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_default_3_0=ruleParameterString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStringTypeRule()); + } + set( + current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterStringType" + + + // $ANTLR start "entryRuleParameterDoubleType" + // InternalRos1Parser.g:2953:1: entryRuleParameterDoubleType returns [EObject current=null] : iv_ruleParameterDoubleType= ruleParameterDoubleType EOF ; + public final EObject entryRuleParameterDoubleType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterDoubleType = null; + + + try { + // InternalRos1Parser.g:2953:60: (iv_ruleParameterDoubleType= ruleParameterDoubleType EOF ) + // InternalRos1Parser.g:2954:2: iv_ruleParameterDoubleType= ruleParameterDoubleType EOF + { + newCompositeNode(grammarAccess.getParameterDoubleTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterDoubleType=ruleParameterDoubleType(); + + state._fsp--; + + current =iv_ruleParameterDoubleType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterDoubleType" + + + // $ANTLR start "ruleParameterDoubleType" + // InternalRos1Parser.g:2960:1: ruleParameterDoubleType returns [EObject current=null] : ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) ; + public final EObject ruleParameterDoubleType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + EObject lv_default_3_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:2966:2: ( ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) ) + // InternalRos1Parser.g:2967:2: ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) + { + // InternalRos1Parser.g:2967:2: ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) + // InternalRos1Parser.g:2968:3: () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? + { + // InternalRos1Parser.g:2968:3: () + // InternalRos1Parser.g:2969:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Double,FOLLOW_42); + + newLeafNode(otherlv_1, grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); + + // InternalRos1Parser.g:2979:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? + int alt52=2; + int LA52_0 = input.LA(1); + + if ( (LA52_0==Default) ) { + int LA52_1 = input.LA(2); + + if ( (LA52_1==RULE_DOUBLE) ) { + alt52=1; + } + } + switch (alt52) { + case 1 : + // InternalRos1Parser.g:2980:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) + { + otherlv_2=(Token)match(input,Default,FOLLOW_44); + + newLeafNode(otherlv_2, grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); + + // InternalRos1Parser.g:2984:4: ( (lv_default_3_0= ruleParameterDouble ) ) + // InternalRos1Parser.g:2985:5: (lv_default_3_0= ruleParameterDouble ) + { + // InternalRos1Parser.g:2985:5: (lv_default_3_0= ruleParameterDouble ) + // InternalRos1Parser.g:2986:6: lv_default_3_0= ruleParameterDouble + { + + newCompositeNode(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_default_3_0=ruleParameterDouble(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterDoubleTypeRule()); + } + set( + current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterDouble"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterDoubleType" + + + // $ANTLR start "entryRuleParameterBooleanType" + // InternalRos1Parser.g:3008:1: entryRuleParameterBooleanType returns [EObject current=null] : iv_ruleParameterBooleanType= ruleParameterBooleanType EOF ; + public final EObject entryRuleParameterBooleanType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterBooleanType = null; + + + try { + // InternalRos1Parser.g:3008:61: (iv_ruleParameterBooleanType= ruleParameterBooleanType EOF ) + // InternalRos1Parser.g:3009:2: iv_ruleParameterBooleanType= ruleParameterBooleanType EOF + { + newCompositeNode(grammarAccess.getParameterBooleanTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterBooleanType=ruleParameterBooleanType(); + + state._fsp--; + + current =iv_ruleParameterBooleanType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterBooleanType" + + + // $ANTLR start "ruleParameterBooleanType" + // InternalRos1Parser.g:3015:1: ruleParameterBooleanType returns [EObject current=null] : ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) ; + public final EObject ruleParameterBooleanType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + EObject lv_default_3_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3021:2: ( ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) ) + // InternalRos1Parser.g:3022:2: ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) + { + // InternalRos1Parser.g:3022:2: ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) + // InternalRos1Parser.g:3023:3: () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? + { + // InternalRos1Parser.g:3023:3: () + // InternalRos1Parser.g:3024:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Boolean,FOLLOW_42); + + newLeafNode(otherlv_1, grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); + + // InternalRos1Parser.g:3034:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? + int alt53=2; + int LA53_0 = input.LA(1); + + if ( (LA53_0==Default) ) { + int LA53_1 = input.LA(2); + + if ( (LA53_1==RULE_BOOLEAN) ) { + alt53=1; + } + } + switch (alt53) { + case 1 : + // InternalRos1Parser.g:3035:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) + { + otherlv_2=(Token)match(input,Default,FOLLOW_45); + + newLeafNode(otherlv_2, grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); + + // InternalRos1Parser.g:3039:4: ( (lv_default_3_0= ruleParameterBoolean ) ) + // InternalRos1Parser.g:3040:5: (lv_default_3_0= ruleParameterBoolean ) + { + // InternalRos1Parser.g:3040:5: (lv_default_3_0= ruleParameterBoolean ) + // InternalRos1Parser.g:3041:6: lv_default_3_0= ruleParameterBoolean + { + + newCompositeNode(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_default_3_0=ruleParameterBoolean(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterBooleanTypeRule()); + } + set( + current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterBoolean"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterBooleanType" + + + // $ANTLR start "entryRuleParameterBase64Type" + // InternalRos1Parser.g:3063:1: entryRuleParameterBase64Type returns [EObject current=null] : iv_ruleParameterBase64Type= ruleParameterBase64Type EOF ; + public final EObject entryRuleParameterBase64Type() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterBase64Type = null; + + + try { + // InternalRos1Parser.g:3063:60: (iv_ruleParameterBase64Type= ruleParameterBase64Type EOF ) + // InternalRos1Parser.g:3064:2: iv_ruleParameterBase64Type= ruleParameterBase64Type EOF + { + newCompositeNode(grammarAccess.getParameterBase64TypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterBase64Type=ruleParameterBase64Type(); + + state._fsp--; + + current =iv_ruleParameterBase64Type; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterBase64Type" + + + // $ANTLR start "ruleParameterBase64Type" + // InternalRos1Parser.g:3070:1: ruleParameterBase64Type returns [EObject current=null] : ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) ; + public final EObject ruleParameterBase64Type() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + EObject lv_default_3_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3076:2: ( ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) ) + // InternalRos1Parser.g:3077:2: ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) + { + // InternalRos1Parser.g:3077:2: ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) + // InternalRos1Parser.g:3078:3: () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? + { + // InternalRos1Parser.g:3078:3: () + // InternalRos1Parser.g:3079:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Base64,FOLLOW_42); + + newLeafNode(otherlv_1, grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); + + // InternalRos1Parser.g:3089:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? + int alt54=2; + int LA54_0 = input.LA(1); + + if ( (LA54_0==Default) ) { + int LA54_1 = input.LA(2); + + if ( (LA54_1==RULE_BINARY) ) { + alt54=1; + } + } + switch (alt54) { + case 1 : + // InternalRos1Parser.g:3090:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) + { + otherlv_2=(Token)match(input,Default,FOLLOW_46); + + newLeafNode(otherlv_2, grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); + + // InternalRos1Parser.g:3094:4: ( (lv_default_3_0= ruleParameterBase64 ) ) + // InternalRos1Parser.g:3095:5: (lv_default_3_0= ruleParameterBase64 ) + { + // InternalRos1Parser.g:3095:5: (lv_default_3_0= ruleParameterBase64 ) + // InternalRos1Parser.g:3096:6: lv_default_3_0= ruleParameterBase64 + { + + newCompositeNode(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_default_3_0=ruleParameterBase64(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterBase64TypeRule()); + } + set( + current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterBase64"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterBase64Type" + + + // $ANTLR start "entryRuleParameterArrayType" + // InternalRos1Parser.g:3118:1: entryRuleParameterArrayType returns [EObject current=null] : iv_ruleParameterArrayType= ruleParameterArrayType EOF ; + public final EObject entryRuleParameterArrayType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterArrayType = null; + + + try { + // InternalRos1Parser.g:3118:59: (iv_ruleParameterArrayType= ruleParameterArrayType EOF ) + // InternalRos1Parser.g:3119:2: iv_ruleParameterArrayType= ruleParameterArrayType EOF + { + newCompositeNode(grammarAccess.getParameterArrayTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterArrayType=ruleParameterArrayType(); + + state._fsp--; + + current =iv_ruleParameterArrayType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterArrayType" + + + // $ANTLR start "ruleParameterArrayType" + // InternalRos1Parser.g:3125:1: ruleParameterArrayType returns [EObject current=null] : (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) ; + public final EObject ruleParameterArrayType() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token this_BEGIN_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token this_END_6=null; + EObject lv_type_3_0 = null; + + EObject lv_default_5_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3131:2: ( (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) ) + // InternalRos1Parser.g:3132:2: (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) + { + // InternalRos1Parser.g:3132:2: (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) + // InternalRos1Parser.g:3133:3: otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END + { + otherlv_0=(Token)match(input,Array,FOLLOW_4); + + newLeafNode(otherlv_0, grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); + + this_BEGIN_1=(Token)match(input,RULE_BEGIN,FOLLOW_39); + + newLeafNode(this_BEGIN_1, grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); + + otherlv_2=(Token)match(input,Type,FOLLOW_40); + + newLeafNode(otherlv_2, grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); + + // InternalRos1Parser.g:3145:3: ( (lv_type_3_0= ruleParameterType ) ) + // InternalRos1Parser.g:3146:4: (lv_type_3_0= ruleParameterType ) + { + // InternalRos1Parser.g:3146:4: (lv_type_3_0= ruleParameterType ) + // InternalRos1Parser.g:3147:5: lv_type_3_0= ruleParameterType + { + + newCompositeNode(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); + + pushFollow(FOLLOW_47); + lv_type_3_0=ruleParameterType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterArrayTypeRule()); + } + set( + current, + "type", + lv_type_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:3164:3: (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? + int alt55=2; + int LA55_0 = input.LA(1); + + if ( (LA55_0==Default) ) { + alt55=1; + } + switch (alt55) { + case 1 : + // InternalRos1Parser.g:3165:4: otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) + { + otherlv_4=(Token)match(input,Default,FOLLOW_10); + + newLeafNode(otherlv_4, grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); + + // InternalRos1Parser.g:3169:4: ( (lv_default_5_0= ruleParameterList ) ) + // InternalRos1Parser.g:3170:5: (lv_default_5_0= ruleParameterList ) + { + // InternalRos1Parser.g:3170:5: (lv_default_5_0= ruleParameterList ) + // InternalRos1Parser.g:3171:6: lv_default_5_0= ruleParameterList + { + + newCompositeNode(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); + + pushFollow(FOLLOW_13); + lv_default_5_0=ruleParameterList(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterArrayTypeRule()); + } + set( + current, + "default", + lv_default_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterList"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_6=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_6, grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterArrayType" + + + // $ANTLR start "entryRuleParameterList" + // InternalRos1Parser.g:3197:1: entryRuleParameterList returns [EObject current=null] : iv_ruleParameterList= ruleParameterList EOF ; + public final EObject entryRuleParameterList() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterList = null; + + + try { + // InternalRos1Parser.g:3197:54: (iv_ruleParameterList= ruleParameterList EOF ) + // InternalRos1Parser.g:3198:2: iv_ruleParameterList= ruleParameterList EOF + { + newCompositeNode(grammarAccess.getParameterListRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterList=ruleParameterList(); + + state._fsp--; + + current =iv_ruleParameterList; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterList" + + + // $ANTLR start "ruleParameterList" + // InternalRos1Parser.g:3204:1: ruleParameterList returns [EObject current=null] : ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) ; + public final EObject ruleParameterList() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + EObject lv_value_2_0 = null; + + EObject lv_value_4_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3210:2: ( ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) ) + // InternalRos1Parser.g:3211:2: ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) + { + // InternalRos1Parser.g:3211:2: ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) + // InternalRos1Parser.g:3212:3: () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket + { + // InternalRos1Parser.g:3212:3: () + // InternalRos1Parser.g:3213:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterListAccess().getParameterSequenceAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,LeftSquareBracket,FOLLOW_48); + + newLeafNode(otherlv_1, grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); + + // InternalRos1Parser.g:3223:3: ( (lv_value_2_0= ruleParameterValue ) ) + // InternalRos1Parser.g:3224:4: (lv_value_2_0= ruleParameterValue ) + { + // InternalRos1Parser.g:3224:4: (lv_value_2_0= ruleParameterValue ) + // InternalRos1Parser.g:3225:5: lv_value_2_0= ruleParameterValue + { + + newCompositeNode(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); + + pushFollow(FOLLOW_12); + lv_value_2_0=ruleParameterValue(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterListRule()); + } + add( + current, + "value", + lv_value_2_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:3242:3: (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* + loop56: + do { + int alt56=2; + int LA56_0 = input.LA(1); + + if ( (LA56_0==Comma) ) { + alt56=1; + } + + + switch (alt56) { + case 1 : + // InternalRos1Parser.g:3243:4: otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) + { + otherlv_3=(Token)match(input,Comma,FOLLOW_48); + + newLeafNode(otherlv_3, grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); + + // InternalRos1Parser.g:3247:4: ( (lv_value_4_0= ruleParameterValue ) ) + // InternalRos1Parser.g:3248:5: (lv_value_4_0= ruleParameterValue ) + { + // InternalRos1Parser.g:3248:5: (lv_value_4_0= ruleParameterValue ) + // InternalRos1Parser.g:3249:6: lv_value_4_0= ruleParameterValue + { + + newCompositeNode(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); + + pushFollow(FOLLOW_12); + lv_value_4_0=ruleParameterValue(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterListRule()); + } + add( + current, + "value", + lv_value_4_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop56; + } + } while (true); + + otherlv_5=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_5, grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterList" + + + // $ANTLR start "entryRuleParameterAny" + // InternalRos1Parser.g:3275:1: entryRuleParameterAny returns [EObject current=null] : iv_ruleParameterAny= ruleParameterAny EOF ; + public final EObject entryRuleParameterAny() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterAny = null; + + + try { + // InternalRos1Parser.g:3275:53: (iv_ruleParameterAny= ruleParameterAny EOF ) + // InternalRos1Parser.g:3276:2: iv_ruleParameterAny= ruleParameterAny EOF + { + newCompositeNode(grammarAccess.getParameterAnyRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterAny=ruleParameterAny(); + + state._fsp--; + + current =iv_ruleParameterAny; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterAny" + + + // $ANTLR start "ruleParameterAny" + // InternalRos1Parser.g:3282:1: ruleParameterAny returns [EObject current=null] : ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) ; + public final EObject ruleParameterAny() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + AntlrDatatypeRuleToken lv_value_3_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3288:2: ( ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) ) + // InternalRos1Parser.g:3289:2: ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) + { + // InternalRos1Parser.g:3289:2: ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) + // InternalRos1Parser.g:3290:3: () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? + { + // InternalRos1Parser.g:3290:3: () + // InternalRos1Parser.g:3291:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterAnyAccess().getParameterAnyAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,ParameterAny,FOLLOW_49); + + newLeafNode(otherlv_1, grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); + + // InternalRos1Parser.g:3301:3: (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? + int alt57=2; + int LA57_0 = input.LA(1); + + if ( (LA57_0==Value) ) { + alt57=1; + } + switch (alt57) { + case 1 : + // InternalRos1Parser.g:3302:4: otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) + { + otherlv_2=(Token)match(input,Value,FOLLOW_6); + + newLeafNode(otherlv_2, grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); + + // InternalRos1Parser.g:3306:4: ( (lv_value_3_0= ruleEString ) ) + // InternalRos1Parser.g:3307:5: (lv_value_3_0= ruleEString ) + { + // InternalRos1Parser.g:3307:5: (lv_value_3_0= ruleEString ) + // InternalRos1Parser.g:3308:6: lv_value_3_0= ruleEString + { + + newCompositeNode(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_value_3_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterAnyRule()); + } + set( + current, + "value", + lv_value_3_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterAny" + + + // $ANTLR start "entryRuleParameterString" + // InternalRos1Parser.g:3330:1: entryRuleParameterString returns [EObject current=null] : iv_ruleParameterString= ruleParameterString EOF ; + public final EObject entryRuleParameterString() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterString = null; + + + try { + // InternalRos1Parser.g:3330:56: (iv_ruleParameterString= ruleParameterString EOF ) + // InternalRos1Parser.g:3331:2: iv_ruleParameterString= ruleParameterString EOF + { + newCompositeNode(grammarAccess.getParameterStringRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterString=ruleParameterString(); + + state._fsp--; + + current =iv_ruleParameterString; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterString" + + + // $ANTLR start "ruleParameterString" + // InternalRos1Parser.g:3337:1: ruleParameterString returns [EObject current=null] : ( (lv_value_0_0= ruleEString ) ) ; + public final EObject ruleParameterString() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3343:2: ( ( (lv_value_0_0= ruleEString ) ) ) + // InternalRos1Parser.g:3344:2: ( (lv_value_0_0= ruleEString ) ) + { + // InternalRos1Parser.g:3344:2: ( (lv_value_0_0= ruleEString ) ) + // InternalRos1Parser.g:3345:3: (lv_value_0_0= ruleEString ) + { + // InternalRos1Parser.g:3345:3: (lv_value_0_0= ruleEString ) + // InternalRos1Parser.g:3346:4: lv_value_0_0= ruleEString + { + + newCompositeNode(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStringRule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterString" + + + // $ANTLR start "entryRuleParameterBase64" + // InternalRos1Parser.g:3366:1: entryRuleParameterBase64 returns [EObject current=null] : iv_ruleParameterBase64= ruleParameterBase64 EOF ; + public final EObject entryRuleParameterBase64() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterBase64 = null; + + + try { + // InternalRos1Parser.g:3366:56: (iv_ruleParameterBase64= ruleParameterBase64 EOF ) + // InternalRos1Parser.g:3367:2: iv_ruleParameterBase64= ruleParameterBase64 EOF + { + newCompositeNode(grammarAccess.getParameterBase64Rule()); + pushFollow(FOLLOW_1); + iv_ruleParameterBase64=ruleParameterBase64(); + + state._fsp--; + + current =iv_ruleParameterBase64; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterBase64" + + + // $ANTLR start "ruleParameterBase64" + // InternalRos1Parser.g:3373:1: ruleParameterBase64 returns [EObject current=null] : ( (lv_value_0_0= ruleBase64Binary ) ) ; + public final EObject ruleParameterBase64() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3379:2: ( ( (lv_value_0_0= ruleBase64Binary ) ) ) + // InternalRos1Parser.g:3380:2: ( (lv_value_0_0= ruleBase64Binary ) ) + { + // InternalRos1Parser.g:3380:2: ( (lv_value_0_0= ruleBase64Binary ) ) + // InternalRos1Parser.g:3381:3: (lv_value_0_0= ruleBase64Binary ) + { + // InternalRos1Parser.g:3381:3: (lv_value_0_0= ruleBase64Binary ) + // InternalRos1Parser.g:3382:4: lv_value_0_0= ruleBase64Binary + { + + newCompositeNode(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleBase64Binary(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterBase64Rule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Base64Binary"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterBase64" + + + // $ANTLR start "entryRuleParameterInteger" + // InternalRos1Parser.g:3402:1: entryRuleParameterInteger returns [EObject current=null] : iv_ruleParameterInteger= ruleParameterInteger EOF ; + public final EObject entryRuleParameterInteger() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterInteger = null; + + + try { + // InternalRos1Parser.g:3402:57: (iv_ruleParameterInteger= ruleParameterInteger EOF ) + // InternalRos1Parser.g:3403:2: iv_ruleParameterInteger= ruleParameterInteger EOF + { + newCompositeNode(grammarAccess.getParameterIntegerRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterInteger=ruleParameterInteger(); + + state._fsp--; + + current =iv_ruleParameterInteger; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterInteger" + + + // $ANTLR start "ruleParameterInteger" + // InternalRos1Parser.g:3409:1: ruleParameterInteger returns [EObject current=null] : ( (lv_value_0_0= ruleInteger0 ) ) ; + public final EObject ruleParameterInteger() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3415:2: ( ( (lv_value_0_0= ruleInteger0 ) ) ) + // InternalRos1Parser.g:3416:2: ( (lv_value_0_0= ruleInteger0 ) ) + { + // InternalRos1Parser.g:3416:2: ( (lv_value_0_0= ruleInteger0 ) ) + // InternalRos1Parser.g:3417:3: (lv_value_0_0= ruleInteger0 ) + { + // InternalRos1Parser.g:3417:3: (lv_value_0_0= ruleInteger0 ) + // InternalRos1Parser.g:3418:4: lv_value_0_0= ruleInteger0 + { + + newCompositeNode(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleInteger0(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterIntegerRule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Integer0"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterInteger" + + + // $ANTLR start "entryRuleParameterDouble" + // InternalRos1Parser.g:3438:1: entryRuleParameterDouble returns [EObject current=null] : iv_ruleParameterDouble= ruleParameterDouble EOF ; + public final EObject entryRuleParameterDouble() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterDouble = null; + + + try { + // InternalRos1Parser.g:3438:56: (iv_ruleParameterDouble= ruleParameterDouble EOF ) + // InternalRos1Parser.g:3439:2: iv_ruleParameterDouble= ruleParameterDouble EOF + { + newCompositeNode(grammarAccess.getParameterDoubleRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterDouble=ruleParameterDouble(); + + state._fsp--; + + current =iv_ruleParameterDouble; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterDouble" + + + // $ANTLR start "ruleParameterDouble" + // InternalRos1Parser.g:3445:1: ruleParameterDouble returns [EObject current=null] : ( (lv_value_0_0= ruleDouble0 ) ) ; + public final EObject ruleParameterDouble() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3451:2: ( ( (lv_value_0_0= ruleDouble0 ) ) ) + // InternalRos1Parser.g:3452:2: ( (lv_value_0_0= ruleDouble0 ) ) + { + // InternalRos1Parser.g:3452:2: ( (lv_value_0_0= ruleDouble0 ) ) + // InternalRos1Parser.g:3453:3: (lv_value_0_0= ruleDouble0 ) + { + // InternalRos1Parser.g:3453:3: (lv_value_0_0= ruleDouble0 ) + // InternalRos1Parser.g:3454:4: lv_value_0_0= ruleDouble0 + { + + newCompositeNode(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleDouble0(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterDoubleRule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Double0"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterDouble" + + + // $ANTLR start "entryRuleParameterBoolean" + // InternalRos1Parser.g:3474:1: entryRuleParameterBoolean returns [EObject current=null] : iv_ruleParameterBoolean= ruleParameterBoolean EOF ; + public final EObject entryRuleParameterBoolean() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterBoolean = null; + + + try { + // InternalRos1Parser.g:3474:57: (iv_ruleParameterBoolean= ruleParameterBoolean EOF ) + // InternalRos1Parser.g:3475:2: iv_ruleParameterBoolean= ruleParameterBoolean EOF + { + newCompositeNode(grammarAccess.getParameterBooleanRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterBoolean=ruleParameterBoolean(); + + state._fsp--; + + current =iv_ruleParameterBoolean; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterBoolean" + + + // $ANTLR start "ruleParameterBoolean" + // InternalRos1Parser.g:3481:1: ruleParameterBoolean returns [EObject current=null] : ( (lv_value_0_0= ruleboolean0 ) ) ; + public final EObject ruleParameterBoolean() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3487:2: ( ( (lv_value_0_0= ruleboolean0 ) ) ) + // InternalRos1Parser.g:3488:2: ( (lv_value_0_0= ruleboolean0 ) ) + { + // InternalRos1Parser.g:3488:2: ( (lv_value_0_0= ruleboolean0 ) ) + // InternalRos1Parser.g:3489:3: (lv_value_0_0= ruleboolean0 ) + { + // InternalRos1Parser.g:3489:3: (lv_value_0_0= ruleboolean0 ) + // InternalRos1Parser.g:3490:4: lv_value_0_0= ruleboolean0 + { + + newCompositeNode(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleboolean0(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterBooleanRule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.boolean0"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterBoolean" + + + // $ANTLR start "entryRuleParameterStruct" + // InternalRos1Parser.g:3510:1: entryRuleParameterStruct returns [EObject current=null] : iv_ruleParameterStruct= ruleParameterStruct EOF ; + public final EObject entryRuleParameterStruct() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterStruct = null; + + + try { + // InternalRos1Parser.g:3510:56: (iv_ruleParameterStruct= ruleParameterStruct EOF ) + // InternalRos1Parser.g:3511:2: iv_ruleParameterStruct= ruleParameterStruct EOF + { + newCompositeNode(grammarAccess.getParameterStructRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterStruct=ruleParameterStruct(); + + state._fsp--; + + current =iv_ruleParameterStruct; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterStruct" + + + // $ANTLR start "ruleParameterStruct" + // InternalRos1Parser.g:3517:1: ruleParameterStruct returns [EObject current=null] : ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) ; + public final EObject ruleParameterStruct() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_7=null; + EObject lv_value_2_0 = null; + + EObject lv_value_5_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3523:2: ( ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) ) + // InternalRos1Parser.g:3524:2: ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) + { + // InternalRos1Parser.g:3524:2: ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) + // InternalRos1Parser.g:3525:3: () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? + { + // InternalRos1Parser.g:3525:3: () + // InternalRos1Parser.g:3526:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterStructAccess().getParameterStructAction_0(), + current); + + + } + + // InternalRos1Parser.g:3532:3: (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? + int alt59=2; + int LA59_0 = input.LA(1); + + if ( (LA59_0==LeftSquareBracket) ) { + alt59=1; + } + switch (alt59) { + case 1 : + // InternalRos1Parser.g:3533:4: otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket + { + otherlv_1=(Token)match(input,LeftSquareBracket,FOLLOW_50); + + newLeafNode(otherlv_1, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); + + // InternalRos1Parser.g:3537:4: ( (lv_value_2_0= ruleParameterStructMember ) ) + // InternalRos1Parser.g:3538:5: (lv_value_2_0= ruleParameterStructMember ) + { + // InternalRos1Parser.g:3538:5: (lv_value_2_0= ruleParameterStructMember ) + // InternalRos1Parser.g:3539:6: lv_value_2_0= ruleParameterStructMember + { + + newCompositeNode(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); + + pushFollow(FOLLOW_12); + lv_value_2_0=ruleParameterStructMember(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructRule()); + } + add( + current, + "value", + lv_value_2_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructMember"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:3556:4: (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* + loop58: + do { + int alt58=2; + int LA58_0 = input.LA(1); + + if ( (LA58_0==Comma) ) { + alt58=1; + } + + + switch (alt58) { + case 1 : + // InternalRos1Parser.g:3557:5: otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket + { + otherlv_3=(Token)match(input,Comma,FOLLOW_10); + + newLeafNode(otherlv_3, grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); + + otherlv_4=(Token)match(input,LeftSquareBracket,FOLLOW_50); + + newLeafNode(otherlv_4, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); + + // InternalRos1Parser.g:3565:5: ( (lv_value_5_0= ruleParameterStructMember ) ) + // InternalRos1Parser.g:3566:6: (lv_value_5_0= ruleParameterStructMember ) + { + // InternalRos1Parser.g:3566:6: (lv_value_5_0= ruleParameterStructMember ) + // InternalRos1Parser.g:3567:7: lv_value_5_0= ruleParameterStructMember + { + + newCompositeNode(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); + + pushFollow(FOLLOW_51); + lv_value_5_0=ruleParameterStructMember(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructRule()); + } + add( + current, + "value", + lv_value_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructMember"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_12); + + newLeafNode(otherlv_6, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); + + + } + break; + + default : + break loop58; + } + } while (true); + + otherlv_7=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_7, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterStruct" + + + // $ANTLR start "entryRuleParameterDate" + // InternalRos1Parser.g:3598:1: entryRuleParameterDate returns [EObject current=null] : iv_ruleParameterDate= ruleParameterDate EOF ; + public final EObject entryRuleParameterDate() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterDate = null; + + + try { + // InternalRos1Parser.g:3598:54: (iv_ruleParameterDate= ruleParameterDate EOF ) + // InternalRos1Parser.g:3599:2: iv_ruleParameterDate= ruleParameterDate EOF + { + newCompositeNode(grammarAccess.getParameterDateRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterDate=ruleParameterDate(); + + state._fsp--; + + current =iv_ruleParameterDate; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterDate" + + + // $ANTLR start "ruleParameterDate" + // InternalRos1Parser.g:3605:1: ruleParameterDate returns [EObject current=null] : ( (lv_value_0_0= ruleDateTime0 ) ) ; + public final EObject ruleParameterDate() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3611:2: ( ( (lv_value_0_0= ruleDateTime0 ) ) ) + // InternalRos1Parser.g:3612:2: ( (lv_value_0_0= ruleDateTime0 ) ) + { + // InternalRos1Parser.g:3612:2: ( (lv_value_0_0= ruleDateTime0 ) ) + // InternalRos1Parser.g:3613:3: (lv_value_0_0= ruleDateTime0 ) + { + // InternalRos1Parser.g:3613:3: (lv_value_0_0= ruleDateTime0 ) + // InternalRos1Parser.g:3614:4: lv_value_0_0= ruleDateTime0 + { + + newCompositeNode(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleDateTime0(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterDateRule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.DateTime0"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterDate" + + + // $ANTLR start "entryRuleParameterStructMember" + // InternalRos1Parser.g:3634:1: entryRuleParameterStructMember returns [EObject current=null] : iv_ruleParameterStructMember= ruleParameterStructMember EOF ; + public final EObject entryRuleParameterStructMember() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterStructMember = null; + + + try { + // InternalRos1Parser.g:3634:62: (iv_ruleParameterStructMember= ruleParameterStructMember EOF ) + // InternalRos1Parser.g:3635:2: iv_ruleParameterStructMember= ruleParameterStructMember EOF + { + newCompositeNode(grammarAccess.getParameterStructMemberRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterStructMember=ruleParameterStructMember(); + + state._fsp--; + + current =iv_ruleParameterStructMember; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterStructMember" + + + // $ANTLR start "ruleParameterStructMember" + // InternalRos1Parser.g:3641:1: ruleParameterStructMember returns [EObject current=null] : (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) ; + public final EObject ruleParameterStructMember() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token this_END_5=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_value_4_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3647:2: ( (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) ) + // InternalRos1Parser.g:3648:2: (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) + { + // InternalRos1Parser.g:3648:2: (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) + // InternalRos1Parser.g:3649:3: otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END + { + otherlv_0=(Token)match(input,ParameterStructMember,FOLLOW_6); + + newLeafNode(otherlv_0, grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); + + // InternalRos1Parser.g:3653:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos1Parser.g:3654:4: (lv_name_1_0= ruleEString ) + { + // InternalRos1Parser.g:3654:4: (lv_name_1_0= ruleEString ) + // InternalRos1Parser.g:3655:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructMemberRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_48); + + newLeafNode(this_BEGIN_3, grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); + + // InternalRos1Parser.g:3680:3: ( (lv_value_4_0= ruleParameterValue ) ) + // InternalRos1Parser.g:3681:4: (lv_value_4_0= ruleParameterValue ) + { + // InternalRos1Parser.g:3681:4: (lv_value_4_0= ruleParameterValue ) + // InternalRos1Parser.g:3682:5: lv_value_4_0= ruleParameterValue + { + + newCompositeNode(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); + + pushFollow(FOLLOW_13); + lv_value_4_0=ruleParameterValue(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructMemberRule()); + } + set( + current, + "value", + lv_value_4_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_5=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_5, grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterStructMember" + + + // $ANTLR start "entryRuleParameterStructTypeMember" + // InternalRos1Parser.g:3707:1: entryRuleParameterStructTypeMember returns [EObject current=null] : iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF ; + public final EObject entryRuleParameterStructTypeMember() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterStructTypeMember = null; + + + try { + // InternalRos1Parser.g:3707:66: (iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF ) + // InternalRos1Parser.g:3708:2: iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF + { + newCompositeNode(grammarAccess.getParameterStructTypeMemberRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterStructTypeMember=ruleParameterStructTypeMember(); + + state._fsp--; + + current =iv_ruleParameterStructTypeMember; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterStructTypeMember" + + + // $ANTLR start "ruleParameterStructTypeMember" + // InternalRos1Parser.g:3714:1: ruleParameterStructTypeMember returns [EObject current=null] : ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) ; + public final EObject ruleParameterStructTypeMember() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_name_0_0 = null; + + EObject lv_type_1_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3720:2: ( ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) ) + // InternalRos1Parser.g:3721:2: ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) + { + // InternalRos1Parser.g:3721:2: ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) + // InternalRos1Parser.g:3722:3: ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) + { + // InternalRos1Parser.g:3722:3: ( (lv_name_0_0= ruleEString ) ) + // InternalRos1Parser.g:3723:4: (lv_name_0_0= ruleEString ) + { + // InternalRos1Parser.g:3723:4: (lv_name_0_0= ruleEString ) + // InternalRos1Parser.g:3724:5: lv_name_0_0= ruleEString + { + + newCompositeNode(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); + + pushFollow(FOLLOW_40); + lv_name_0_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructTypeMemberRule()); + } + set( + current, + "name", + lv_name_0_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:3741:3: ( (lv_type_1_0= ruleParameterType ) ) + // InternalRos1Parser.g:3742:4: (lv_type_1_0= ruleParameterType ) + { + // InternalRos1Parser.g:3742:4: (lv_type_1_0= ruleParameterType ) + // InternalRos1Parser.g:3743:5: lv_type_1_0= ruleParameterType + { + + newCompositeNode(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); + + pushFollow(FOLLOW_2); + lv_type_1_0=ruleParameterType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructTypeMemberRule()); + } + set( + current, + "type", + lv_type_1_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterStructTypeMember" + + + // $ANTLR start "entryRuleBase64Binary" + // InternalRos1Parser.g:3764:1: entryRuleBase64Binary returns [String current=null] : iv_ruleBase64Binary= ruleBase64Binary EOF ; + public final String entryRuleBase64Binary() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleBase64Binary = null; + + + try { + // InternalRos1Parser.g:3764:52: (iv_ruleBase64Binary= ruleBase64Binary EOF ) + // InternalRos1Parser.g:3765:2: iv_ruleBase64Binary= ruleBase64Binary EOF + { + newCompositeNode(grammarAccess.getBase64BinaryRule()); + pushFollow(FOLLOW_1); + iv_ruleBase64Binary=ruleBase64Binary(); + + state._fsp--; + + current =iv_ruleBase64Binary.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleBase64Binary" + + + // $ANTLR start "ruleBase64Binary" + // InternalRos1Parser.g:3771:1: ruleBase64Binary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_BINARY_0= RULE_BINARY ; + public final AntlrDatatypeRuleToken ruleBase64Binary() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_BINARY_0=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:3777:2: (this_BINARY_0= RULE_BINARY ) + // InternalRos1Parser.g:3778:2: this_BINARY_0= RULE_BINARY + { + this_BINARY_0=(Token)match(input,RULE_BINARY,FOLLOW_2); + + current.merge(this_BINARY_0); + + + newLeafNode(this_BINARY_0, grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleBase64Binary" + + + // $ANTLR start "entryRuleboolean0" + // InternalRos1Parser.g:3788:1: entryRuleboolean0 returns [String current=null] : iv_ruleboolean0= ruleboolean0 EOF ; + public final String entryRuleboolean0() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleboolean0 = null; + + + try { + // InternalRos1Parser.g:3788:48: (iv_ruleboolean0= ruleboolean0 EOF ) + // InternalRos1Parser.g:3789:2: iv_ruleboolean0= ruleboolean0 EOF + { + newCompositeNode(grammarAccess.getBoolean0Rule()); + pushFollow(FOLLOW_1); + iv_ruleboolean0=ruleboolean0(); + + state._fsp--; + + current =iv_ruleboolean0.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleboolean0" + + + // $ANTLR start "ruleboolean0" + // InternalRos1Parser.g:3795:1: ruleboolean0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_BOOLEAN_0= RULE_BOOLEAN ; + public final AntlrDatatypeRuleToken ruleboolean0() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_BOOLEAN_0=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:3801:2: (this_BOOLEAN_0= RULE_BOOLEAN ) + // InternalRos1Parser.g:3802:2: this_BOOLEAN_0= RULE_BOOLEAN + { + this_BOOLEAN_0=(Token)match(input,RULE_BOOLEAN,FOLLOW_2); + + current.merge(this_BOOLEAN_0); + + + newLeafNode(this_BOOLEAN_0, grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleboolean0" + + + // $ANTLR start "entryRuleDouble0" + // InternalRos1Parser.g:3812:1: entryRuleDouble0 returns [String current=null] : iv_ruleDouble0= ruleDouble0 EOF ; + public final String entryRuleDouble0() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleDouble0 = null; + + + try { + // InternalRos1Parser.g:3812:47: (iv_ruleDouble0= ruleDouble0 EOF ) + // InternalRos1Parser.g:3813:2: iv_ruleDouble0= ruleDouble0 EOF + { + newCompositeNode(grammarAccess.getDouble0Rule()); + pushFollow(FOLLOW_1); + iv_ruleDouble0=ruleDouble0(); + + state._fsp--; + + current =iv_ruleDouble0.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleDouble0" + + + // $ANTLR start "ruleDouble0" + // InternalRos1Parser.g:3819:1: ruleDouble0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DOUBLE_0= RULE_DOUBLE ; + public final AntlrDatatypeRuleToken ruleDouble0() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_DOUBLE_0=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:3825:2: (this_DOUBLE_0= RULE_DOUBLE ) + // InternalRos1Parser.g:3826:2: this_DOUBLE_0= RULE_DOUBLE + { + this_DOUBLE_0=(Token)match(input,RULE_DOUBLE,FOLLOW_2); + + current.merge(this_DOUBLE_0); + + + newLeafNode(this_DOUBLE_0, grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleDouble0" + + + // $ANTLR start "entryRuleInteger0" + // InternalRos1Parser.g:3836:1: entryRuleInteger0 returns [String current=null] : iv_ruleInteger0= ruleInteger0 EOF ; + public final String entryRuleInteger0() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleInteger0 = null; + + + try { + // InternalRos1Parser.g:3836:48: (iv_ruleInteger0= ruleInteger0 EOF ) + // InternalRos1Parser.g:3837:2: iv_ruleInteger0= ruleInteger0 EOF + { + newCompositeNode(grammarAccess.getInteger0Rule()); + pushFollow(FOLLOW_1); + iv_ruleInteger0=ruleInteger0(); + + state._fsp--; + + current =iv_ruleInteger0.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleInteger0" + + + // $ANTLR start "ruleInteger0" + // InternalRos1Parser.g:3843:1: ruleInteger0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DECINT_0= RULE_DECINT ; + public final AntlrDatatypeRuleToken ruleInteger0() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_DECINT_0=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:3849:2: (this_DECINT_0= RULE_DECINT ) + // InternalRos1Parser.g:3850:2: this_DECINT_0= RULE_DECINT + { + this_DECINT_0=(Token)match(input,RULE_DECINT,FOLLOW_2); + + current.merge(this_DECINT_0); + + + newLeafNode(this_DECINT_0, grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleInteger0" + + + // $ANTLR start "entryRuleDateTime0" + // InternalRos1Parser.g:3860:1: entryRuleDateTime0 returns [String current=null] : iv_ruleDateTime0= ruleDateTime0 EOF ; + public final String entryRuleDateTime0() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleDateTime0 = null; + + + try { + // InternalRos1Parser.g:3860:49: (iv_ruleDateTime0= ruleDateTime0 EOF ) + // InternalRos1Parser.g:3861:2: iv_ruleDateTime0= ruleDateTime0 EOF + { + newCompositeNode(grammarAccess.getDateTime0Rule()); + pushFollow(FOLLOW_1); + iv_ruleDateTime0=ruleDateTime0(); + + state._fsp--; + + current =iv_ruleDateTime0.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleDateTime0" + + + // $ANTLR start "ruleDateTime0" + // InternalRos1Parser.g:3867:1: ruleDateTime0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DATE_TIME_0= RULE_DATE_TIME ; + public final AntlrDatatypeRuleToken ruleDateTime0() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_DATE_TIME_0=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:3873:2: (this_DATE_TIME_0= RULE_DATE_TIME ) + // InternalRos1Parser.g:3874:2: this_DATE_TIME_0= RULE_DATE_TIME + { + this_DATE_TIME_0=(Token)match(input,RULE_DATE_TIME,FOLLOW_2); + + current.merge(this_DATE_TIME_0); + + + newLeafNode(this_DATE_TIME_0, grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleDateTime0" + + + // $ANTLR start "entryRuleMessagePart" + // InternalRos1Parser.g:3884:1: entryRuleMessagePart returns [EObject current=null] : iv_ruleMessagePart= ruleMessagePart EOF ; + public final EObject entryRuleMessagePart() throws RecognitionException { + EObject current = null; + + EObject iv_ruleMessagePart = null; + + + try { + // InternalRos1Parser.g:3884:52: (iv_ruleMessagePart= ruleMessagePart EOF ) + // InternalRos1Parser.g:3885:2: iv_ruleMessagePart= ruleMessagePart EOF + { + newCompositeNode(grammarAccess.getMessagePartRule()); + pushFollow(FOLLOW_1); + iv_ruleMessagePart=ruleMessagePart(); + + state._fsp--; + + current =iv_ruleMessagePart; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleMessagePart" + + + // $ANTLR start "ruleMessagePart" + // InternalRos1Parser.g:3891:1: ruleMessagePart returns [EObject current=null] : ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) ; + public final EObject ruleMessagePart() throws RecognitionException { + EObject current = null; + + Token lv_Data_1_2=null; + EObject lv_Type_0_0 = null; + + AntlrDatatypeRuleToken lv_Data_1_1 = null; + + AntlrDatatypeRuleToken lv_Data_1_3 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3897:2: ( ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) ) + // InternalRos1Parser.g:3898:2: ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) + { + // InternalRos1Parser.g:3898:2: ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) + // InternalRos1Parser.g:3899:3: ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) + { + // InternalRos1Parser.g:3899:3: ( (lv_Type_0_0= ruleAbstractType ) ) + // InternalRos1Parser.g:3900:4: (lv_Type_0_0= ruleAbstractType ) + { + // InternalRos1Parser.g:3900:4: (lv_Type_0_0= ruleAbstractType ) + // InternalRos1Parser.g:3901:5: lv_Type_0_0= ruleAbstractType + { + + newCompositeNode(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); + + pushFollow(FOLLOW_52); + lv_Type_0_0=ruleAbstractType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + current, + "Type", + lv_Type_0_0, + "de.fraunhofer.ipa.ros.Ros.AbstractType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:3918:3: ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) + // InternalRos1Parser.g:3919:4: ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) + { + // InternalRos1Parser.g:3919:4: ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) + // InternalRos1Parser.g:3920:5: (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) + { + // InternalRos1Parser.g:3920:5: (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) + int alt60=3; + switch ( input.LA(1) ) { + case Duration: + case Feedback: + case Message: + case Service: + case Action: + case Result: + case Value: + case Goal: + case Name: + case Time: + case Type: + { + alt60=1; + } + break; + case RULE_MESSAGE_ASIGMENT: + { + alt60=2; + } + break; + case RULE_ID: + case RULE_STRING: + { + alt60=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 60, 0, input); + + throw nvae; + } + + switch (alt60) { + case 1 : + // InternalRos1Parser.g:3921:6: lv_Data_1_1= ruleKEYWORD + { + + newCompositeNode(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); + + pushFollow(FOLLOW_2); + lv_Data_1_1=ruleKEYWORD(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + current, + "Data", + lv_Data_1_1, + "de.fraunhofer.ipa.ros.Ros.KEYWORD"); + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos1Parser.g:3937:6: lv_Data_1_2= RULE_MESSAGE_ASIGMENT + { + lv_Data_1_2=(Token)match(input,RULE_MESSAGE_ASIGMENT,FOLLOW_2); + + newLeafNode(lv_Data_1_2, grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); + + + if (current==null) { + current = createModelElement(grammarAccess.getMessagePartRule()); + } + setWithLastConsumed( + current, + "Data", + lv_Data_1_2, + "de.fraunhofer.ipa.ros.Ros.MESSAGE_ASIGMENT"); + + + } + break; + case 3 : + // InternalRos1Parser.g:3952:6: lv_Data_1_3= ruleEString + { + + newCompositeNode(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); + + pushFollow(FOLLOW_2); + lv_Data_1_3=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + current, + "Data", + lv_Data_1_3, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMessagePart" + + + // $ANTLR start "entryRuleAbstractType" + // InternalRos1Parser.g:3974:1: entryRuleAbstractType returns [EObject current=null] : iv_ruleAbstractType= ruleAbstractType EOF ; + public final EObject entryRuleAbstractType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleAbstractType = null; + + + try { + // InternalRos1Parser.g:3974:53: (iv_ruleAbstractType= ruleAbstractType EOF ) + // InternalRos1Parser.g:3975:2: iv_ruleAbstractType= ruleAbstractType EOF + { + newCompositeNode(grammarAccess.getAbstractTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleAbstractType=ruleAbstractType(); + + state._fsp--; + + current =iv_ruleAbstractType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleAbstractType" + + + // $ANTLR start "ruleAbstractType" + // InternalRos1Parser.g:3981:1: ruleAbstractType returns [EObject current=null] : (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) ; + public final EObject ruleAbstractType() throws RecognitionException { + EObject current = null; + + EObject this_bool_0 = null; + + EObject this_int8_1 = null; + + EObject this_uint8_2 = null; + + EObject this_int16_3 = null; + + EObject this_uint16_4 = null; + + EObject this_int32_5 = null; + + EObject this_uint32_6 = null; + + EObject this_int64_7 = null; + + EObject this_uint64_8 = null; + + EObject this_float32_9 = null; + + EObject this_float64_10 = null; + + EObject this_string0_11 = null; + + EObject this_byte_12 = null; + + EObject this_time_13 = null; + + EObject this_duration_14 = null; + + EObject this_Header_15 = null; + + EObject this_boolArray_16 = null; + + EObject this_int8Array_17 = null; + + EObject this_uint8Array_18 = null; + + EObject this_int16Array_19 = null; + + EObject this_uint16Array_20 = null; + + EObject this_int32Array_21 = null; + + EObject this_uint32Array_22 = null; + + EObject this_int64Array_23 = null; + + EObject this_uint64Array_24 = null; + + EObject this_float32Array_25 = null; + + EObject this_float64Array_26 = null; + + EObject this_string0Array_27 = null; + + EObject this_byteArray_28 = null; + + EObject this_TopicSpecRef_29 = null; + + EObject this_ArrayTopicSpecRef_30 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:3987:2: ( (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) ) + // InternalRos1Parser.g:3988:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) + { + // InternalRos1Parser.g:3988:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) + int alt61=31; + alt61 = dfa61.predict(input); + switch (alt61) { + case 1 : + // InternalRos1Parser.g:3989:3: this_bool_0= rulebool + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_bool_0=rulebool(); + + state._fsp--; + + + current = this_bool_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos1Parser.g:3998:3: this_int8_1= ruleint8 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_int8_1=ruleint8(); + + state._fsp--; + + + current = this_int8_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalRos1Parser.g:4007:3: this_uint8_2= ruleuint8 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_uint8_2=ruleuint8(); + + state._fsp--; + + + current = this_uint8_2; + afterParserOrEnumRuleCall(); + + + } + break; + case 4 : + // InternalRos1Parser.g:4016:3: this_int16_3= ruleint16 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); + + pushFollow(FOLLOW_2); + this_int16_3=ruleint16(); + + state._fsp--; + + + current = this_int16_3; + afterParserOrEnumRuleCall(); + + + } + break; + case 5 : + // InternalRos1Parser.g:4025:3: this_uint16_4= ruleuint16 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); + + pushFollow(FOLLOW_2); + this_uint16_4=ruleuint16(); + + state._fsp--; + + + current = this_uint16_4; + afterParserOrEnumRuleCall(); + + + } + break; + case 6 : + // InternalRos1Parser.g:4034:3: this_int32_5= ruleint32 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); + + pushFollow(FOLLOW_2); + this_int32_5=ruleint32(); + + state._fsp--; + + + current = this_int32_5; + afterParserOrEnumRuleCall(); + + + } + break; + case 7 : + // InternalRos1Parser.g:4043:3: this_uint32_6= ruleuint32 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); + + pushFollow(FOLLOW_2); + this_uint32_6=ruleuint32(); + + state._fsp--; + + + current = this_uint32_6; + afterParserOrEnumRuleCall(); + + + } + break; + case 8 : + // InternalRos1Parser.g:4052:3: this_int64_7= ruleint64 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); + + pushFollow(FOLLOW_2); + this_int64_7=ruleint64(); + + state._fsp--; + + + current = this_int64_7; + afterParserOrEnumRuleCall(); + + + } + break; + case 9 : + // InternalRos1Parser.g:4061:3: this_uint64_8= ruleuint64 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); + + pushFollow(FOLLOW_2); + this_uint64_8=ruleuint64(); + + state._fsp--; + + + current = this_uint64_8; + afterParserOrEnumRuleCall(); + + + } + break; + case 10 : + // InternalRos1Parser.g:4070:3: this_float32_9= rulefloat32 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); + + pushFollow(FOLLOW_2); + this_float32_9=rulefloat32(); + + state._fsp--; + + + current = this_float32_9; + afterParserOrEnumRuleCall(); + + + } + break; + case 11 : + // InternalRos1Parser.g:4079:3: this_float64_10= rulefloat64 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); + + pushFollow(FOLLOW_2); + this_float64_10=rulefloat64(); + + state._fsp--; + + + current = this_float64_10; + afterParserOrEnumRuleCall(); + + + } + break; + case 12 : + // InternalRos1Parser.g:4088:3: this_string0_11= rulestring0 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); + + pushFollow(FOLLOW_2); + this_string0_11=rulestring0(); + + state._fsp--; + + + current = this_string0_11; + afterParserOrEnumRuleCall(); + + + } + break; + case 13 : + // InternalRos1Parser.g:4097:3: this_byte_12= rulebyte + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); + + pushFollow(FOLLOW_2); + this_byte_12=rulebyte(); + + state._fsp--; + + + current = this_byte_12; + afterParserOrEnumRuleCall(); + + + } + break; + case 14 : + // InternalRos1Parser.g:4106:3: this_time_13= ruletime + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); + + pushFollow(FOLLOW_2); + this_time_13=ruletime(); + + state._fsp--; + + + current = this_time_13; + afterParserOrEnumRuleCall(); + + + } + break; + case 15 : + // InternalRos1Parser.g:4115:3: this_duration_14= ruleduration + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); + + pushFollow(FOLLOW_2); + this_duration_14=ruleduration(); + + state._fsp--; + + + current = this_duration_14; + afterParserOrEnumRuleCall(); + + + } + break; + case 16 : + // InternalRos1Parser.g:4124:3: this_Header_15= ruleHeader + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); + + pushFollow(FOLLOW_2); + this_Header_15=ruleHeader(); + + state._fsp--; + + + current = this_Header_15; + afterParserOrEnumRuleCall(); + + + } + break; + case 17 : + // InternalRos1Parser.g:4133:3: this_boolArray_16= ruleboolArray + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); + + pushFollow(FOLLOW_2); + this_boolArray_16=ruleboolArray(); + + state._fsp--; + + + current = this_boolArray_16; + afterParserOrEnumRuleCall(); + + + } + break; + case 18 : + // InternalRos1Parser.g:4142:3: this_int8Array_17= ruleint8Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); + + pushFollow(FOLLOW_2); + this_int8Array_17=ruleint8Array(); + + state._fsp--; + + + current = this_int8Array_17; + afterParserOrEnumRuleCall(); + + + } + break; + case 19 : + // InternalRos1Parser.g:4151:3: this_uint8Array_18= ruleuint8Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); + + pushFollow(FOLLOW_2); + this_uint8Array_18=ruleuint8Array(); + + state._fsp--; + + + current = this_uint8Array_18; + afterParserOrEnumRuleCall(); + + + } + break; + case 20 : + // InternalRos1Parser.g:4160:3: this_int16Array_19= ruleint16Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); + + pushFollow(FOLLOW_2); + this_int16Array_19=ruleint16Array(); + + state._fsp--; + + + current = this_int16Array_19; + afterParserOrEnumRuleCall(); + + + } + break; + case 21 : + // InternalRos1Parser.g:4169:3: this_uint16Array_20= ruleuint16Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); + + pushFollow(FOLLOW_2); + this_uint16Array_20=ruleuint16Array(); + + state._fsp--; + + + current = this_uint16Array_20; + afterParserOrEnumRuleCall(); + + + } + break; + case 22 : + // InternalRos1Parser.g:4178:3: this_int32Array_21= ruleint32Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); + + pushFollow(FOLLOW_2); + this_int32Array_21=ruleint32Array(); + + state._fsp--; + + + current = this_int32Array_21; + afterParserOrEnumRuleCall(); + + + } + break; + case 23 : + // InternalRos1Parser.g:4187:3: this_uint32Array_22= ruleuint32Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); + + pushFollow(FOLLOW_2); + this_uint32Array_22=ruleuint32Array(); + + state._fsp--; + + + current = this_uint32Array_22; + afterParserOrEnumRuleCall(); + + + } + break; + case 24 : + // InternalRos1Parser.g:4196:3: this_int64Array_23= ruleint64Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); + + pushFollow(FOLLOW_2); + this_int64Array_23=ruleint64Array(); + + state._fsp--; + + + current = this_int64Array_23; + afterParserOrEnumRuleCall(); + + + } + break; + case 25 : + // InternalRos1Parser.g:4205:3: this_uint64Array_24= ruleuint64Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); + + pushFollow(FOLLOW_2); + this_uint64Array_24=ruleuint64Array(); + + state._fsp--; + + + current = this_uint64Array_24; + afterParserOrEnumRuleCall(); + + + } + break; + case 26 : + // InternalRos1Parser.g:4214:3: this_float32Array_25= rulefloat32Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); + + pushFollow(FOLLOW_2); + this_float32Array_25=rulefloat32Array(); + + state._fsp--; + + + current = this_float32Array_25; + afterParserOrEnumRuleCall(); + + + } + break; + case 27 : + // InternalRos1Parser.g:4223:3: this_float64Array_26= rulefloat64Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); + + pushFollow(FOLLOW_2); + this_float64Array_26=rulefloat64Array(); + + state._fsp--; + + + current = this_float64Array_26; + afterParserOrEnumRuleCall(); + + + } + break; + case 28 : + // InternalRos1Parser.g:4232:3: this_string0Array_27= rulestring0Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); + + pushFollow(FOLLOW_2); + this_string0Array_27=rulestring0Array(); + + state._fsp--; + + + current = this_string0Array_27; + afterParserOrEnumRuleCall(); + + + } + break; + case 29 : + // InternalRos1Parser.g:4241:3: this_byteArray_28= rulebyteArray + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); + + pushFollow(FOLLOW_2); + this_byteArray_28=rulebyteArray(); + + state._fsp--; + + + current = this_byteArray_28; + afterParserOrEnumRuleCall(); + + + } + break; + case 30 : + // InternalRos1Parser.g:4250:3: this_TopicSpecRef_29= ruleTopicSpecRef + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); + + pushFollow(FOLLOW_2); + this_TopicSpecRef_29=ruleTopicSpecRef(); + + state._fsp--; + + + current = this_TopicSpecRef_29; + afterParserOrEnumRuleCall(); + + + } + break; + case 31 : + // InternalRos1Parser.g:4259:3: this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); + + pushFollow(FOLLOW_2); + this_ArrayTopicSpecRef_30=ruleArrayTopicSpecRef(); + + state._fsp--; + + + current = this_ArrayTopicSpecRef_30; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleAbstractType" + + + // $ANTLR start "entryRulebool" + // InternalRos1Parser.g:4271:1: entryRulebool returns [EObject current=null] : iv_rulebool= rulebool EOF ; + public final EObject entryRulebool() throws RecognitionException { + EObject current = null; + + EObject iv_rulebool = null; + + + try { + // InternalRos1Parser.g:4271:45: (iv_rulebool= rulebool EOF ) + // InternalRos1Parser.g:4272:2: iv_rulebool= rulebool EOF + { + newCompositeNode(grammarAccess.getBoolRule()); + pushFollow(FOLLOW_1); + iv_rulebool=rulebool(); + + state._fsp--; + + current =iv_rulebool; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulebool" + + + // $ANTLR start "rulebool" + // InternalRos1Parser.g:4278:1: rulebool returns [EObject current=null] : ( () otherlv_1= Bool ) ; + public final EObject rulebool() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4284:2: ( ( () otherlv_1= Bool ) ) + // InternalRos1Parser.g:4285:2: ( () otherlv_1= Bool ) + { + // InternalRos1Parser.g:4285:2: ( () otherlv_1= Bool ) + // InternalRos1Parser.g:4286:3: () otherlv_1= Bool + { + // InternalRos1Parser.g:4286:3: () + // InternalRos1Parser.g:4287:4: + { + + current = forceCreateModelElement( + grammarAccess.getBoolAccess().getBoolAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Bool,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getBoolAccess().getBoolKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulebool" + + + // $ANTLR start "entryRuleint8" + // InternalRos1Parser.g:4301:1: entryRuleint8 returns [EObject current=null] : iv_ruleint8= ruleint8 EOF ; + public final EObject entryRuleint8() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint8 = null; + + + try { + // InternalRos1Parser.g:4301:45: (iv_ruleint8= ruleint8 EOF ) + // InternalRos1Parser.g:4302:2: iv_ruleint8= ruleint8 EOF + { + newCompositeNode(grammarAccess.getInt8Rule()); + pushFollow(FOLLOW_1); + iv_ruleint8=ruleint8(); + + state._fsp--; + + current =iv_ruleint8; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint8" + + + // $ANTLR start "ruleint8" + // InternalRos1Parser.g:4308:1: ruleint8 returns [EObject current=null] : ( () otherlv_1= Int8 ) ; + public final EObject ruleint8() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4314:2: ( ( () otherlv_1= Int8 ) ) + // InternalRos1Parser.g:4315:2: ( () otherlv_1= Int8 ) + { + // InternalRos1Parser.g:4315:2: ( () otherlv_1= Int8 ) + // InternalRos1Parser.g:4316:3: () otherlv_1= Int8 + { + // InternalRos1Parser.g:4316:3: () + // InternalRos1Parser.g:4317:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt8Access().getInt8Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int8,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt8Access().getInt8Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint8" + + + // $ANTLR start "entryRuleuint8" + // InternalRos1Parser.g:4331:1: entryRuleuint8 returns [EObject current=null] : iv_ruleuint8= ruleuint8 EOF ; + public final EObject entryRuleuint8() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint8 = null; + + + try { + // InternalRos1Parser.g:4331:46: (iv_ruleuint8= ruleuint8 EOF ) + // InternalRos1Parser.g:4332:2: iv_ruleuint8= ruleuint8 EOF + { + newCompositeNode(grammarAccess.getUint8Rule()); + pushFollow(FOLLOW_1); + iv_ruleuint8=ruleuint8(); + + state._fsp--; + + current =iv_ruleuint8; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint8" + + + // $ANTLR start "ruleuint8" + // InternalRos1Parser.g:4338:1: ruleuint8 returns [EObject current=null] : ( () otherlv_1= Uint8 ) ; + public final EObject ruleuint8() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4344:2: ( ( () otherlv_1= Uint8 ) ) + // InternalRos1Parser.g:4345:2: ( () otherlv_1= Uint8 ) + { + // InternalRos1Parser.g:4345:2: ( () otherlv_1= Uint8 ) + // InternalRos1Parser.g:4346:3: () otherlv_1= Uint8 + { + // InternalRos1Parser.g:4346:3: () + // InternalRos1Parser.g:4347:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint8Access().getUint8Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint8,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint8Access().getUint8Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint8" + + + // $ANTLR start "entryRuleint16" + // InternalRos1Parser.g:4361:1: entryRuleint16 returns [EObject current=null] : iv_ruleint16= ruleint16 EOF ; + public final EObject entryRuleint16() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint16 = null; + + + try { + // InternalRos1Parser.g:4361:46: (iv_ruleint16= ruleint16 EOF ) + // InternalRos1Parser.g:4362:2: iv_ruleint16= ruleint16 EOF + { + newCompositeNode(grammarAccess.getInt16Rule()); + pushFollow(FOLLOW_1); + iv_ruleint16=ruleint16(); + + state._fsp--; + + current =iv_ruleint16; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint16" + + + // $ANTLR start "ruleint16" + // InternalRos1Parser.g:4368:1: ruleint16 returns [EObject current=null] : ( () otherlv_1= Int16 ) ; + public final EObject ruleint16() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4374:2: ( ( () otherlv_1= Int16 ) ) + // InternalRos1Parser.g:4375:2: ( () otherlv_1= Int16 ) + { + // InternalRos1Parser.g:4375:2: ( () otherlv_1= Int16 ) + // InternalRos1Parser.g:4376:3: () otherlv_1= Int16 + { + // InternalRos1Parser.g:4376:3: () + // InternalRos1Parser.g:4377:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt16Access().getInt16Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int16,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt16Access().getInt16Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint16" + + + // $ANTLR start "entryRuleuint16" + // InternalRos1Parser.g:4391:1: entryRuleuint16 returns [EObject current=null] : iv_ruleuint16= ruleuint16 EOF ; + public final EObject entryRuleuint16() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint16 = null; + + + try { + // InternalRos1Parser.g:4391:47: (iv_ruleuint16= ruleuint16 EOF ) + // InternalRos1Parser.g:4392:2: iv_ruleuint16= ruleuint16 EOF + { + newCompositeNode(grammarAccess.getUint16Rule()); + pushFollow(FOLLOW_1); + iv_ruleuint16=ruleuint16(); + + state._fsp--; + + current =iv_ruleuint16; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint16" + + + // $ANTLR start "ruleuint16" + // InternalRos1Parser.g:4398:1: ruleuint16 returns [EObject current=null] : ( () otherlv_1= Uint16 ) ; + public final EObject ruleuint16() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4404:2: ( ( () otherlv_1= Uint16 ) ) + // InternalRos1Parser.g:4405:2: ( () otherlv_1= Uint16 ) + { + // InternalRos1Parser.g:4405:2: ( () otherlv_1= Uint16 ) + // InternalRos1Parser.g:4406:3: () otherlv_1= Uint16 + { + // InternalRos1Parser.g:4406:3: () + // InternalRos1Parser.g:4407:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint16Access().getUint16Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint16,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint16Access().getUint16Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint16" + + + // $ANTLR start "entryRuleint32" + // InternalRos1Parser.g:4421:1: entryRuleint32 returns [EObject current=null] : iv_ruleint32= ruleint32 EOF ; + public final EObject entryRuleint32() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint32 = null; + + + try { + // InternalRos1Parser.g:4421:46: (iv_ruleint32= ruleint32 EOF ) + // InternalRos1Parser.g:4422:2: iv_ruleint32= ruleint32 EOF + { + newCompositeNode(grammarAccess.getInt32Rule()); + pushFollow(FOLLOW_1); + iv_ruleint32=ruleint32(); + + state._fsp--; + + current =iv_ruleint32; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint32" + + + // $ANTLR start "ruleint32" + // InternalRos1Parser.g:4428:1: ruleint32 returns [EObject current=null] : ( () otherlv_1= Int32 ) ; + public final EObject ruleint32() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4434:2: ( ( () otherlv_1= Int32 ) ) + // InternalRos1Parser.g:4435:2: ( () otherlv_1= Int32 ) + { + // InternalRos1Parser.g:4435:2: ( () otherlv_1= Int32 ) + // InternalRos1Parser.g:4436:3: () otherlv_1= Int32 + { + // InternalRos1Parser.g:4436:3: () + // InternalRos1Parser.g:4437:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt32Access().getInt32Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int32,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt32Access().getInt32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint32" + + + // $ANTLR start "entryRuleuint32" + // InternalRos1Parser.g:4451:1: entryRuleuint32 returns [EObject current=null] : iv_ruleuint32= ruleuint32 EOF ; + public final EObject entryRuleuint32() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint32 = null; + + + try { + // InternalRos1Parser.g:4451:47: (iv_ruleuint32= ruleuint32 EOF ) + // InternalRos1Parser.g:4452:2: iv_ruleuint32= ruleuint32 EOF + { + newCompositeNode(grammarAccess.getUint32Rule()); + pushFollow(FOLLOW_1); + iv_ruleuint32=ruleuint32(); + + state._fsp--; + + current =iv_ruleuint32; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint32" + + + // $ANTLR start "ruleuint32" + // InternalRos1Parser.g:4458:1: ruleuint32 returns [EObject current=null] : ( () otherlv_1= Uint32 ) ; + public final EObject ruleuint32() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4464:2: ( ( () otherlv_1= Uint32 ) ) + // InternalRos1Parser.g:4465:2: ( () otherlv_1= Uint32 ) + { + // InternalRos1Parser.g:4465:2: ( () otherlv_1= Uint32 ) + // InternalRos1Parser.g:4466:3: () otherlv_1= Uint32 + { + // InternalRos1Parser.g:4466:3: () + // InternalRos1Parser.g:4467:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint32Access().getUint32Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint32,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint32Access().getUint32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint32" + + + // $ANTLR start "entryRuleint64" + // InternalRos1Parser.g:4481:1: entryRuleint64 returns [EObject current=null] : iv_ruleint64= ruleint64 EOF ; + public final EObject entryRuleint64() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint64 = null; + + + try { + // InternalRos1Parser.g:4481:46: (iv_ruleint64= ruleint64 EOF ) + // InternalRos1Parser.g:4482:2: iv_ruleint64= ruleint64 EOF + { + newCompositeNode(grammarAccess.getInt64Rule()); + pushFollow(FOLLOW_1); + iv_ruleint64=ruleint64(); + + state._fsp--; + + current =iv_ruleint64; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint64" + + + // $ANTLR start "ruleint64" + // InternalRos1Parser.g:4488:1: ruleint64 returns [EObject current=null] : ( () otherlv_1= Int64 ) ; + public final EObject ruleint64() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4494:2: ( ( () otherlv_1= Int64 ) ) + // InternalRos1Parser.g:4495:2: ( () otherlv_1= Int64 ) + { + // InternalRos1Parser.g:4495:2: ( () otherlv_1= Int64 ) + // InternalRos1Parser.g:4496:3: () otherlv_1= Int64 + { + // InternalRos1Parser.g:4496:3: () + // InternalRos1Parser.g:4497:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt64Access().getInt64Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int64,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt64Access().getInt64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint64" + + + // $ANTLR start "entryRuleuint64" + // InternalRos1Parser.g:4511:1: entryRuleuint64 returns [EObject current=null] : iv_ruleuint64= ruleuint64 EOF ; + public final EObject entryRuleuint64() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint64 = null; + + + try { + // InternalRos1Parser.g:4511:47: (iv_ruleuint64= ruleuint64 EOF ) + // InternalRos1Parser.g:4512:2: iv_ruleuint64= ruleuint64 EOF + { + newCompositeNode(grammarAccess.getUint64Rule()); + pushFollow(FOLLOW_1); + iv_ruleuint64=ruleuint64(); + + state._fsp--; + + current =iv_ruleuint64; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint64" + + + // $ANTLR start "ruleuint64" + // InternalRos1Parser.g:4518:1: ruleuint64 returns [EObject current=null] : ( () otherlv_1= Uint64 ) ; + public final EObject ruleuint64() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4524:2: ( ( () otherlv_1= Uint64 ) ) + // InternalRos1Parser.g:4525:2: ( () otherlv_1= Uint64 ) + { + // InternalRos1Parser.g:4525:2: ( () otherlv_1= Uint64 ) + // InternalRos1Parser.g:4526:3: () otherlv_1= Uint64 + { + // InternalRos1Parser.g:4526:3: () + // InternalRos1Parser.g:4527:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint64Access().getUint64Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint64,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint64Access().getUint64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint64" + + + // $ANTLR start "entryRulefloat32" + // InternalRos1Parser.g:4541:1: entryRulefloat32 returns [EObject current=null] : iv_rulefloat32= rulefloat32 EOF ; + public final EObject entryRulefloat32() throws RecognitionException { + EObject current = null; + + EObject iv_rulefloat32 = null; + + + try { + // InternalRos1Parser.g:4541:48: (iv_rulefloat32= rulefloat32 EOF ) + // InternalRos1Parser.g:4542:2: iv_rulefloat32= rulefloat32 EOF + { + newCompositeNode(grammarAccess.getFloat32Rule()); + pushFollow(FOLLOW_1); + iv_rulefloat32=rulefloat32(); + + state._fsp--; + + current =iv_rulefloat32; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulefloat32" + + + // $ANTLR start "rulefloat32" + // InternalRos1Parser.g:4548:1: rulefloat32 returns [EObject current=null] : ( () otherlv_1= Float32 ) ; + public final EObject rulefloat32() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4554:2: ( ( () otherlv_1= Float32 ) ) + // InternalRos1Parser.g:4555:2: ( () otherlv_1= Float32 ) + { + // InternalRos1Parser.g:4555:2: ( () otherlv_1= Float32 ) + // InternalRos1Parser.g:4556:3: () otherlv_1= Float32 + { + // InternalRos1Parser.g:4556:3: () + // InternalRos1Parser.g:4557:4: + { + + current = forceCreateModelElement( + grammarAccess.getFloat32Access().getFloat32Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Float32,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getFloat32Access().getFloat32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulefloat32" + + + // $ANTLR start "entryRulefloat64" + // InternalRos1Parser.g:4571:1: entryRulefloat64 returns [EObject current=null] : iv_rulefloat64= rulefloat64 EOF ; + public final EObject entryRulefloat64() throws RecognitionException { + EObject current = null; + + EObject iv_rulefloat64 = null; + + + try { + // InternalRos1Parser.g:4571:48: (iv_rulefloat64= rulefloat64 EOF ) + // InternalRos1Parser.g:4572:2: iv_rulefloat64= rulefloat64 EOF + { + newCompositeNode(grammarAccess.getFloat64Rule()); + pushFollow(FOLLOW_1); + iv_rulefloat64=rulefloat64(); + + state._fsp--; + + current =iv_rulefloat64; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulefloat64" + + + // $ANTLR start "rulefloat64" + // InternalRos1Parser.g:4578:1: rulefloat64 returns [EObject current=null] : ( () otherlv_1= Float64 ) ; + public final EObject rulefloat64() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4584:2: ( ( () otherlv_1= Float64 ) ) + // InternalRos1Parser.g:4585:2: ( () otherlv_1= Float64 ) + { + // InternalRos1Parser.g:4585:2: ( () otherlv_1= Float64 ) + // InternalRos1Parser.g:4586:3: () otherlv_1= Float64 + { + // InternalRos1Parser.g:4586:3: () + // InternalRos1Parser.g:4587:4: + { + + current = forceCreateModelElement( + grammarAccess.getFloat64Access().getFloat64Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Float64,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getFloat64Access().getFloat64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulefloat64" + + + // $ANTLR start "entryRulestring0" + // InternalRos1Parser.g:4601:1: entryRulestring0 returns [EObject current=null] : iv_rulestring0= rulestring0 EOF ; + public final EObject entryRulestring0() throws RecognitionException { + EObject current = null; + + EObject iv_rulestring0 = null; + + + try { + // InternalRos1Parser.g:4601:48: (iv_rulestring0= rulestring0 EOF ) + // InternalRos1Parser.g:4602:2: iv_rulestring0= rulestring0 EOF + { + newCompositeNode(grammarAccess.getString0Rule()); + pushFollow(FOLLOW_1); + iv_rulestring0=rulestring0(); + + state._fsp--; + + current =iv_rulestring0; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulestring0" + + + // $ANTLR start "rulestring0" + // InternalRos1Parser.g:4608:1: rulestring0 returns [EObject current=null] : ( () otherlv_1= String_1 ) ; + public final EObject rulestring0() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4614:2: ( ( () otherlv_1= String_1 ) ) + // InternalRos1Parser.g:4615:2: ( () otherlv_1= String_1 ) + { + // InternalRos1Parser.g:4615:2: ( () otherlv_1= String_1 ) + // InternalRos1Parser.g:4616:3: () otherlv_1= String_1 + { + // InternalRos1Parser.g:4616:3: () + // InternalRos1Parser.g:4617:4: + { + + current = forceCreateModelElement( + grammarAccess.getString0Access().getStringAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,String_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getString0Access().getStringKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulestring0" + + + // $ANTLR start "entryRulebyte" + // InternalRos1Parser.g:4631:1: entryRulebyte returns [EObject current=null] : iv_rulebyte= rulebyte EOF ; + public final EObject entryRulebyte() throws RecognitionException { + EObject current = null; + + EObject iv_rulebyte = null; + + + try { + // InternalRos1Parser.g:4631:45: (iv_rulebyte= rulebyte EOF ) + // InternalRos1Parser.g:4632:2: iv_rulebyte= rulebyte EOF + { + newCompositeNode(grammarAccess.getByteRule()); + pushFollow(FOLLOW_1); + iv_rulebyte=rulebyte(); + + state._fsp--; + + current =iv_rulebyte; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulebyte" + + + // $ANTLR start "rulebyte" + // InternalRos1Parser.g:4638:1: rulebyte returns [EObject current=null] : ( () otherlv_1= Byte ) ; + public final EObject rulebyte() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4644:2: ( ( () otherlv_1= Byte ) ) + // InternalRos1Parser.g:4645:2: ( () otherlv_1= Byte ) + { + // InternalRos1Parser.g:4645:2: ( () otherlv_1= Byte ) + // InternalRos1Parser.g:4646:3: () otherlv_1= Byte + { + // InternalRos1Parser.g:4646:3: () + // InternalRos1Parser.g:4647:4: + { + + current = forceCreateModelElement( + grammarAccess.getByteAccess().getByteAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Byte,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getByteAccess().getByteKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulebyte" + + + // $ANTLR start "entryRuletime" + // InternalRos1Parser.g:4661:1: entryRuletime returns [EObject current=null] : iv_ruletime= ruletime EOF ; + public final EObject entryRuletime() throws RecognitionException { + EObject current = null; + + EObject iv_ruletime = null; + + + try { + // InternalRos1Parser.g:4661:45: (iv_ruletime= ruletime EOF ) + // InternalRos1Parser.g:4662:2: iv_ruletime= ruletime EOF + { + newCompositeNode(grammarAccess.getTimeRule()); + pushFollow(FOLLOW_1); + iv_ruletime=ruletime(); + + state._fsp--; + + current =iv_ruletime; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuletime" + + + // $ANTLR start "ruletime" + // InternalRos1Parser.g:4668:1: ruletime returns [EObject current=null] : ( () otherlv_1= Time ) ; + public final EObject ruletime() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4674:2: ( ( () otherlv_1= Time ) ) + // InternalRos1Parser.g:4675:2: ( () otherlv_1= Time ) + { + // InternalRos1Parser.g:4675:2: ( () otherlv_1= Time ) + // InternalRos1Parser.g:4676:3: () otherlv_1= Time + { + // InternalRos1Parser.g:4676:3: () + // InternalRos1Parser.g:4677:4: + { + + current = forceCreateModelElement( + grammarAccess.getTimeAccess().getTimeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Time,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getTimeAccess().getTimeKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruletime" + + + // $ANTLR start "entryRuleduration" + // InternalRos1Parser.g:4691:1: entryRuleduration returns [EObject current=null] : iv_ruleduration= ruleduration EOF ; + public final EObject entryRuleduration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleduration = null; + + + try { + // InternalRos1Parser.g:4691:49: (iv_ruleduration= ruleduration EOF ) + // InternalRos1Parser.g:4692:2: iv_ruleduration= ruleduration EOF + { + newCompositeNode(grammarAccess.getDurationRule()); + pushFollow(FOLLOW_1); + iv_ruleduration=ruleduration(); + + state._fsp--; + + current =iv_ruleduration; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleduration" + + + // $ANTLR start "ruleduration" + // InternalRos1Parser.g:4698:1: ruleduration returns [EObject current=null] : ( () otherlv_1= Duration ) ; + public final EObject ruleduration() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4704:2: ( ( () otherlv_1= Duration ) ) + // InternalRos1Parser.g:4705:2: ( () otherlv_1= Duration ) + { + // InternalRos1Parser.g:4705:2: ( () otherlv_1= Duration ) + // InternalRos1Parser.g:4706:3: () otherlv_1= Duration + { + // InternalRos1Parser.g:4706:3: () + // InternalRos1Parser.g:4707:4: + { + + current = forceCreateModelElement( + grammarAccess.getDurationAccess().getDurationAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Duration,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getDurationAccess().getDurationKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleduration" + + + // $ANTLR start "entryRuleboolArray" + // InternalRos1Parser.g:4721:1: entryRuleboolArray returns [EObject current=null] : iv_ruleboolArray= ruleboolArray EOF ; + public final EObject entryRuleboolArray() throws RecognitionException { + EObject current = null; + + EObject iv_ruleboolArray = null; + + + try { + // InternalRos1Parser.g:4721:50: (iv_ruleboolArray= ruleboolArray EOF ) + // InternalRos1Parser.g:4722:2: iv_ruleboolArray= ruleboolArray EOF + { + newCompositeNode(grammarAccess.getBoolArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleboolArray=ruleboolArray(); + + state._fsp--; + + current =iv_ruleboolArray; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleboolArray" + + + // $ANTLR start "ruleboolArray" + // InternalRos1Parser.g:4728:1: ruleboolArray returns [EObject current=null] : ( () otherlv_1= Bool_1 ) ; + public final EObject ruleboolArray() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4734:2: ( ( () otherlv_1= Bool_1 ) ) + // InternalRos1Parser.g:4735:2: ( () otherlv_1= Bool_1 ) + { + // InternalRos1Parser.g:4735:2: ( () otherlv_1= Bool_1 ) + // InternalRos1Parser.g:4736:3: () otherlv_1= Bool_1 + { + // InternalRos1Parser.g:4736:3: () + // InternalRos1Parser.g:4737:4: + { + + current = forceCreateModelElement( + grammarAccess.getBoolArrayAccess().getBoolArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Bool_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleboolArray" + + + // $ANTLR start "entryRuleint8Array" + // InternalRos1Parser.g:4751:1: entryRuleint8Array returns [EObject current=null] : iv_ruleint8Array= ruleint8Array EOF ; + public final EObject entryRuleint8Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint8Array = null; + + + try { + // InternalRos1Parser.g:4751:50: (iv_ruleint8Array= ruleint8Array EOF ) + // InternalRos1Parser.g:4752:2: iv_ruleint8Array= ruleint8Array EOF + { + newCompositeNode(grammarAccess.getInt8ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleint8Array=ruleint8Array(); + + state._fsp--; + + current =iv_ruleint8Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint8Array" + + + // $ANTLR start "ruleint8Array" + // InternalRos1Parser.g:4758:1: ruleint8Array returns [EObject current=null] : ( () otherlv_1= Int8_1 ) ; + public final EObject ruleint8Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4764:2: ( ( () otherlv_1= Int8_1 ) ) + // InternalRos1Parser.g:4765:2: ( () otherlv_1= Int8_1 ) + { + // InternalRos1Parser.g:4765:2: ( () otherlv_1= Int8_1 ) + // InternalRos1Parser.g:4766:3: () otherlv_1= Int8_1 + { + // InternalRos1Parser.g:4766:3: () + // InternalRos1Parser.g:4767:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int8_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint8Array" + + + // $ANTLR start "entryRuleuint8Array" + // InternalRos1Parser.g:4781:1: entryRuleuint8Array returns [EObject current=null] : iv_ruleuint8Array= ruleuint8Array EOF ; + public final EObject entryRuleuint8Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint8Array = null; + + + try { + // InternalRos1Parser.g:4781:51: (iv_ruleuint8Array= ruleuint8Array EOF ) + // InternalRos1Parser.g:4782:2: iv_ruleuint8Array= ruleuint8Array EOF + { + newCompositeNode(grammarAccess.getUint8ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleuint8Array=ruleuint8Array(); + + state._fsp--; + + current =iv_ruleuint8Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint8Array" + + + // $ANTLR start "ruleuint8Array" + // InternalRos1Parser.g:4788:1: ruleuint8Array returns [EObject current=null] : ( () otherlv_1= Uint8_1 ) ; + public final EObject ruleuint8Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4794:2: ( ( () otherlv_1= Uint8_1 ) ) + // InternalRos1Parser.g:4795:2: ( () otherlv_1= Uint8_1 ) + { + // InternalRos1Parser.g:4795:2: ( () otherlv_1= Uint8_1 ) + // InternalRos1Parser.g:4796:3: () otherlv_1= Uint8_1 + { + // InternalRos1Parser.g:4796:3: () + // InternalRos1Parser.g:4797:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint8_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint8Array" + + + // $ANTLR start "entryRuleint16Array" + // InternalRos1Parser.g:4811:1: entryRuleint16Array returns [EObject current=null] : iv_ruleint16Array= ruleint16Array EOF ; + public final EObject entryRuleint16Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint16Array = null; + + + try { + // InternalRos1Parser.g:4811:51: (iv_ruleint16Array= ruleint16Array EOF ) + // InternalRos1Parser.g:4812:2: iv_ruleint16Array= ruleint16Array EOF + { + newCompositeNode(grammarAccess.getInt16ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleint16Array=ruleint16Array(); + + state._fsp--; + + current =iv_ruleint16Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint16Array" + + + // $ANTLR start "ruleint16Array" + // InternalRos1Parser.g:4818:1: ruleint16Array returns [EObject current=null] : ( () otherlv_1= Int16_1 ) ; + public final EObject ruleint16Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4824:2: ( ( () otherlv_1= Int16_1 ) ) + // InternalRos1Parser.g:4825:2: ( () otherlv_1= Int16_1 ) + { + // InternalRos1Parser.g:4825:2: ( () otherlv_1= Int16_1 ) + // InternalRos1Parser.g:4826:3: () otherlv_1= Int16_1 + { + // InternalRos1Parser.g:4826:3: () + // InternalRos1Parser.g:4827:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int16_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint16Array" + + + // $ANTLR start "entryRuleuint16Array" + // InternalRos1Parser.g:4841:1: entryRuleuint16Array returns [EObject current=null] : iv_ruleuint16Array= ruleuint16Array EOF ; + public final EObject entryRuleuint16Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint16Array = null; + + + try { + // InternalRos1Parser.g:4841:52: (iv_ruleuint16Array= ruleuint16Array EOF ) + // InternalRos1Parser.g:4842:2: iv_ruleuint16Array= ruleuint16Array EOF + { + newCompositeNode(grammarAccess.getUint16ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleuint16Array=ruleuint16Array(); + + state._fsp--; + + current =iv_ruleuint16Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint16Array" + + + // $ANTLR start "ruleuint16Array" + // InternalRos1Parser.g:4848:1: ruleuint16Array returns [EObject current=null] : ( () otherlv_1= Uint16_1 ) ; + public final EObject ruleuint16Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4854:2: ( ( () otherlv_1= Uint16_1 ) ) + // InternalRos1Parser.g:4855:2: ( () otherlv_1= Uint16_1 ) + { + // InternalRos1Parser.g:4855:2: ( () otherlv_1= Uint16_1 ) + // InternalRos1Parser.g:4856:3: () otherlv_1= Uint16_1 + { + // InternalRos1Parser.g:4856:3: () + // InternalRos1Parser.g:4857:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint16_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint16Array" + + + // $ANTLR start "entryRuleint32Array" + // InternalRos1Parser.g:4871:1: entryRuleint32Array returns [EObject current=null] : iv_ruleint32Array= ruleint32Array EOF ; + public final EObject entryRuleint32Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint32Array = null; + + + try { + // InternalRos1Parser.g:4871:51: (iv_ruleint32Array= ruleint32Array EOF ) + // InternalRos1Parser.g:4872:2: iv_ruleint32Array= ruleint32Array EOF + { + newCompositeNode(grammarAccess.getInt32ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleint32Array=ruleint32Array(); + + state._fsp--; + + current =iv_ruleint32Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint32Array" + + + // $ANTLR start "ruleint32Array" + // InternalRos1Parser.g:4878:1: ruleint32Array returns [EObject current=null] : ( () otherlv_1= Int32_1 ) ; + public final EObject ruleint32Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4884:2: ( ( () otherlv_1= Int32_1 ) ) + // InternalRos1Parser.g:4885:2: ( () otherlv_1= Int32_1 ) + { + // InternalRos1Parser.g:4885:2: ( () otherlv_1= Int32_1 ) + // InternalRos1Parser.g:4886:3: () otherlv_1= Int32_1 + { + // InternalRos1Parser.g:4886:3: () + // InternalRos1Parser.g:4887:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int32_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint32Array" + + + // $ANTLR start "entryRuleuint32Array" + // InternalRos1Parser.g:4901:1: entryRuleuint32Array returns [EObject current=null] : iv_ruleuint32Array= ruleuint32Array EOF ; + public final EObject entryRuleuint32Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint32Array = null; + + + try { + // InternalRos1Parser.g:4901:52: (iv_ruleuint32Array= ruleuint32Array EOF ) + // InternalRos1Parser.g:4902:2: iv_ruleuint32Array= ruleuint32Array EOF + { + newCompositeNode(grammarAccess.getUint32ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleuint32Array=ruleuint32Array(); + + state._fsp--; + + current =iv_ruleuint32Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint32Array" + + + // $ANTLR start "ruleuint32Array" + // InternalRos1Parser.g:4908:1: ruleuint32Array returns [EObject current=null] : ( () otherlv_1= Uint32_1 ) ; + public final EObject ruleuint32Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4914:2: ( ( () otherlv_1= Uint32_1 ) ) + // InternalRos1Parser.g:4915:2: ( () otherlv_1= Uint32_1 ) + { + // InternalRos1Parser.g:4915:2: ( () otherlv_1= Uint32_1 ) + // InternalRos1Parser.g:4916:3: () otherlv_1= Uint32_1 + { + // InternalRos1Parser.g:4916:3: () + // InternalRos1Parser.g:4917:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint32_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint32Array" + + + // $ANTLR start "entryRuleint64Array" + // InternalRos1Parser.g:4931:1: entryRuleint64Array returns [EObject current=null] : iv_ruleint64Array= ruleint64Array EOF ; + public final EObject entryRuleint64Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint64Array = null; + + + try { + // InternalRos1Parser.g:4931:51: (iv_ruleint64Array= ruleint64Array EOF ) + // InternalRos1Parser.g:4932:2: iv_ruleint64Array= ruleint64Array EOF + { + newCompositeNode(grammarAccess.getInt64ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleint64Array=ruleint64Array(); + + state._fsp--; + + current =iv_ruleint64Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint64Array" + + + // $ANTLR start "ruleint64Array" + // InternalRos1Parser.g:4938:1: ruleint64Array returns [EObject current=null] : ( () otherlv_1= Int64_1 ) ; + public final EObject ruleint64Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4944:2: ( ( () otherlv_1= Int64_1 ) ) + // InternalRos1Parser.g:4945:2: ( () otherlv_1= Int64_1 ) + { + // InternalRos1Parser.g:4945:2: ( () otherlv_1= Int64_1 ) + // InternalRos1Parser.g:4946:3: () otherlv_1= Int64_1 + { + // InternalRos1Parser.g:4946:3: () + // InternalRos1Parser.g:4947:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int64_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint64Array" + + + // $ANTLR start "entryRuleuint64Array" + // InternalRos1Parser.g:4961:1: entryRuleuint64Array returns [EObject current=null] : iv_ruleuint64Array= ruleuint64Array EOF ; + public final EObject entryRuleuint64Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint64Array = null; + + + try { + // InternalRos1Parser.g:4961:52: (iv_ruleuint64Array= ruleuint64Array EOF ) + // InternalRos1Parser.g:4962:2: iv_ruleuint64Array= ruleuint64Array EOF + { + newCompositeNode(grammarAccess.getUint64ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleuint64Array=ruleuint64Array(); + + state._fsp--; + + current =iv_ruleuint64Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint64Array" + + + // $ANTLR start "ruleuint64Array" + // InternalRos1Parser.g:4968:1: ruleuint64Array returns [EObject current=null] : ( () otherlv_1= Uint64_1 ) ; + public final EObject ruleuint64Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:4974:2: ( ( () otherlv_1= Uint64_1 ) ) + // InternalRos1Parser.g:4975:2: ( () otherlv_1= Uint64_1 ) + { + // InternalRos1Parser.g:4975:2: ( () otherlv_1= Uint64_1 ) + // InternalRos1Parser.g:4976:3: () otherlv_1= Uint64_1 + { + // InternalRos1Parser.g:4976:3: () + // InternalRos1Parser.g:4977:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint64_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint64Array" + + + // $ANTLR start "entryRulefloat32Array" + // InternalRos1Parser.g:4991:1: entryRulefloat32Array returns [EObject current=null] : iv_rulefloat32Array= rulefloat32Array EOF ; + public final EObject entryRulefloat32Array() throws RecognitionException { + EObject current = null; + + EObject iv_rulefloat32Array = null; + + + try { + // InternalRos1Parser.g:4991:53: (iv_rulefloat32Array= rulefloat32Array EOF ) + // InternalRos1Parser.g:4992:2: iv_rulefloat32Array= rulefloat32Array EOF + { + newCompositeNode(grammarAccess.getFloat32ArrayRule()); + pushFollow(FOLLOW_1); + iv_rulefloat32Array=rulefloat32Array(); + + state._fsp--; + + current =iv_rulefloat32Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulefloat32Array" + + + // $ANTLR start "rulefloat32Array" + // InternalRos1Parser.g:4998:1: rulefloat32Array returns [EObject current=null] : ( () otherlv_1= Float32_1 ) ; + public final EObject rulefloat32Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:5004:2: ( ( () otherlv_1= Float32_1 ) ) + // InternalRos1Parser.g:5005:2: ( () otherlv_1= Float32_1 ) + { + // InternalRos1Parser.g:5005:2: ( () otherlv_1= Float32_1 ) + // InternalRos1Parser.g:5006:3: () otherlv_1= Float32_1 + { + // InternalRos1Parser.g:5006:3: () + // InternalRos1Parser.g:5007:4: + { + + current = forceCreateModelElement( + grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Float32_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulefloat32Array" + + + // $ANTLR start "entryRulefloat64Array" + // InternalRos1Parser.g:5021:1: entryRulefloat64Array returns [EObject current=null] : iv_rulefloat64Array= rulefloat64Array EOF ; + public final EObject entryRulefloat64Array() throws RecognitionException { + EObject current = null; + + EObject iv_rulefloat64Array = null; + + + try { + // InternalRos1Parser.g:5021:53: (iv_rulefloat64Array= rulefloat64Array EOF ) + // InternalRos1Parser.g:5022:2: iv_rulefloat64Array= rulefloat64Array EOF + { + newCompositeNode(grammarAccess.getFloat64ArrayRule()); + pushFollow(FOLLOW_1); + iv_rulefloat64Array=rulefloat64Array(); + + state._fsp--; + + current =iv_rulefloat64Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulefloat64Array" + + + // $ANTLR start "rulefloat64Array" + // InternalRos1Parser.g:5028:1: rulefloat64Array returns [EObject current=null] : ( () otherlv_1= Float64_1 ) ; + public final EObject rulefloat64Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:5034:2: ( ( () otherlv_1= Float64_1 ) ) + // InternalRos1Parser.g:5035:2: ( () otherlv_1= Float64_1 ) + { + // InternalRos1Parser.g:5035:2: ( () otherlv_1= Float64_1 ) + // InternalRos1Parser.g:5036:3: () otherlv_1= Float64_1 + { + // InternalRos1Parser.g:5036:3: () + // InternalRos1Parser.g:5037:4: + { + + current = forceCreateModelElement( + grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Float64_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulefloat64Array" + + + // $ANTLR start "entryRulestring0Array" + // InternalRos1Parser.g:5051:1: entryRulestring0Array returns [EObject current=null] : iv_rulestring0Array= rulestring0Array EOF ; + public final EObject entryRulestring0Array() throws RecognitionException { + EObject current = null; + + EObject iv_rulestring0Array = null; + + + try { + // InternalRos1Parser.g:5051:53: (iv_rulestring0Array= rulestring0Array EOF ) + // InternalRos1Parser.g:5052:2: iv_rulestring0Array= rulestring0Array EOF + { + newCompositeNode(grammarAccess.getString0ArrayRule()); + pushFollow(FOLLOW_1); + iv_rulestring0Array=rulestring0Array(); + + state._fsp--; + + current =iv_rulestring0Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulestring0Array" + + + // $ANTLR start "rulestring0Array" + // InternalRos1Parser.g:5058:1: rulestring0Array returns [EObject current=null] : ( () otherlv_1= String_2 ) ; + public final EObject rulestring0Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:5064:2: ( ( () otherlv_1= String_2 ) ) + // InternalRos1Parser.g:5065:2: ( () otherlv_1= String_2 ) + { + // InternalRos1Parser.g:5065:2: ( () otherlv_1= String_2 ) + // InternalRos1Parser.g:5066:3: () otherlv_1= String_2 + { + // InternalRos1Parser.g:5066:3: () + // InternalRos1Parser.g:5067:4: + { + + current = forceCreateModelElement( + grammarAccess.getString0ArrayAccess().getStringArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,String_2,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getString0ArrayAccess().getStringKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulestring0Array" + + + // $ANTLR start "entryRulebyteArray" + // InternalRos1Parser.g:5081:1: entryRulebyteArray returns [EObject current=null] : iv_rulebyteArray= rulebyteArray EOF ; + public final EObject entryRulebyteArray() throws RecognitionException { + EObject current = null; + + EObject iv_rulebyteArray = null; + + + try { + // InternalRos1Parser.g:5081:50: (iv_rulebyteArray= rulebyteArray EOF ) + // InternalRos1Parser.g:5082:2: iv_rulebyteArray= rulebyteArray EOF + { + newCompositeNode(grammarAccess.getByteArrayRule()); + pushFollow(FOLLOW_1); + iv_rulebyteArray=rulebyteArray(); + + state._fsp--; + + current =iv_rulebyteArray; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulebyteArray" + + + // $ANTLR start "rulebyteArray" + // InternalRos1Parser.g:5088:1: rulebyteArray returns [EObject current=null] : ( () otherlv_1= Byte_1 ) ; + public final EObject rulebyteArray() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:5094:2: ( ( () otherlv_1= Byte_1 ) ) + // InternalRos1Parser.g:5095:2: ( () otherlv_1= Byte_1 ) + { + // InternalRos1Parser.g:5095:2: ( () otherlv_1= Byte_1 ) + // InternalRos1Parser.g:5096:3: () otherlv_1= Byte_1 + { + // InternalRos1Parser.g:5096:3: () + // InternalRos1Parser.g:5097:4: + { + + current = forceCreateModelElement( + grammarAccess.getByteArrayAccess().getByteArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Byte_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getByteArrayAccess().getByteKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulebyteArray" + + + // $ANTLR start "entryRuleHeader" + // InternalRos1Parser.g:5111:1: entryRuleHeader returns [EObject current=null] : iv_ruleHeader= ruleHeader EOF ; + public final EObject entryRuleHeader() throws RecognitionException { + EObject current = null; + + EObject iv_ruleHeader = null; + + + try { + // InternalRos1Parser.g:5111:47: (iv_ruleHeader= ruleHeader EOF ) + // InternalRos1Parser.g:5112:2: iv_ruleHeader= ruleHeader EOF + { + newCompositeNode(grammarAccess.getHeaderRule()); + pushFollow(FOLLOW_1); + iv_ruleHeader=ruleHeader(); + + state._fsp--; + + current =iv_ruleHeader; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleHeader" + + + // $ANTLR start "ruleHeader" + // InternalRos1Parser.g:5118:1: ruleHeader returns [EObject current=null] : ( () otherlv_1= Header ) ; + public final EObject ruleHeader() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:5124:2: ( ( () otherlv_1= Header ) ) + // InternalRos1Parser.g:5125:2: ( () otherlv_1= Header ) + { + // InternalRos1Parser.g:5125:2: ( () otherlv_1= Header ) + // InternalRos1Parser.g:5126:3: () otherlv_1= Header + { + // InternalRos1Parser.g:5126:3: () + // InternalRos1Parser.g:5127:4: + { + + current = forceCreateModelElement( + grammarAccess.getHeaderAccess().getHeaderAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Header,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getHeaderAccess().getHeaderKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleHeader" + + + // $ANTLR start "entryRuleTopicSpecRef" + // InternalRos1Parser.g:5141:1: entryRuleTopicSpecRef returns [EObject current=null] : iv_ruleTopicSpecRef= ruleTopicSpecRef EOF ; + public final EObject entryRuleTopicSpecRef() throws RecognitionException { + EObject current = null; + + EObject iv_ruleTopicSpecRef = null; + + + try { + // InternalRos1Parser.g:5141:53: (iv_ruleTopicSpecRef= ruleTopicSpecRef EOF ) + // InternalRos1Parser.g:5142:2: iv_ruleTopicSpecRef= ruleTopicSpecRef EOF + { + newCompositeNode(grammarAccess.getTopicSpecRefRule()); + pushFollow(FOLLOW_1); + iv_ruleTopicSpecRef=ruleTopicSpecRef(); + + state._fsp--; + + current =iv_ruleTopicSpecRef; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleTopicSpecRef" + + + // $ANTLR start "ruleTopicSpecRef" + // InternalRos1Parser.g:5148:1: ruleTopicSpecRef returns [EObject current=null] : ( ( ruleEString ) ) ; + public final EObject ruleTopicSpecRef() throws RecognitionException { + EObject current = null; + + + enterRule(); + + try { + // InternalRos1Parser.g:5154:2: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:5155:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:5155:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:5156:3: ( ruleEString ) + { + // InternalRos1Parser.g:5156:3: ( ruleEString ) + // InternalRos1Parser.g:5157:4: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getTopicSpecRefRule()); + } + + + newCompositeNode(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); + + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleTopicSpecRef" + + + // $ANTLR start "entryRuleArrayTopicSpecRef" + // InternalRos1Parser.g:5174:1: entryRuleArrayTopicSpecRef returns [EObject current=null] : iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF ; + public final EObject entryRuleArrayTopicSpecRef() throws RecognitionException { + EObject current = null; + + EObject iv_ruleArrayTopicSpecRef = null; + + + try { + // InternalRos1Parser.g:5174:58: (iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF ) + // InternalRos1Parser.g:5175:2: iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF + { + newCompositeNode(grammarAccess.getArrayTopicSpecRefRule()); + pushFollow(FOLLOW_1); + iv_ruleArrayTopicSpecRef=ruleArrayTopicSpecRef(); + + state._fsp--; + + current =iv_ruleArrayTopicSpecRef; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleArrayTopicSpecRef" + + + // $ANTLR start "ruleArrayTopicSpecRef" + // InternalRos1Parser.g:5181:1: ruleArrayTopicSpecRef returns [EObject current=null] : ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) ; + public final EObject ruleArrayTopicSpecRef() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:5187:2: ( ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) ) + // InternalRos1Parser.g:5188:2: ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) + { + // InternalRos1Parser.g:5188:2: ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) + // InternalRos1Parser.g:5189:3: ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket + { + // InternalRos1Parser.g:5189:3: ( ( ruleEString ) ) + // InternalRos1Parser.g:5190:4: ( ruleEString ) + { + // InternalRos1Parser.g:5190:4: ( ruleEString ) + // InternalRos1Parser.g:5191:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getArrayTopicSpecRefRule()); + } + + + newCompositeNode(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); + + pushFollow(FOLLOW_53); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_1=(Token)match(input,LeftSquareBracketRightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleArrayTopicSpecRef" + + + // $ANTLR start "entryRuleKEYWORD" + // InternalRos1Parser.g:5213:1: entryRuleKEYWORD returns [String current=null] : iv_ruleKEYWORD= ruleKEYWORD EOF ; + public final String entryRuleKEYWORD() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleKEYWORD = null; + + + try { + // InternalRos1Parser.g:5213:47: (iv_ruleKEYWORD= ruleKEYWORD EOF ) + // InternalRos1Parser.g:5214:2: iv_ruleKEYWORD= ruleKEYWORD EOF + { + newCompositeNode(grammarAccess.getKEYWORDRule()); + pushFollow(FOLLOW_1); + iv_ruleKEYWORD=ruleKEYWORD(); + + state._fsp--; + + current =iv_ruleKEYWORD.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleKEYWORD" + + + // $ANTLR start "ruleKEYWORD" + // InternalRos1Parser.g:5220:1: ruleKEYWORD returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) ; + public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:5226:2: ( (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) ) + // InternalRos1Parser.g:5227:2: (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) + { + // InternalRos1Parser.g:5227:2: (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) + int alt62=11; + switch ( input.LA(1) ) { + case Goal: + { + alt62=1; + } + break; + case Message: + { + alt62=2; + } + break; + case Result: + { + alt62=3; + } + break; + case Feedback: + { + alt62=4; + } + break; + case Name: + { + alt62=5; + } + break; + case Value: + { + alt62=6; + } + break; + case Service: + { + alt62=7; + } + break; + case Type: + { + alt62=8; + } + break; + case Action: + { + alt62=9; + } + break; + case Duration: + { + alt62=10; + } + break; + case Time: + { + alt62=11; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 62, 0, input); + + throw nvae; + } + + switch (alt62) { + case 1 : + // InternalRos1Parser.g:5228:3: kw= Goal + { + kw=(Token)match(input,Goal,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); + + + } + break; + case 2 : + // InternalRos1Parser.g:5234:3: kw= Message + { + kw=(Token)match(input,Message,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); + + + } + break; + case 3 : + // InternalRos1Parser.g:5240:3: kw= Result + { + kw=(Token)match(input,Result,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getResultKeyword_2()); + + + } + break; + case 4 : + // InternalRos1Parser.g:5246:3: kw= Feedback + { + kw=(Token)match(input,Feedback,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); + + + } + break; + case 5 : + // InternalRos1Parser.g:5252:3: kw= Name + { + kw=(Token)match(input,Name,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getNameKeyword_4()); + + + } + break; + case 6 : + // InternalRos1Parser.g:5258:3: kw= Value + { + kw=(Token)match(input,Value,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getValueKeyword_5()); + + + } + break; + case 7 : + // InternalRos1Parser.g:5264:3: kw= Service + { + kw=(Token)match(input,Service,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); + + + } + break; + case 8 : + // InternalRos1Parser.g:5270:3: kw= Type + { + kw=(Token)match(input,Type,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); + + + } + break; + case 9 : + // InternalRos1Parser.g:5276:3: kw= Action + { + kw=(Token)match(input,Action,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getActionKeyword_8()); + + + } + break; + case 10 : + // InternalRos1Parser.g:5282:3: kw= Duration + { + kw=(Token)match(input,Duration,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); + + + } + break; + case 11 : + // InternalRos1Parser.g:5288:3: kw= Time + { + kw=(Token)match(input,Time,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleKEYWORD" + + // Delegated rules + + + protected DFA61 dfa61 = new DFA61(this); + static final String dfa_1s = "\42\uffff"; + static final String dfa_2s = "\36\uffff\2\41\2\uffff"; + static final String dfa_3s = "\1\27\35\uffff\2\32\2\uffff"; + static final String dfa_4s = "\1\140\35\uffff\2\156\2\uffff"; + static final String dfa_5s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\2\uffff\1\37\1\36"; + static final String dfa_6s = "\42\uffff}>"; + static final String[] dfa_7s = { + "\1\32\1\33\1\uffff\1\17\3\uffff\1\34\1\25\1\27\1\31\4\uffff\1\12\1\13\1\24\1\26\1\30\3\uffff\1\23\3\uffff\1\20\3\uffff\1\21\1\35\1\22\2\uffff\1\14\1\5\1\7\1\11\1\uffff\1\4\1\6\1\10\2\uffff\1\3\3\uffff\1\1\1\15\1\uffff\1\2\4\uffff\1\16\14\uffff\1\37\1\uffff\1\36", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\2\41\17\uffff\1\41\1\uffff\1\41\7\uffff\1\41\3\uffff\1\41\14\uffff\1\41\4\uffff\1\41\2\uffff\1\41\2\uffff\2\41\2\uffff\1\40\10\uffff\1\41\1\uffff\1\41\15\uffff\1\41", + "\2\41\17\uffff\1\41\1\uffff\1\41\7\uffff\1\41\3\uffff\1\41\14\uffff\1\41\4\uffff\1\41\2\uffff\1\41\2\uffff\2\41\2\uffff\1\40\10\uffff\1\41\1\uffff\1\41\15\uffff\1\41", + "", + "" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s); + static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s); + + class DFA61 extends DFA { + + public DFA61(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 61; + this.eot = dfa_1; + this.eof = dfa_2; + this.min = dfa_3; + this.max = dfa_4; + this.accept = dfa_5; + this.special = dfa_6; + this.transition = dfa_7; + } + public String getDescription() { + return "3988:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef )"; + } + } + + + 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[]{0x0000000000000000L,0x0000000000800000L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000112000L,0x0000000010000000L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000000000L,0x0000000140000000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000102000L,0x0000000010000000L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000000L,0x00000000D0008000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000002000L,0x0000000010000000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000020L,0x0000000140000000L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0000000002400000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0400000000012000L,0x0000000010000000L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0400000000002000L,0x0000000010000000L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000001000000000L,0x0000000010012000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000008L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000000000L,0x00000000C0008000L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x00000000000E1E00L,0x0000000010000000L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000000L,0x0000000150000000L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x000C000000000000L,0x0000000140000000L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000010000000L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000000000L,0x0000000018000000L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x79C447C3C5800000L,0x0000000150021627L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000020000000L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000002000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000002000000L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x8000000000000000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000100000000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000100000000000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000400000L,0x0000000008000000L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000400000L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x79C447C3C5800002L,0x0000000140021627L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x00000000000001C0L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000002L,0x0000000001000000L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000200000L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x001B800C00000000L,0x0000000000000100L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000002000000002L}); + public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000000L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x0000004000000000L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000002000000000L,0x0000000010000000L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000000000L,0x0000007941000000L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L}); + public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x022028000C000000L,0x0000400140064840L}); + public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); + +} \ 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..7a07c1570 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.tokens @@ -0,0 +1,110 @@ +','=86 +':'=87 +'AmentPackage'=14 +'Any'=83 +'Array:'=47 +'Base64'=48 +'Boolean'=34 +'Date'=71 +'Double'=49 +'ExternalDependency'=5 +'GlobalNamespace'=8 +'GraphName'=21 +'Header'=50 +'Integer'=35 +'List'=72 +'ParameterAny'=15 +'ParameterStructMember'=4 +'PrivateNamespace'=7 +'RelativeNamespace'=6 +'String'=51 +'Struct'=52 +'['=88 +'[]'=85 +']'=89 +'action'=53 +'action:'=36 +'actionclient:'=11 +'actionserver:'=12 +'artifacts:'=20 +'bool'=73 +'bool[]'=54 +'byte'=74 +'byte[]'=55 +'default'=37 +'dependencies:'=13 +'duration'=26 +'feedback'=27 +'feedback:'=22 +'float32'=38 +'float32[]'=23 +'float64'=39 +'float64[]'=24 +'fromGitRepo:'=16 +'goal'=75 +'goal:'=63 +'int16'=64 +'int16[]'=40 +'int32'=65 +'int32[]'=41 +'int64'=66 +'int64[]'=42 +'int8'=76 +'int8[]'=56 +'message'=43 +'message:'=28 +'msg:'=77 +'name'=78 +'node'=79 +'node:'=67 +'ns:'=84 +'parameters:'=18 +'publishers:'=19 +'request:'=29 +'response:'=25 +'result'=57 +'result:'=44 +'service'=45 +'serviceclient:'=9 +'serviceserver:'=10 +'specs:'=58 +'srv:'=80 +'string'=59 +'string[]'=30 +'subscribers:'=17 +'time'=81 +'type'=82 +'type:'=68 +'uint16'=60 +'uint16[]'=31 +'uint32'=61 +'uint32[]'=32 +'uint64'=62 +'uint64[]'=33 +'uint8'=69 +'uint8[]'=46 +'value'=70 +'}'=90 +RULE_ANY_OTHER=113 +RULE_BEGIN=91 +RULE_BINARY=99 +RULE_BOOLEAN=100 +RULE_DATE_TIME=108 +RULE_DAY=103 +RULE_DECINT=101 +RULE_DIGIT=98 +RULE_DOUBLE=102 +RULE_END=92 +RULE_HOUR=106 +RULE_ID=94 +RULE_INT=109 +RULE_MESSAGE_ASIGMENT=110 +RULE_MIN_SEC=107 +RULE_ML_COMMENT=111 +RULE_MONTH=104 +RULE_ROS_CONVENTION_A=95 +RULE_ROS_CONVENTION_PARAM=97 +RULE_SL_COMMENT=93 +RULE_STRING=96 +RULE_WS=112 +RULE_YEAR=105 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..2f3b099fa --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.g @@ -0,0 +1,232 @@ +/* + * 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; +} + +ParameterStructMember : 'ParameterStructMember'; + +ExternalDependency : 'ExternalDependency'; + +RelativeNamespace : 'RelativeNamespace'; + +PrivateNamespace : 'PrivateNamespace'; + +GlobalNamespace : 'GlobalNamespace'; + +Serviceclient : 'serviceclient:'; + +Serviceserver : 'serviceserver:'; + +Actionclient : 'actionclient:'; + +Actionserver : 'actionserver:'; + +Dependencies : 'dependencies:'; + +AmentPackage : 'AmentPackage'; + +ParameterAny : 'ParameterAny'; + +FromGitRepo : 'fromGitRepo:'; + +Subscribers : 'subscribers:'; + +Parameters : 'parameters:'; + +Publishers : 'publishers:'; + +Artifacts : 'artifacts:'; + +GraphName : 'GraphName'; + +Feedback_1 : 'feedback:'; + +Float32_1 : 'float32[]'; + +Float64_1 : 'float64[]'; + +Response : 'response:'; + +Duration : 'duration'; + +Feedback : 'feedback'; + +Message_1 : 'message:'; + +Request : 'request:'; + +String_2 : 'string[]'; + +Uint16_1 : 'uint16[]'; + +Uint32_1 : 'uint32[]'; + +Uint64_1 : 'uint64[]'; + +Boolean : 'Boolean'; + +Integer : 'Integer'; + +Action_1 : 'action:'; + +Default : 'default'; + +Float32 : 'float32'; + +Float64 : 'float64'; + +Int16_1 : 'int16[]'; + +Int32_1 : 'int32[]'; + +Int64_1 : 'int64[]'; + +Message : 'message'; + +Result_1 : 'result:'; + +Service : 'service'; + +Uint8_1 : 'uint8[]'; + +Array : 'Array:'; + +Base64 : 'Base64'; + +Double : 'Double'; + +Header : 'Header'; + +String : 'String'; + +Struct : 'Struct'; + +Action : 'action'; + +Bool_1 : 'bool[]'; + +Byte_1 : 'byte[]'; + +Int8_1 : 'int8[]'; + +Result : 'result'; + +Specs : 'specs:'; + +String_1 : 'string'; + +Uint16 : 'uint16'; + +Uint32 : 'uint32'; + +Uint64 : 'uint64'; + +Goal_1 : 'goal:'; + +Int16 : 'int16'; + +Int32 : 'int32'; + +Int64 : 'int64'; + +Node_1 : 'node:'; + +Type_1 : 'type:'; + +Uint8 : 'uint8'; + +Value : 'value'; + +Date : 'Date'; + +List : 'List'; + +Bool : 'bool'; + +Byte : 'byte'; + +Goal : 'goal'; + +Int8 : 'int8'; + +Msg : 'msg:'; + +Name : 'name'; + +Node : 'node'; + +Srv : 'srv:'; + +Time : 'time'; + +Type : 'type'; + +Any : 'Any'; + +Ns : 'ns:'; + +LeftSquareBracketRightSquareBracket : '[]'; + +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)*; + +fragment RULE_DIGIT : '0'..'9'; + +RULE_BINARY : ('0b'|'0B') ('0'|'1')+; + +RULE_BOOLEAN : ('true'|'false'); + +RULE_DOUBLE : RULE_DIGIT ('.' RULE_DECINT*|('.' RULE_DIGIT*)? ('E'|'e') ('-'|'+')? RULE_DIGIT); + +RULE_DECINT : ('0'|'1'..'9' RULE_DIGIT*|'-' '0'..'9' RULE_DIGIT*); + +fragment RULE_DAY : ('1'..'9'|'1'..'3' '0'..'9'); + +fragment RULE_MONTH : ('1'..'9'|'1' '0'..'2'); + +fragment RULE_YEAR : '0'..'2' '0'..'9' '0'..'9' '0'..'9'; + +fragment RULE_HOUR : ('0'..'1' '0'..'9'|'2' '0'..'3'); + +fragment RULE_MIN_SEC : '0'..'5' '0'..'9'; + +RULE_DATE_TIME : RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC; + +RULE_MESSAGE_ASIGMENT : (RULE_ID|RULE_STRING) '=' (RULE_ID|RULE_STRING|RULE_INT|'-' RULE_INT); + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + +fragment 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..a0e49af00 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.java @@ -0,0 +1,4967 @@ +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 Float32_1=23; + public static final int Node=79; + public static final int RULE_DATE_TIME=108; + public static final int Uint64_1=33; + public static final int String=51; + public static final int Int16=64; + public static final int Float32=38; + public static final int Goal=75; + public static final int Bool=73; + public static final int Uint16=60; + public static final int Boolean=34; + public static final int ExternalDependency=5; + public static final int Uint8=69; + public static final int Parameters=18; + public static final int RULE_ID=94; + public static final int AmentPackage=14; + public static final int Actionclient=11; + public static final int RULE_DIGIT=98; + public static final int GlobalNamespace=8; + public static final int Artifacts=20; + public static final int Node_1=67; + public static final int Int16_1=40; + public static final int Header=50; + public static final int RULE_INT=109; + public static final int Byte=74; + public static final int RULE_ML_COMMENT=111; + public static final int LeftSquareBracket=88; + public static final int Specs=58; + public static final int Base64=48; + public static final int Message_1=28; + public static final int Comma=86; + public static final int RULE_MESSAGE_ASIGMENT=110; + public static final int Goal_1=63; + public static final int LeftSquareBracketRightSquareBracket=85; + public static final int Int32=65; + public static final int Publishers=19; + public static final int Serviceserver=10; + public static final int RightCurlyBracket=90; + public static final int RULE_DECINT=101; + public static final int Uint32=61; + public static final int FromGitRepo=16; + public static final int Msg=77; + public static final int RULE_HOUR=106; + public static final int Int8=76; + public static final int Default=37; + public static final int Actionserver=12; + public static final int Int8_1=56; + public static final int Uint16_1=31; + public static final int Type=82; + public static final int Float64=39; + public static final int Int32_1=41; + public static final int Result_1=44; + public static final int RULE_BINARY=99; + public static final int String_1=59; + public static final int Subscribers=17; + public static final int String_2=30; + public static final int RULE_BEGIN=91; + public static final int RULE_DAY=103; + public static final int RULE_BOOLEAN=100; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=105; + public static final int Feedback_1=22; + public static final int Result=57; + public static final int Name=78; + public static final int RULE_MIN_SEC=107; + public static final int ParameterAny=15; + public static final int List=72; + public static final int Dependencies=13; + public static final int RightSquareBracket=89; + public static final int PrivateNamespace=7; + public static final int GraphName=21; + public static final int Byte_1=55; + public static final int Float64_1=24; + public static final int Duration=26; + public static final int Uint32_1=32; + public static final int Action_1=36; + public static final int Double=49; + public static final int Type_1=68; + public static final int Value=70; + public static final int Uint64=62; + public static final int Action=53; + public static final int RULE_END=92; + public static final int Message=43; + public static final int Time=81; + public static final int RULE_STRING=96; + public static final int Bool_1=54; + public static final int Any=83; + public static final int Struct=52; + public static final int RULE_SL_COMMENT=93; + public static final int Uint8_1=46; + public static final int RULE_DOUBLE=102; + public static final int Feedback=27; + public static final int ParameterStructMember=4; + public static final int Srv=80; + public static final int RULE_ROS_CONVENTION_A=95; + public static final int RULE_ROS_CONVENTION_PARAM=97; + public static final int Colon=87; + public static final int EOF=-1; + public static final int Ns=84; + public static final int RULE_WS=112; + public static final int Request=29; + public static final int Int64_1=42; + public static final int Service=45; + public static final int RULE_ANY_OTHER=113; + public static final int Date=71; + public static final int Response=25; + public static final int Integer=35; + public static final int Array=47; + public static final int Serviceclient=9; + public static final int Int64=66; + public static final int RULE_MONTH=104; + + // 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 "ParameterStructMember" + public final void mParameterStructMember() throws RecognitionException { + try { + int _type = ParameterStructMember; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:14:23: ( 'ParameterStructMember' ) + // InternalRos1Lexer.g:14:25: 'ParameterStructMember' + { + match("ParameterStructMember"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterStructMember" + + // $ANTLR start "ExternalDependency" + public final void mExternalDependency() throws RecognitionException { + try { + int _type = ExternalDependency; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:16:20: ( 'ExternalDependency' ) + // InternalRos1Lexer.g:16:22: 'ExternalDependency' + { + match("ExternalDependency"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ExternalDependency" + + // $ANTLR start "RelativeNamespace" + public final void mRelativeNamespace() throws RecognitionException { + try { + int _type = RelativeNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:18:19: ( 'RelativeNamespace' ) + // InternalRos1Lexer.g:18:21: 'RelativeNamespace' + { + match("RelativeNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RelativeNamespace" + + // $ANTLR start "PrivateNamespace" + public final void mPrivateNamespace() throws RecognitionException { + try { + int _type = PrivateNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:20:18: ( 'PrivateNamespace' ) + // InternalRos1Lexer.g:20:20: 'PrivateNamespace' + { + match("PrivateNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PrivateNamespace" + + // $ANTLR start "GlobalNamespace" + public final void mGlobalNamespace() throws RecognitionException { + try { + int _type = GlobalNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:22:17: ( 'GlobalNamespace' ) + // InternalRos1Lexer.g:22:19: 'GlobalNamespace' + { + match("GlobalNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GlobalNamespace" + + // $ANTLR start "Serviceclient" + public final void mServiceclient() throws RecognitionException { + try { + int _type = Serviceclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:24:15: ( 'serviceclient:' ) + // InternalRos1Lexer.g:24:17: 'serviceclient:' + { + match("serviceclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceclient" + + // $ANTLR start "Serviceserver" + public final void mServiceserver() throws RecognitionException { + try { + int _type = Serviceserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:26:15: ( 'serviceserver:' ) + // InternalRos1Lexer.g:26:17: 'serviceserver:' + { + match("serviceserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceserver" + + // $ANTLR start "Actionclient" + public final void mActionclient() throws RecognitionException { + try { + int _type = Actionclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:28:14: ( 'actionclient:' ) + // InternalRos1Lexer.g:28:16: 'actionclient:' + { + match("actionclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionclient" + + // $ANTLR start "Actionserver" + public final void mActionserver() throws RecognitionException { + try { + int _type = Actionserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:30:14: ( 'actionserver:' ) + // InternalRos1Lexer.g:30:16: 'actionserver:' + { + match("actionserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionserver" + + // $ANTLR start "Dependencies" + public final void mDependencies() throws RecognitionException { + try { + int _type = Dependencies; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:32:14: ( 'dependencies:' ) + // InternalRos1Lexer.g:32:16: 'dependencies:' + { + match("dependencies:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Dependencies" + + // $ANTLR start "AmentPackage" + public final void mAmentPackage() throws RecognitionException { + try { + int _type = AmentPackage; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:34:14: ( 'AmentPackage' ) + // InternalRos1Lexer.g:34:16: 'AmentPackage' + { + match("AmentPackage"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "AmentPackage" + + // $ANTLR start "ParameterAny" + public final void mParameterAny() throws RecognitionException { + try { + int _type = ParameterAny; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:36:14: ( 'ParameterAny' ) + // InternalRos1Lexer.g:36:16: 'ParameterAny' + { + match("ParameterAny"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterAny" + + // $ANTLR start "FromGitRepo" + public final void mFromGitRepo() throws RecognitionException { + try { + int _type = FromGitRepo; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:38:13: ( 'fromGitRepo:' ) + // InternalRos1Lexer.g:38: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:40:13: ( 'subscribers:' ) + // InternalRos1Lexer.g:40: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:42:12: ( 'parameters:' ) + // InternalRos1Lexer.g:42: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:44:12: ( 'publishers:' ) + // InternalRos1Lexer.g:44: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:46:11: ( 'artifacts:' ) + // InternalRos1Lexer.g:46:13: 'artifacts:' + { + match("artifacts:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Artifacts" + + // $ANTLR start "GraphName" + public final void mGraphName() throws RecognitionException { + try { + int _type = GraphName; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:48:11: ( 'GraphName' ) + // InternalRos1Lexer.g:48:13: 'GraphName' + { + match("GraphName"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GraphName" + + // $ANTLR start "Feedback_1" + public final void mFeedback_1() throws RecognitionException { + try { + int _type = Feedback_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:50:12: ( 'feedback:' ) + // InternalRos1Lexer.g:50:14: 'feedback:' + { + match("feedback:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback_1" + + // $ANTLR start "Float32_1" + public final void mFloat32_1() throws RecognitionException { + try { + int _type = Float32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:52:11: ( 'float32[]' ) + // InternalRos1Lexer.g:52:13: 'float32[]' + { + match("float32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32_1" + + // $ANTLR start "Float64_1" + public final void mFloat64_1() throws RecognitionException { + try { + int _type = Float64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:54:11: ( 'float64[]' ) + // InternalRos1Lexer.g:54:13: 'float64[]' + { + match("float64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64_1" + + // $ANTLR start "Response" + public final void mResponse() throws RecognitionException { + try { + int _type = Response; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:56:10: ( 'response:' ) + // InternalRos1Lexer.g:56:12: 'response:' + { + match("response:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Response" + + // $ANTLR start "Duration" + public final void mDuration() throws RecognitionException { + try { + int _type = Duration; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:58:10: ( 'duration' ) + // InternalRos1Lexer.g:58:12: 'duration' + { + match("duration"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Duration" + + // $ANTLR start "Feedback" + public final void mFeedback() throws RecognitionException { + try { + int _type = Feedback; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:60:10: ( 'feedback' ) + // InternalRos1Lexer.g:60:12: 'feedback' + { + match("feedback"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback" + + // $ANTLR start "Message_1" + public final void mMessage_1() throws RecognitionException { + try { + int _type = Message_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:62:11: ( 'message:' ) + // InternalRos1Lexer.g:62:13: 'message:' + { + match("message:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message_1" + + // $ANTLR start "Request" + public final void mRequest() throws RecognitionException { + try { + int _type = Request; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:64:9: ( 'request:' ) + // InternalRos1Lexer.g:64:11: 'request:' + { + match("request:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Request" + + // $ANTLR start "String_2" + public final void mString_2() throws RecognitionException { + try { + int _type = String_2; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:66:10: ( 'string[]' ) + // InternalRos1Lexer.g:66:12: 'string[]' + { + match("string[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_2" + + // $ANTLR start "Uint16_1" + public final void mUint16_1() throws RecognitionException { + try { + int _type = Uint16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:68:10: ( 'uint16[]' ) + // InternalRos1Lexer.g:68:12: 'uint16[]' + { + match("uint16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16_1" + + // $ANTLR start "Uint32_1" + public final void mUint32_1() throws RecognitionException { + try { + int _type = Uint32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:70:10: ( 'uint32[]' ) + // InternalRos1Lexer.g:70:12: 'uint32[]' + { + match("uint32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32_1" + + // $ANTLR start "Uint64_1" + public final void mUint64_1() throws RecognitionException { + try { + int _type = Uint64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:72:10: ( 'uint64[]' ) + // InternalRos1Lexer.g:72:12: 'uint64[]' + { + match("uint64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64_1" + + // $ANTLR start "Boolean" + public final void mBoolean() throws RecognitionException { + try { + int _type = Boolean; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:74:9: ( 'Boolean' ) + // InternalRos1Lexer.g:74:11: 'Boolean' + { + match("Boolean"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Boolean" + + // $ANTLR start "Integer" + public final void mInteger() throws RecognitionException { + try { + int _type = Integer; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:76:9: ( 'Integer' ) + // InternalRos1Lexer.g:76:11: 'Integer' + { + match("Integer"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Integer" + + // $ANTLR start "Action_1" + public final void mAction_1() throws RecognitionException { + try { + int _type = Action_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:78:10: ( 'action:' ) + // InternalRos1Lexer.g:78:12: 'action:' + { + match("action:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action_1" + + // $ANTLR start "Default" + public final void mDefault() throws RecognitionException { + try { + int _type = Default; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:80:9: ( 'default' ) + // InternalRos1Lexer.g:80:11: 'default' + { + match("default"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Default" + + // $ANTLR start "Float32" + public final void mFloat32() throws RecognitionException { + try { + int _type = Float32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:82:9: ( 'float32' ) + // InternalRos1Lexer.g:82:11: 'float32' + { + match("float32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32" + + // $ANTLR start "Float64" + public final void mFloat64() throws RecognitionException { + try { + int _type = Float64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:84:9: ( 'float64' ) + // InternalRos1Lexer.g:84:11: 'float64' + { + match("float64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64" + + // $ANTLR start "Int16_1" + public final void mInt16_1() throws RecognitionException { + try { + int _type = Int16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:86:9: ( 'int16[]' ) + // InternalRos1Lexer.g:86:11: 'int16[]' + { + match("int16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16_1" + + // $ANTLR start "Int32_1" + public final void mInt32_1() throws RecognitionException { + try { + int _type = Int32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:88:9: ( 'int32[]' ) + // InternalRos1Lexer.g:88:11: 'int32[]' + { + match("int32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32_1" + + // $ANTLR start "Int64_1" + public final void mInt64_1() throws RecognitionException { + try { + int _type = Int64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:90:9: ( 'int64[]' ) + // InternalRos1Lexer.g:90:11: 'int64[]' + { + match("int64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64_1" + + // $ANTLR start "Message" + public final void mMessage() throws RecognitionException { + try { + int _type = Message; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:92:9: ( 'message' ) + // InternalRos1Lexer.g:92:11: 'message' + { + match("message"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message" + + // $ANTLR start "Result_1" + public final void mResult_1() throws RecognitionException { + try { + int _type = Result_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:94:10: ( 'result:' ) + // InternalRos1Lexer.g:94:12: 'result:' + { + match("result:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result_1" + + // $ANTLR start "Service" + public final void mService() throws RecognitionException { + try { + int _type = Service; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:96:9: ( 'service' ) + // InternalRos1Lexer.g:96:11: 'service' + { + match("service"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Service" + + // $ANTLR start "Uint8_1" + public final void mUint8_1() throws RecognitionException { + try { + int _type = Uint8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:98:9: ( 'uint8[]' ) + // InternalRos1Lexer.g:98:11: 'uint8[]' + { + match("uint8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8_1" + + // $ANTLR start "Array" + public final void mArray() throws RecognitionException { + try { + int _type = Array; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:100:7: ( 'Array:' ) + // InternalRos1Lexer.g:100:9: 'Array:' + { + match("Array:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Array" + + // $ANTLR start "Base64" + public final void mBase64() throws RecognitionException { + try { + int _type = Base64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:102:8: ( 'Base64' ) + // InternalRos1Lexer.g:102:10: 'Base64' + { + match("Base64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Base64" + + // $ANTLR start "Double" + public final void mDouble() throws RecognitionException { + try { + int _type = Double; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:104:8: ( 'Double' ) + // InternalRos1Lexer.g:104:10: 'Double' + { + match("Double"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Double" + + // $ANTLR start "Header" + public final void mHeader() throws RecognitionException { + try { + int _type = Header; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:106:8: ( 'Header' ) + // InternalRos1Lexer.g:106:10: 'Header' + { + match("Header"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Header" + + // $ANTLR start "String" + public final void mString() throws RecognitionException { + try { + int _type = String; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:108:8: ( 'String' ) + // InternalRos1Lexer.g:108:10: 'String' + { + match("String"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String" + + // $ANTLR start "Struct" + public final void mStruct() throws RecognitionException { + try { + int _type = Struct; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:110:8: ( 'Struct' ) + // InternalRos1Lexer.g:110:10: 'Struct' + { + match("Struct"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Struct" + + // $ANTLR start "Action" + public final void mAction() throws RecognitionException { + try { + int _type = Action; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:112:8: ( 'action' ) + // InternalRos1Lexer.g:112:10: 'action' + { + match("action"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action" + + // $ANTLR start "Bool_1" + public final void mBool_1() throws RecognitionException { + try { + int _type = Bool_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:114:8: ( 'bool[]' ) + // InternalRos1Lexer.g:114:10: 'bool[]' + { + match("bool[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool_1" + + // $ANTLR start "Byte_1" + public final void mByte_1() throws RecognitionException { + try { + int _type = Byte_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:116:8: ( 'byte[]' ) + // InternalRos1Lexer.g:116:10: 'byte[]' + { + match("byte[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte_1" + + // $ANTLR start "Int8_1" + public final void mInt8_1() throws RecognitionException { + try { + int _type = Int8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:118:8: ( 'int8[]' ) + // InternalRos1Lexer.g:118:10: 'int8[]' + { + match("int8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8_1" + + // $ANTLR start "Result" + public final void mResult() throws RecognitionException { + try { + int _type = Result; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:120:8: ( 'result' ) + // InternalRos1Lexer.g:120:10: 'result' + { + match("result"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result" + + // $ANTLR start "Specs" + public final void mSpecs() throws RecognitionException { + try { + int _type = Specs; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:122:7: ( 'specs:' ) + // InternalRos1Lexer.g:122:9: 'specs:' + { + match("specs:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Specs" + + // $ANTLR start "String_1" + public final void mString_1() throws RecognitionException { + try { + int _type = String_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:124:10: ( 'string' ) + // InternalRos1Lexer.g:124:12: 'string' + { + match("string"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_1" + + // $ANTLR start "Uint16" + public final void mUint16() throws RecognitionException { + try { + int _type = Uint16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:126:8: ( 'uint16' ) + // InternalRos1Lexer.g:126:10: 'uint16' + { + match("uint16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16" + + // $ANTLR start "Uint32" + public final void mUint32() throws RecognitionException { + try { + int _type = Uint32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:128:8: ( 'uint32' ) + // InternalRos1Lexer.g:128:10: 'uint32' + { + match("uint32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32" + + // $ANTLR start "Uint64" + public final void mUint64() throws RecognitionException { + try { + int _type = Uint64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:130:8: ( 'uint64' ) + // InternalRos1Lexer.g:130:10: 'uint64' + { + match("uint64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64" + + // $ANTLR start "Goal_1" + public final void mGoal_1() throws RecognitionException { + try { + int _type = Goal_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:132:8: ( 'goal:' ) + // InternalRos1Lexer.g:132:10: 'goal:' + { + match("goal:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal_1" + + // $ANTLR start "Int16" + public final void mInt16() throws RecognitionException { + try { + int _type = Int16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:134:7: ( 'int16' ) + // InternalRos1Lexer.g:134:9: 'int16' + { + match("int16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16" + + // $ANTLR start "Int32" + public final void mInt32() throws RecognitionException { + try { + int _type = Int32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:136:7: ( 'int32' ) + // InternalRos1Lexer.g:136:9: 'int32' + { + match("int32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32" + + // $ANTLR start "Int64" + public final void mInt64() throws RecognitionException { + try { + int _type = Int64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:138:7: ( 'int64' ) + // InternalRos1Lexer.g:138:9: 'int64' + { + match("int64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64" + + // $ANTLR start "Node_1" + public final void mNode_1() throws RecognitionException { + try { + int _type = Node_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:140:8: ( 'node:' ) + // InternalRos1Lexer.g:140:10: 'node:' + { + match("node:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node_1" + + // $ANTLR start "Type_1" + public final void mType_1() throws RecognitionException { + try { + int _type = Type_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:142:8: ( 'type:' ) + // InternalRos1Lexer.g:142:10: 'type:' + { + match("type:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type_1" + + // $ANTLR start "Uint8" + public final void mUint8() throws RecognitionException { + try { + int _type = Uint8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:144:7: ( 'uint8' ) + // InternalRos1Lexer.g:144:9: 'uint8' + { + match("uint8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8" + + // $ANTLR start "Value" + public final void mValue() throws RecognitionException { + try { + int _type = Value; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:146:7: ( 'value' ) + // InternalRos1Lexer.g:146:9: 'value' + { + match("value"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Value" + + // $ANTLR start "Date" + public final void mDate() throws RecognitionException { + try { + int _type = Date; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:148:6: ( 'Date' ) + // InternalRos1Lexer.g:148:8: 'Date' + { + match("Date"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Date" + + // $ANTLR start "List" + public final void mList() throws RecognitionException { + try { + int _type = List; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:150:6: ( 'List' ) + // InternalRos1Lexer.g:150:8: 'List' + { + match("List"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "List" + + // $ANTLR start "Bool" + public final void mBool() throws RecognitionException { + try { + int _type = Bool; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:152:6: ( 'bool' ) + // InternalRos1Lexer.g:152:8: 'bool' + { + match("bool"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool" + + // $ANTLR start "Byte" + public final void mByte() throws RecognitionException { + try { + int _type = Byte; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:154:6: ( 'byte' ) + // InternalRos1Lexer.g:154:8: 'byte' + { + match("byte"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte" + + // $ANTLR start "Goal" + public final void mGoal() throws RecognitionException { + try { + int _type = Goal; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:156:6: ( 'goal' ) + // InternalRos1Lexer.g:156:8: 'goal' + { + match("goal"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal" + + // $ANTLR start "Int8" + public final void mInt8() throws RecognitionException { + try { + int _type = Int8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:158:6: ( 'int8' ) + // InternalRos1Lexer.g:158:8: 'int8' + { + match("int8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8" + + // $ANTLR start "Msg" + public final void mMsg() throws RecognitionException { + try { + int _type = Msg; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:160:5: ( 'msg:' ) + // InternalRos1Lexer.g:160:7: 'msg:' + { + match("msg:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Msg" + + // $ANTLR start "Name" + public final void mName() throws RecognitionException { + try { + int _type = Name; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:162:6: ( 'name' ) + // InternalRos1Lexer.g:162:8: 'name' + { + match("name"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Name" + + // $ANTLR start "Node" + public final void mNode() throws RecognitionException { + try { + int _type = Node; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:164:6: ( 'node' ) + // InternalRos1Lexer.g:164:8: 'node' + { + match("node"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node" + + // $ANTLR start "Srv" + public final void mSrv() throws RecognitionException { + try { + int _type = Srv; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:166:5: ( 'srv:' ) + // InternalRos1Lexer.g:166:7: 'srv:' + { + match("srv:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Srv" + + // $ANTLR start "Time" + public final void mTime() throws RecognitionException { + try { + int _type = Time; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:168:6: ( 'time' ) + // InternalRos1Lexer.g:168:8: 'time' + { + match("time"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Time" + + // $ANTLR start "Type" + public final void mType() throws RecognitionException { + try { + int _type = Type; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:170:6: ( 'type' ) + // InternalRos1Lexer.g:170:8: 'type' + { + match("type"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type" + + // $ANTLR start "Any" + public final void mAny() throws RecognitionException { + try { + int _type = Any; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:172:5: ( 'Any' ) + // InternalRos1Lexer.g:172:7: 'Any' + { + match("Any"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Any" + + // $ANTLR start "Ns" + public final void mNs() throws RecognitionException { + try { + int _type = Ns; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:174:4: ( 'ns:' ) + // InternalRos1Lexer.g:174:6: 'ns:' + { + match("ns:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Ns" + + // $ANTLR start "LeftSquareBracketRightSquareBracket" + public final void mLeftSquareBracketRightSquareBracket() throws RecognitionException { + try { + int _type = LeftSquareBracketRightSquareBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:176:37: ( '[]' ) + // InternalRos1Lexer.g:176:39: '[]' + { + match("[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LeftSquareBracketRightSquareBracket" + + // $ANTLR start "Comma" + public final void mComma() throws RecognitionException { + try { + int _type = Comma; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:178:7: ( ',' ) + // InternalRos1Lexer.g:178: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:180:7: ( ':' ) + // InternalRos1Lexer.g:180: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:182:19: ( '[' ) + // InternalRos1Lexer.g:182: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:184:20: ( ']' ) + // InternalRos1Lexer.g:184: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:186:19: ( '}' ) + // InternalRos1Lexer.g:186: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:188:21: () + // InternalRos1Lexer.g:188:23: + { + } + + } + finally { + } + } + // $ANTLR end "RULE_BEGIN" + + // $ANTLR start "RULE_END" + public final void mRULE_END() throws RecognitionException { + try { + // InternalRos1Lexer.g:190:19: () + // InternalRos1Lexer.g:190: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:192:17: ( '#' (~ ( ( '\\n' | '\\r' ) ) )* ) + // InternalRos1Lexer.g:192:19: '#' (~ ( ( '\\n' | '\\r' ) ) )* + { + match('#'); + // InternalRos1Lexer.g:192: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:192: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:194:23: ( ( '/' RULE_ID | RULE_ID '/' )* ) + // InternalRos1Lexer.g:194:25: ( '/' RULE_ID | RULE_ID '/' )* + { + // InternalRos1Lexer.g:194: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:194:26: '/' RULE_ID + { + match('/'); + mRULE_ID(); + + } + break; + case 2 : + // InternalRos1Lexer.g:194: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:196:27: ( ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* ) + // InternalRos1Lexer.g:196:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* + { + // InternalRos1Lexer.g:196: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:196:30: '/' RULE_STRING + { + match('/'); + mRULE_STRING(); + + } + break; + case 2 : + // InternalRos1Lexer.g:196:46: RULE_STRING '/' + { + mRULE_STRING(); + match('/'); + + } + break; + case 3 : + // InternalRos1Lexer.g:196: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_DIGIT" + public final void mRULE_DIGIT() throws RecognitionException { + try { + // InternalRos1Lexer.g:198:21: ( '0' .. '9' ) + // InternalRos1Lexer.g:198:23: '0' .. '9' + { + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_DIGIT" + + // $ANTLR start "RULE_BINARY" + public final void mRULE_BINARY() throws RecognitionException { + try { + int _type = RULE_BINARY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:200:13: ( ( '0b' | '0B' ) ( '0' | '1' )+ ) + // InternalRos1Lexer.g:200:15: ( '0b' | '0B' ) ( '0' | '1' )+ + { + // InternalRos1Lexer.g:200:15: ( '0b' | '0B' ) + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0=='0') ) { + int LA4_1 = input.LA(2); + + if ( (LA4_1=='b') ) { + alt4=1; + } + else if ( (LA4_1=='B') ) { + alt4=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + switch (alt4) { + case 1 : + // InternalRos1Lexer.g:200:16: '0b' + { + match("0b"); + + + } + break; + case 2 : + // InternalRos1Lexer.g:200:21: '0B' + { + match("0B"); + + + } + break; + + } + + // InternalRos1Lexer.g:200:27: ( '0' | '1' )+ + int cnt5=0; + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( ((LA5_0>='0' && LA5_0<='1')) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalRos1Lexer.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='1') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt5 >= 1 ) break loop5; + EarlyExitException eee = + new EarlyExitException(5, input); + throw eee; + } + cnt5++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BINARY" + + // $ANTLR start "RULE_BOOLEAN" + public final void mRULE_BOOLEAN() throws RecognitionException { + try { + int _type = RULE_BOOLEAN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:202:14: ( ( 'true' | 'false' ) ) + // InternalRos1Lexer.g:202:16: ( 'true' | 'false' ) + { + // InternalRos1Lexer.g:202:16: ( 'true' | 'false' ) + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='t') ) { + alt6=1; + } + else if ( (LA6_0=='f') ) { + alt6=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + switch (alt6) { + case 1 : + // InternalRos1Lexer.g:202:17: 'true' + { + match("true"); + + + } + break; + case 2 : + // InternalRos1Lexer.g:202:24: 'false' + { + match("false"); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BOOLEAN" + + // $ANTLR start "RULE_DOUBLE" + public final void mRULE_DOUBLE() throws RecognitionException { + try { + int _type = RULE_DOUBLE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:204:13: ( RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) ) + // InternalRos1Lexer.g:204:15: RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + { + mRULE_DIGIT(); + // InternalRos1Lexer.g:204:26: ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + int alt11=2; + alt11 = dfa11.predict(input); + switch (alt11) { + case 1 : + // InternalRos1Lexer.g:204:27: '.' ( RULE_DECINT )* + { + match('.'); + // InternalRos1Lexer.g:204:31: ( RULE_DECINT )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0=='-'||(LA7_0>='0' && LA7_0<='9')) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalRos1Lexer.g:204:31: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + + default : + break loop7; + } + } while (true); + + + } + break; + case 2 : + // InternalRos1Lexer.g:204:44: ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT + { + // InternalRos1Lexer.g:204:44: ( '.' ( RULE_DIGIT )* )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='.') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalRos1Lexer.g:204:45: '.' ( RULE_DIGIT )* + { + match('.'); + // InternalRos1Lexer.g:204:49: ( RULE_DIGIT )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( ((LA8_0>='0' && LA8_0<='9')) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // InternalRos1Lexer.g:204:49: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop8; + } + } while (true); + + + } + break; + + } + + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalRos1Lexer.g:204:73: ( '-' | '+' )? + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='+'||LA10_0=='-') ) { + alt10=1; + } + switch (alt10) { + case 1 : + // InternalRos1Lexer.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_DIGIT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DOUBLE" + + // $ANTLR start "RULE_DECINT" + public final void mRULE_DECINT() throws RecognitionException { + try { + int _type = RULE_DECINT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:206:13: ( ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) ) + // InternalRos1Lexer.g:206:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + { + // InternalRos1Lexer.g:206:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + int alt14=3; + switch ( input.LA(1) ) { + case '0': + { + alt14=1; + } + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt14=2; + } + break; + case '-': + { + alt14=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + + throw nvae; + } + + switch (alt14) { + case 1 : + // InternalRos1Lexer.g:206:16: '0' + { + match('0'); + + } + break; + case 2 : + // InternalRos1Lexer.g:206:20: '1' .. '9' ( RULE_DIGIT )* + { + matchRange('1','9'); + // InternalRos1Lexer.g:206:29: ( RULE_DIGIT )* + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( ((LA12_0>='0' && LA12_0<='9')) ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalRos1Lexer.g:206:29: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop12; + } + } while (true); + + + } + break; + case 3 : + // InternalRos1Lexer.g:206:41: '-' '0' .. '9' ( RULE_DIGIT )* + { + match('-'); + matchRange('0','9'); + // InternalRos1Lexer.g:206:54: ( RULE_DIGIT )* + loop13: + do { + int alt13=2; + int LA13_0 = input.LA(1); + + if ( ((LA13_0>='0' && LA13_0<='9')) ) { + alt13=1; + } + + + switch (alt13) { + case 1 : + // InternalRos1Lexer.g:206:54: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop13; + } + } while (true); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DECINT" + + // $ANTLR start "RULE_DAY" + public final void mRULE_DAY() throws RecognitionException { + try { + // InternalRos1Lexer.g:208:19: ( ( '1' .. '9' | '1' .. '3' '0' .. '9' ) ) + // InternalRos1Lexer.g:208:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + { + // InternalRos1Lexer.g:208:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + int alt15=2; + int LA15_0 = input.LA(1); + + if ( ((LA15_0>='1' && LA15_0<='3')) ) { + int LA15_1 = input.LA(2); + + if ( ((LA15_1>='0' && LA15_1<='9')) ) { + alt15=2; + } + else { + alt15=1;} + } + else if ( ((LA15_0>='4' && LA15_0<='9')) ) { + alt15=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + + throw nvae; + } + switch (alt15) { + case 1 : + // InternalRos1Lexer.g:208:22: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRos1Lexer.g:208:31: '1' .. '3' '0' .. '9' + { + matchRange('1','3'); + matchRange('0','9'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_DAY" + + // $ANTLR start "RULE_MONTH" + public final void mRULE_MONTH() throws RecognitionException { + try { + // InternalRos1Lexer.g:210:21: ( ( '1' .. '9' | '1' '0' .. '2' ) ) + // InternalRos1Lexer.g:210:23: ( '1' .. '9' | '1' '0' .. '2' ) + { + // InternalRos1Lexer.g:210:23: ( '1' .. '9' | '1' '0' .. '2' ) + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='1') ) { + int LA16_1 = input.LA(2); + + if ( ((LA16_1>='0' && LA16_1<='2')) ) { + alt16=2; + } + else { + alt16=1;} + } + else if ( ((LA16_0>='2' && LA16_0<='9')) ) { + alt16=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + + throw nvae; + } + switch (alt16) { + case 1 : + // InternalRos1Lexer.g:210:24: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRos1Lexer.g:210:33: '1' '0' .. '2' + { + match('1'); + matchRange('0','2'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_MONTH" + + // $ANTLR start "RULE_YEAR" + public final void mRULE_YEAR() throws RecognitionException { + try { + // InternalRos1Lexer.g:212:20: ( '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' ) + // InternalRos1Lexer.g:212:22: '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' + { + matchRange('0','2'); + matchRange('0','9'); + matchRange('0','9'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_YEAR" + + // $ANTLR start "RULE_HOUR" + public final void mRULE_HOUR() throws RecognitionException { + try { + // InternalRos1Lexer.g:214:20: ( ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) ) + // InternalRos1Lexer.g:214:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + { + // InternalRos1Lexer.g:214:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + int alt17=2; + int LA17_0 = input.LA(1); + + if ( ((LA17_0>='0' && LA17_0<='1')) ) { + alt17=1; + } + else if ( (LA17_0=='2') ) { + alt17=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); + + throw nvae; + } + switch (alt17) { + case 1 : + // InternalRos1Lexer.g:214:23: '0' .. '1' '0' .. '9' + { + matchRange('0','1'); + matchRange('0','9'); + + } + break; + case 2 : + // InternalRos1Lexer.g:214:41: '2' '0' .. '3' + { + match('2'); + matchRange('0','3'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_HOUR" + + // $ANTLR start "RULE_MIN_SEC" + public final void mRULE_MIN_SEC() throws RecognitionException { + try { + // InternalRos1Lexer.g:216:23: ( '0' .. '5' '0' .. '9' ) + // InternalRos1Lexer.g:216:25: '0' .. '5' '0' .. '9' + { + matchRange('0','5'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_MIN_SEC" + + // $ANTLR start "RULE_DATE_TIME" + public final void mRULE_DATE_TIME() throws RecognitionException { + try { + int _type = RULE_DATE_TIME; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:218:16: ( RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC ) + // InternalRos1Lexer.g:218:18: RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC + { + mRULE_YEAR(); + match('-'); + mRULE_MONTH(); + match('-'); + mRULE_DAY(); + match('T'); + mRULE_HOUR(); + match(':'); + mRULE_MIN_SEC(); + match(':'); + mRULE_MIN_SEC(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DATE_TIME" + + // $ANTLR start "RULE_MESSAGE_ASIGMENT" + public final void mRULE_MESSAGE_ASIGMENT() throws RecognitionException { + try { + int _type = RULE_MESSAGE_ASIGMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:220:23: ( ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) ) + // InternalRos1Lexer.g:220:25: ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + { + // InternalRos1Lexer.g:220:25: ( RULE_ID | RULE_STRING ) + int alt18=2; + int LA18_0 = input.LA(1); + + if ( ((LA18_0>='A' && LA18_0<='Z')||(LA18_0>='^' && LA18_0<='_')||(LA18_0>='a' && LA18_0<='z')) ) { + alt18=1; + } + else if ( (LA18_0=='\"'||LA18_0=='\'') ) { + alt18=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + + throw nvae; + } + switch (alt18) { + case 1 : + // InternalRos1Lexer.g:220:26: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRos1Lexer.g:220:34: RULE_STRING + { + mRULE_STRING(); + + } + break; + + } + + match('='); + // InternalRos1Lexer.g:220:51: ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + int alt19=4; + switch ( input.LA(1) ) { + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + case 'G': + case 'H': + case 'I': + case 'J': + case 'K': + case 'L': + case 'M': + case 'N': + case 'O': + case 'P': + case 'Q': + case 'R': + case 'S': + case 'T': + case 'U': + case 'V': + case 'W': + case 'X': + case 'Y': + case 'Z': + case '^': + case '_': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'g': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': + { + alt19=1; + } + break; + case '\"': + case '\'': + { + alt19=2; + } + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt19=3; + } + break; + case '-': + { + alt19=4; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 19, 0, input); + + throw nvae; + } + + switch (alt19) { + case 1 : + // InternalRos1Lexer.g:220:52: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRos1Lexer.g:220:60: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 3 : + // InternalRos1Lexer.g:220:72: RULE_INT + { + mRULE_INT(); + + } + break; + case 4 : + // InternalRos1Lexer.g:220:81: '-' RULE_INT + { + match('-'); + mRULE_INT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_MESSAGE_ASIGMENT" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:222:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // InternalRos1Lexer.g:222:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + // InternalRos1Lexer.g:222:11: ( '^' )? + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0=='^') ) { + alt20=1; + } + switch (alt20) { + case 1 : + // InternalRos1Lexer.g:222: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:222:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop21: + do { + int alt21=2; + int LA21_0 = input.LA(1); + + if ( ((LA21_0>='0' && LA21_0<='9')||(LA21_0>='A' && LA21_0<='Z')||LA21_0=='_'||(LA21_0>='a' && LA21_0<='z')) ) { + alt21=1; + } + + + switch (alt21) { + 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 loop21; + } + } 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 { + // InternalRos1Lexer.g:224:19: ( ( '0' .. '9' )+ ) + // InternalRos1Lexer.g:224:21: ( '0' .. '9' )+ + { + // InternalRos1Lexer.g:224:21: ( '0' .. '9' )+ + int cnt22=0; + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( ((LA22_0>='0' && LA22_0<='9')) ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalRos1Lexer.g:224:22: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt22 >= 1 ) break loop22; + EarlyExitException eee = + new EarlyExitException(22, input); + throw eee; + } + cnt22++; + } while (true); + + + } + + } + 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:226:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) + // InternalRos1Lexer.g:226:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + { + // InternalRos1Lexer.g:226:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0=='\"') ) { + alt25=1; + } + else if ( (LA25_0=='\'') ) { + alt25=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); + + throw nvae; + } + switch (alt25) { + case 1 : + // InternalRos1Lexer.g:226:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + { + match('\"'); + // InternalRos1Lexer.g:226:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop23: + do { + int alt23=3; + int LA23_0 = input.LA(1); + + if ( (LA23_0=='\\') ) { + alt23=1; + } + else if ( ((LA23_0>='\u0000' && LA23_0<='!')||(LA23_0>='#' && LA23_0<='[')||(LA23_0>=']' && LA23_0<='\uFFFF')) ) { + alt23=2; + } + + + switch (alt23) { + case 1 : + // InternalRos1Lexer.g:226:21: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos1Lexer.g:226: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 loop23; + } + } while (true); + + match('\"'); + + } + break; + case 2 : + // InternalRos1Lexer.g:226:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + { + match('\''); + // InternalRos1Lexer.g:226:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop24: + do { + int alt24=3; + int LA24_0 = input.LA(1); + + if ( (LA24_0=='\\') ) { + alt24=1; + } + else if ( ((LA24_0>='\u0000' && LA24_0<='&')||(LA24_0>='(' && LA24_0<='[')||(LA24_0>=']' && LA24_0<='\uFFFF')) ) { + alt24=2; + } + + + switch (alt24) { + case 1 : + // InternalRos1Lexer.g:226:54: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos1Lexer.g:226: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 loop24; + } + } 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:228:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalRos1Lexer.g:228:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalRos1Lexer.g:228:24: ( options {greedy=false; } : . )* + loop26: + do { + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0=='*') ) { + int LA26_1 = input.LA(2); + + if ( (LA26_1=='/') ) { + alt26=2; + } + else if ( ((LA26_1>='\u0000' && LA26_1<='.')||(LA26_1>='0' && LA26_1<='\uFFFF')) ) { + alt26=1; + } + + + } + else if ( ((LA26_0>='\u0000' && LA26_0<=')')||(LA26_0>='+' && LA26_0<='\uFFFF')) ) { + alt26=1; + } + + + switch (alt26) { + case 1 : + // InternalRos1Lexer.g:228:52: . + { + matchAny(); + + } + break; + + default : + break loop26; + } + } 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:230:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalRos1Lexer.g:230:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalRos1Lexer.g:230:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt27=0; + loop27: + do { + int alt27=2; + int LA27_0 = input.LA(1); + + if ( ((LA27_0>='\t' && LA27_0<='\n')||LA27_0=='\r'||LA27_0==' ') ) { + alt27=1; + } + + + switch (alt27) { + 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 ( cnt27 >= 1 ) break loop27; + EarlyExitException eee = + new EarlyExitException(27, input); + throw eee; + } + cnt27++; + } 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:232:16: ( . ) + // InternalRos1Lexer.g:232:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalRos1Lexer.g:1:8: ( ParameterStructMember | ExternalDependency | RelativeNamespace | PrivateNamespace | GlobalNamespace | Serviceclient | Serviceserver | Actionclient | Actionserver | Dependencies | AmentPackage | ParameterAny | FromGitRepo | Subscribers | Parameters | Publishers | Artifacts | GraphName | Feedback_1 | Float32_1 | Float64_1 | Response | Duration | Feedback | Message_1 | Request | String_2 | Uint16_1 | Uint32_1 | Uint64_1 | Boolean | Integer | Action_1 | Default | Float32 | Float64 | Int16_1 | Int32_1 | Int64_1 | Message | Result_1 | Service | Uint8_1 | Array | Base64 | Double | Header | String | Struct | Action | Bool_1 | Byte_1 | Int8_1 | Result | Specs | String_1 | Uint16 | Uint32 | Uint64 | Goal_1 | Int16 | Int32 | Int64 | Node_1 | Type_1 | Uint8 | Value | Date | List | Bool | Byte | Goal | Int8 | Msg | Name | Node | Srv | Time | Type | Any | Ns | LeftSquareBracketRightSquareBracket | Comma | Colon | LeftSquareBracket | RightSquareBracket | RightCurlyBracket | RULE_SL_COMMENT | RULE_ROS_CONVENTION_A | RULE_ROS_CONVENTION_PARAM | RULE_BINARY | RULE_BOOLEAN | RULE_DOUBLE | RULE_DECINT | RULE_DATE_TIME | RULE_MESSAGE_ASIGMENT | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt28=101; + alt28 = dfa28.predict(input); + switch (alt28) { + case 1 : + // InternalRos1Lexer.g:1:10: ParameterStructMember + { + mParameterStructMember(); + + } + break; + case 2 : + // InternalRos1Lexer.g:1:32: ExternalDependency + { + mExternalDependency(); + + } + break; + case 3 : + // InternalRos1Lexer.g:1:51: RelativeNamespace + { + mRelativeNamespace(); + + } + break; + case 4 : + // InternalRos1Lexer.g:1:69: PrivateNamespace + { + mPrivateNamespace(); + + } + break; + case 5 : + // InternalRos1Lexer.g:1:86: GlobalNamespace + { + mGlobalNamespace(); + + } + break; + case 6 : + // InternalRos1Lexer.g:1:102: Serviceclient + { + mServiceclient(); + + } + break; + case 7 : + // InternalRos1Lexer.g:1:116: Serviceserver + { + mServiceserver(); + + } + break; + case 8 : + // InternalRos1Lexer.g:1:130: Actionclient + { + mActionclient(); + + } + break; + case 9 : + // InternalRos1Lexer.g:1:143: Actionserver + { + mActionserver(); + + } + break; + case 10 : + // InternalRos1Lexer.g:1:156: Dependencies + { + mDependencies(); + + } + break; + case 11 : + // InternalRos1Lexer.g:1:169: AmentPackage + { + mAmentPackage(); + + } + break; + case 12 : + // InternalRos1Lexer.g:1:182: ParameterAny + { + mParameterAny(); + + } + break; + case 13 : + // InternalRos1Lexer.g:1:195: FromGitRepo + { + mFromGitRepo(); + + } + break; + case 14 : + // InternalRos1Lexer.g:1:207: Subscribers + { + mSubscribers(); + + } + break; + case 15 : + // InternalRos1Lexer.g:1:219: Parameters + { + mParameters(); + + } + break; + case 16 : + // InternalRos1Lexer.g:1:230: Publishers + { + mPublishers(); + + } + break; + case 17 : + // InternalRos1Lexer.g:1:241: Artifacts + { + mArtifacts(); + + } + break; + case 18 : + // InternalRos1Lexer.g:1:251: GraphName + { + mGraphName(); + + } + break; + case 19 : + // InternalRos1Lexer.g:1:261: Feedback_1 + { + mFeedback_1(); + + } + break; + case 20 : + // InternalRos1Lexer.g:1:272: Float32_1 + { + mFloat32_1(); + + } + break; + case 21 : + // InternalRos1Lexer.g:1:282: Float64_1 + { + mFloat64_1(); + + } + break; + case 22 : + // InternalRos1Lexer.g:1:292: Response + { + mResponse(); + + } + break; + case 23 : + // InternalRos1Lexer.g:1:301: Duration + { + mDuration(); + + } + break; + case 24 : + // InternalRos1Lexer.g:1:310: Feedback + { + mFeedback(); + + } + break; + case 25 : + // InternalRos1Lexer.g:1:319: Message_1 + { + mMessage_1(); + + } + break; + case 26 : + // InternalRos1Lexer.g:1:329: Request + { + mRequest(); + + } + break; + case 27 : + // InternalRos1Lexer.g:1:337: String_2 + { + mString_2(); + + } + break; + case 28 : + // InternalRos1Lexer.g:1:346: Uint16_1 + { + mUint16_1(); + + } + break; + case 29 : + // InternalRos1Lexer.g:1:355: Uint32_1 + { + mUint32_1(); + + } + break; + case 30 : + // InternalRos1Lexer.g:1:364: Uint64_1 + { + mUint64_1(); + + } + break; + case 31 : + // InternalRos1Lexer.g:1:373: Boolean + { + mBoolean(); + + } + break; + case 32 : + // InternalRos1Lexer.g:1:381: Integer + { + mInteger(); + + } + break; + case 33 : + // InternalRos1Lexer.g:1:389: Action_1 + { + mAction_1(); + + } + break; + case 34 : + // InternalRos1Lexer.g:1:398: Default + { + mDefault(); + + } + break; + case 35 : + // InternalRos1Lexer.g:1:406: Float32 + { + mFloat32(); + + } + break; + case 36 : + // InternalRos1Lexer.g:1:414: Float64 + { + mFloat64(); + + } + break; + case 37 : + // InternalRos1Lexer.g:1:422: Int16_1 + { + mInt16_1(); + + } + break; + case 38 : + // InternalRos1Lexer.g:1:430: Int32_1 + { + mInt32_1(); + + } + break; + case 39 : + // InternalRos1Lexer.g:1:438: Int64_1 + { + mInt64_1(); + + } + break; + case 40 : + // InternalRos1Lexer.g:1:446: Message + { + mMessage(); + + } + break; + case 41 : + // InternalRos1Lexer.g:1:454: Result_1 + { + mResult_1(); + + } + break; + case 42 : + // InternalRos1Lexer.g:1:463: Service + { + mService(); + + } + break; + case 43 : + // InternalRos1Lexer.g:1:471: Uint8_1 + { + mUint8_1(); + + } + break; + case 44 : + // InternalRos1Lexer.g:1:479: Array + { + mArray(); + + } + break; + case 45 : + // InternalRos1Lexer.g:1:485: Base64 + { + mBase64(); + + } + break; + case 46 : + // InternalRos1Lexer.g:1:492: Double + { + mDouble(); + + } + break; + case 47 : + // InternalRos1Lexer.g:1:499: Header + { + mHeader(); + + } + break; + case 48 : + // InternalRos1Lexer.g:1:506: String + { + mString(); + + } + break; + case 49 : + // InternalRos1Lexer.g:1:513: Struct + { + mStruct(); + + } + break; + case 50 : + // InternalRos1Lexer.g:1:520: Action + { + mAction(); + + } + break; + case 51 : + // InternalRos1Lexer.g:1:527: Bool_1 + { + mBool_1(); + + } + break; + case 52 : + // InternalRos1Lexer.g:1:534: Byte_1 + { + mByte_1(); + + } + break; + case 53 : + // InternalRos1Lexer.g:1:541: Int8_1 + { + mInt8_1(); + + } + break; + case 54 : + // InternalRos1Lexer.g:1:548: Result + { + mResult(); + + } + break; + case 55 : + // InternalRos1Lexer.g:1:555: Specs + { + mSpecs(); + + } + break; + case 56 : + // InternalRos1Lexer.g:1:561: String_1 + { + mString_1(); + + } + break; + case 57 : + // InternalRos1Lexer.g:1:570: Uint16 + { + mUint16(); + + } + break; + case 58 : + // InternalRos1Lexer.g:1:577: Uint32 + { + mUint32(); + + } + break; + case 59 : + // InternalRos1Lexer.g:1:584: Uint64 + { + mUint64(); + + } + break; + case 60 : + // InternalRos1Lexer.g:1:591: Goal_1 + { + mGoal_1(); + + } + break; + case 61 : + // InternalRos1Lexer.g:1:598: Int16 + { + mInt16(); + + } + break; + case 62 : + // InternalRos1Lexer.g:1:604: Int32 + { + mInt32(); + + } + break; + case 63 : + // InternalRos1Lexer.g:1:610: Int64 + { + mInt64(); + + } + break; + case 64 : + // InternalRos1Lexer.g:1:616: Node_1 + { + mNode_1(); + + } + break; + case 65 : + // InternalRos1Lexer.g:1:623: Type_1 + { + mType_1(); + + } + break; + case 66 : + // InternalRos1Lexer.g:1:630: Uint8 + { + mUint8(); + + } + break; + case 67 : + // InternalRos1Lexer.g:1:636: Value + { + mValue(); + + } + break; + case 68 : + // InternalRos1Lexer.g:1:642: Date + { + mDate(); + + } + break; + case 69 : + // InternalRos1Lexer.g:1:647: List + { + mList(); + + } + break; + case 70 : + // InternalRos1Lexer.g:1:652: Bool + { + mBool(); + + } + break; + case 71 : + // InternalRos1Lexer.g:1:657: Byte + { + mByte(); + + } + break; + case 72 : + // InternalRos1Lexer.g:1:662: Goal + { + mGoal(); + + } + break; + case 73 : + // InternalRos1Lexer.g:1:667: Int8 + { + mInt8(); + + } + break; + case 74 : + // InternalRos1Lexer.g:1:672: Msg + { + mMsg(); + + } + break; + case 75 : + // InternalRos1Lexer.g:1:676: Name + { + mName(); + + } + break; + case 76 : + // InternalRos1Lexer.g:1:681: Node + { + mNode(); + + } + break; + case 77 : + // InternalRos1Lexer.g:1:686: Srv + { + mSrv(); + + } + break; + case 78 : + // InternalRos1Lexer.g:1:690: Time + { + mTime(); + + } + break; + case 79 : + // InternalRos1Lexer.g:1:695: Type + { + mType(); + + } + break; + case 80 : + // InternalRos1Lexer.g:1:700: Any + { + mAny(); + + } + break; + case 81 : + // InternalRos1Lexer.g:1:704: Ns + { + mNs(); + + } + break; + case 82 : + // InternalRos1Lexer.g:1:707: LeftSquareBracketRightSquareBracket + { + mLeftSquareBracketRightSquareBracket(); + + } + break; + case 83 : + // InternalRos1Lexer.g:1:743: Comma + { + mComma(); + + } + break; + case 84 : + // InternalRos1Lexer.g:1:749: Colon + { + mColon(); + + } + break; + case 85 : + // InternalRos1Lexer.g:1:755: LeftSquareBracket + { + mLeftSquareBracket(); + + } + break; + case 86 : + // InternalRos1Lexer.g:1:773: RightSquareBracket + { + mRightSquareBracket(); + + } + break; + case 87 : + // InternalRos1Lexer.g:1:792: RightCurlyBracket + { + mRightCurlyBracket(); + + } + break; + case 88 : + // InternalRos1Lexer.g:1:810: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 89 : + // InternalRos1Lexer.g:1:826: RULE_ROS_CONVENTION_A + { + mRULE_ROS_CONVENTION_A(); + + } + break; + case 90 : + // InternalRos1Lexer.g:1:848: RULE_ROS_CONVENTION_PARAM + { + mRULE_ROS_CONVENTION_PARAM(); + + } + break; + case 91 : + // InternalRos1Lexer.g:1:874: RULE_BINARY + { + mRULE_BINARY(); + + } + break; + case 92 : + // InternalRos1Lexer.g:1:886: RULE_BOOLEAN + { + mRULE_BOOLEAN(); + + } + break; + case 93 : + // InternalRos1Lexer.g:1:899: RULE_DOUBLE + { + mRULE_DOUBLE(); + + } + break; + case 94 : + // InternalRos1Lexer.g:1:911: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + case 95 : + // InternalRos1Lexer.g:1:923: RULE_DATE_TIME + { + mRULE_DATE_TIME(); + + } + break; + case 96 : + // InternalRos1Lexer.g:1:938: RULE_MESSAGE_ASIGMENT + { + mRULE_MESSAGE_ASIGMENT(); + + } + break; + case 97 : + // InternalRos1Lexer.g:1:960: RULE_ID + { + mRULE_ID(); + + } + break; + case 98 : + // InternalRos1Lexer.g:1:968: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 99 : + // InternalRos1Lexer.g:1:980: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 100 : + // InternalRos1Lexer.g:1:996: RULE_WS + { + mRULE_WS(); + + } + break; + case 101 : + // InternalRos1Lexer.g:1:1004: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA11 dfa11 = new DFA11(this); + protected DFA28 dfa28 = new DFA28(this); + static final String DFA11_eotS = + "\1\uffff\1\5\1\uffff\2\5\1\uffff\2\5"; + static final String DFA11_eofS = + "\10\uffff"; + static final String DFA11_minS = + "\1\56\1\60\1\uffff\2\60\1\uffff\2\60"; + static final String DFA11_maxS = + "\2\145\1\uffff\2\145\1\uffff\2\145"; + static final String DFA11_acceptS = + "\2\uffff\1\2\2\uffff\1\1\2\uffff"; + static final String DFA11_specialS = + "\10\uffff}>"; + static final String[] DFA11_transitionS = { + "\1\1\26\uffff\1\2\37\uffff\1\2", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2" + }; + + static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); + static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); + static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); + static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); + static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); + static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); + static final short[][] DFA11_transition; + + static { + int numStates = DFA11_transitionS.length; + DFA11_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA28_transitionS = { + "\11\54\2\53\2\54\1\53\22\54\1\53\1\54\1\44\1\37\3\54\1\45\4\54\1\33\1\51\1\54\1\40\1\47\2\50\7\52\1\34\6\54\1\10\1\16\1\42\1\21\1\2\1\42\1\4\1\22\1\17\2\42\1\31\3\42\1\1\1\42\1\3\1\23\7\42\1\32\1\54\1\35\1\41\1\42\1\54\1\6\1\24\1\42\1\7\1\42\1\11\1\25\1\42\1\20\3\42\1\14\1\26\1\42\1\12\1\42\1\13\1\5\1\27\1\15\1\30\4\42\2\54\1\36\1\46\uff81\54", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\55\20\57\1\56\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\27\57\1\62\2\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\63\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\64\5\57\1\65\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\66\12\57\1\71\1\57\1\72\1\57\1\70\1\67\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\73\16\57\1\74\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\75\17\57\1\76\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\77\1\101\3\57\1\100\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\105\3\57\1\103\6\57\1\104\5\57\1\102\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\106\23\57\1\107\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\110\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\111\15\57\1\112\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\113\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\115\15\57\1\114\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\116\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\117\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\121\15\57\1\120\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\122\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\123\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\124\11\57\1\125\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\126\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\130\15\57\1\127\3\57\1\131\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\133\10\57\1\134\6\57\1\132\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\135\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\136\21\57", + "\1\137", + "", + "", + "", + "", + "", + "\1\147\4\uffff\1\147\2\uffff\1\146\26\uffff\32\43\3\uffff\2\43\1\uffff\32\43", + "\32\150\4\uffff\1\150\1\uffff\32\150", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\42\152\1\153\71\152\1\151\uffa3\152", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\1\147\4\uffff\1\147", + "\1\162\1\uffff\12\160\10\uffff\1\157\2\uffff\1\162\34\uffff\1\157\2\uffff\1\162", + "\1\162\1\uffff\12\163\13\uffff\1\162\37\uffff\1\162", + "\12\161", + "\1\162\26\uffff\1\162\37\uffff\1\162", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\165\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\166\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\167\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\170\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\171\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\172\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\173\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\174\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\175\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\176\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\177\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0080\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0081\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\5\57\1\u0083\11\57\1\u0082\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0084\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0085\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0086\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u0087\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u0088\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0089\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u008a\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u008b\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u008c\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u008d\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\20\57\1\u008f\1\57\1\u008e\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0090\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0091\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0092\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u0093\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0094\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0095\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0096\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u0097\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0098\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0099\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u009a\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u009b\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u009c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u009d\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u009e\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u009f\15\57", + "\1\43\12\57\1\u00a0\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00a1\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00a2\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00a3\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00a4\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00a5\7\57", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\0\u00a6", + "\42\152\1\153\71\152\1\151\uffa3\152", + "\1\147\15\uffff\1\61", + "\0\u00a8", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\1\147\15\uffff\1\61", + "", + "", + "", + "", + "\12\u00a9", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00aa\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u00ab\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ac\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00ad\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00ae\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00af\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u00b0\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00b1\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b2\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u00b3\27\57", + "\1\43\12\57\1\u00b4\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b5\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00b6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00b7\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00b8\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00b9\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00ba\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00bb\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00bd\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u00be\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00bf\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00c0\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00c1\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00c2\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u00c3\4\57\1\u00c4\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00c5\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00c6\7\57", + "\1\43\12\57\1\u00c7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00c8\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00c9\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ca\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00cb\25\57", + "\1\43\1\57\1\u00cc\1\57\1\u00cd\2\57\1\u00ce\1\57\1\u00cf\1\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00d0\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d1\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u00d2\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00d3\13\57\1\u00d4\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00d5\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d6\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00d7\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d8\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00d9\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00da\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00db\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00dc\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00dd\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00de\6\57", + "\42\152\1\153\71\152\1\151\uffa3\152", + "", + "\47\155\1\156\64\155\1\154\uffa3\155", + "\12\u00df", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00e0\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00e1\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u00e2\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00e3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00e4\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\7\57\1\u00e5\22\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00e6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u00e7\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00e8\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u00e9\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u00ea\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\5\57\1\u00eb\24\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u00ec\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u00ed\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00ee\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00ef\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u00f0\1\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\6\57\1\u00f1\23\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u00f2\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u00f3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00f4\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u00f5\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u00f6\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u00f7\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u00f8\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00f9\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u00fa\31\57", + "", + "\1\43\1\57\1\u00fb\1\57\1\u00fc\2\57\1\u00fd\1\57\1\u00fe\1\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u00ff\25\57", + "\1\43\6\57\1\u0100\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0101\23\57", + "\1\43\6\57\1\u0102\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\2\57\1\u0103\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u0104\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0105\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0107\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0109\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u010a\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u010b\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u010c\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u010e\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0110\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0112\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u0115\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0119\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\160", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u011b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u011c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u011d\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u011e\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u011f\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0120\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0121\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0122\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0123\23\57", + "\1\43\12\57\1\u0124\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0125\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0126\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u0127\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0128\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u0129\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\17\57\1\u012a\12\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u012b\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u012c\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u012d\31\57", + "\1\43\3\57\1\u012e\2\57\1\u012f\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0130\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0131\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0132\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0133\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0134\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0135\23\57", + "\1\43\6\57\1\u0136\3\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\2\57\1\u0137\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u0138\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0139\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u013b\31\57", + "\1\43\4\57\1\u013c\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u013d\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u013e\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0140\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0142\3\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0144\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0145\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u0146\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0147\6\57", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0149\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u014a\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u014b\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u014c\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u014d\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u014e\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u014f\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u0150\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0151\3\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\1\u0155\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0153\17\57\1\u0154\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0157\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0158\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0159\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u015a\13\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u015b\31\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u015c\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u015d\27\57", + "\1\43\2\57\1\u015e\7\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\4\57\1\u015f\5\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0160\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\7\57\1\u0161\22\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u0162\7\57", + "\1\43\12\57\1\u0163\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0165\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0166\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0167\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0169\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u016b\3\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u016d\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u016f\10\57", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0174\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0175\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0176\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0177\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0178\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u0179\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u017a\17\57\1\u017b\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u017d\30\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u017e\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u017f\25\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u0180\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0181\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u0183\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u0184\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\21\57\1\u0185\10\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\12\57\1\u0186\17\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0187\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\1\u0189\3\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018c\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u018d\25\57", + "", + "", + "\1\43\12\57\1\u018e\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u018f\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u0193\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u0194\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\3\57\1\u0195\26\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\15\57\1\u0196\14\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u0197\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u0198\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\13\57\1\u0199\16\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u019a\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u019b\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u019c\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u019d\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u019e\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u019f\27\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\12\57\1\u01a1\17\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01a2\25\57", + "\1\43\12\57\1\u01a3\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01a5\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01a6\10\57", + "\1\43\12\57\1\u01a7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\1\u01a9\21\57\1\u01a8\7\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01aa\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ab\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01ac\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ad\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u01af\21\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01b0\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01b1\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01b2\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u01b3\4\57", + "\1\43\12\57\1\u01b4\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\10\57\1\u01b5\21\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01b6\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01b7\12\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01b8\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01b9\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01ba\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01bb\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01bc\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01bd\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01be\15\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01bf\7\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c0\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\25\57\1\u01c1\4\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01c2\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01c3\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c4\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01c5\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\6\57\1\u01c6\23\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\16\57\1\u01c7\13\57", + "\1\43\12\57\1\u01c8\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01c9\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01ca\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u01cb\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01cc\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01cd\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ce\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01cf\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01d0\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01d1\25\57", + "\1\43\12\57\1\u01d2\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01d3\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01d4\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01d5\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01d6\25\57", + "\1\43\12\57\1\u01d7\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\24\57\1\u01d8\5\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01da\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01db\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\22\57\1\u01dc\7\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01dd\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01de\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01df\10\57", + "", + "\1\43\12\57\1\u01e0\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01e1\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01e2\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01e4\27\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01e5\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\3\57\1\u01e6\26\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\17\57\1\u01e7\12\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01e8\27\57", + "\1\43\12\57\1\u01e9\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\1\u01ea\2\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\23\57\1\u01eb\6\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01ec\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ed\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\u01ee\31\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01ef\25\57", + "", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\14\57\1\u01f0\15\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f1\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\u01f2\14\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01f3\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f5\25\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\2\57\1\u01f7\27\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01f8\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\14\57\1\u01f9\15\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\30\57\1\u01fa\1\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\1\57\1\u01fc\30\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\4\57\1\u01fe\25\57", + "", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\21\57\1\u01ff\10\57", + "\1\43\12\57\3\uffff\1\61\3\uffff\32\57\4\uffff\1\57\1\uffff\32\57", + "" + }; + + static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS); + static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS); + static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS); + static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS); + static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS); + static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS); + static final short[][] DFA28_transition; + + static { + int numStates = DFA28_transitionS.length; + DFA28_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA28_105<='\uFFFF')) ) {s = 166;} + + if ( s>=0 ) return s; + break; + case 1 : + int LA28_108 = input.LA(1); + + s = -1; + if ( ((LA28_108>='\u0000' && LA28_108<='\uFFFF')) ) {s = 168;} + + if ( s>=0 ) return s; + break; + case 2 : + int LA28_37 = input.LA(1); + + s = -1; + if ( (LA28_37=='\\') ) {s = 108;} + + else if ( ((LA28_37>='\u0000' && LA28_37<='&')||(LA28_37>='(' && LA28_37<='[')||(LA28_37>=']' && LA28_37<='\uFFFF')) ) {s = 109;} + + else if ( (LA28_37=='\'') ) {s = 110;} + + else s = 44; + + if ( s>=0 ) return s; + break; + case 3 : + int LA28_0 = input.LA(1); + + s = -1; + if ( (LA28_0=='P') ) {s = 1;} + + else if ( (LA28_0=='E') ) {s = 2;} + + else if ( (LA28_0=='R') ) {s = 3;} + + else if ( (LA28_0=='G') ) {s = 4;} + + else if ( (LA28_0=='s') ) {s = 5;} + + else if ( (LA28_0=='a') ) {s = 6;} + + else if ( (LA28_0=='d') ) {s = 7;} + + else if ( (LA28_0=='A') ) {s = 8;} + + else if ( (LA28_0=='f') ) {s = 9;} + + else if ( (LA28_0=='p') ) {s = 10;} + + else if ( (LA28_0=='r') ) {s = 11;} + + else if ( (LA28_0=='m') ) {s = 12;} + + else if ( (LA28_0=='u') ) {s = 13;} + + else if ( (LA28_0=='B') ) {s = 14;} + + else if ( (LA28_0=='I') ) {s = 15;} + + else if ( (LA28_0=='i') ) {s = 16;} + + else if ( (LA28_0=='D') ) {s = 17;} + + else if ( (LA28_0=='H') ) {s = 18;} + + else if ( (LA28_0=='S') ) {s = 19;} + + else if ( (LA28_0=='b') ) {s = 20;} + + else if ( (LA28_0=='g') ) {s = 21;} + + else if ( (LA28_0=='n') ) {s = 22;} + + else if ( (LA28_0=='t') ) {s = 23;} + + else if ( (LA28_0=='v') ) {s = 24;} + + else if ( (LA28_0=='L') ) {s = 25;} + + else if ( (LA28_0=='[') ) {s = 26;} + + else if ( (LA28_0==',') ) {s = 27;} + + else if ( (LA28_0==':') ) {s = 28;} + + else if ( (LA28_0==']') ) {s = 29;} + + else if ( (LA28_0=='}') ) {s = 30;} + + else if ( (LA28_0=='#') ) {s = 31;} + + else if ( (LA28_0=='/') ) {s = 32;} + + else if ( (LA28_0=='^') ) {s = 33;} + + else if ( (LA28_0=='C'||LA28_0=='F'||(LA28_0>='J' && LA28_0<='K')||(LA28_0>='M' && LA28_0<='O')||LA28_0=='Q'||(LA28_0>='T' && LA28_0<='Z')||LA28_0=='_'||LA28_0=='c'||LA28_0=='e'||LA28_0=='h'||(LA28_0>='j' && LA28_0<='l')||LA28_0=='o'||LA28_0=='q'||(LA28_0>='w' && LA28_0<='z')) ) {s = 34;} + + else if ( (LA28_0=='\"') ) {s = 36;} + + else if ( (LA28_0=='\'') ) {s = 37;} + + else if ( (LA28_0=='~') ) {s = 38;} + + else if ( (LA28_0=='0') ) {s = 39;} + + else if ( ((LA28_0>='1' && LA28_0<='2')) ) {s = 40;} + + else if ( (LA28_0=='-') ) {s = 41;} + + else if ( ((LA28_0>='3' && LA28_0<='9')) ) {s = 42;} + + else if ( ((LA28_0>='\t' && LA28_0<='\n')||LA28_0=='\r'||LA28_0==' ') ) {s = 43;} + + else if ( ((LA28_0>='\u0000' && LA28_0<='\b')||(LA28_0>='\u000B' && LA28_0<='\f')||(LA28_0>='\u000E' && LA28_0<='\u001F')||LA28_0=='!'||(LA28_0>='$' && LA28_0<='&')||(LA28_0>='(' && LA28_0<='+')||LA28_0=='.'||(LA28_0>=';' && LA28_0<='@')||LA28_0=='\\'||LA28_0=='`'||(LA28_0>='{' && LA28_0<='|')||(LA28_0>='\u007F' && LA28_0<='\uFFFF')) ) {s = 44;} + + else s = 35; + + if ( s>=0 ) return s; + break; + case 4 : + int LA28_166 = input.LA(1); + + s = -1; + if ( (LA28_166=='\"') ) {s = 107;} + + else if ( (LA28_166=='\\') ) {s = 105;} + + else if ( ((LA28_166>='\u0000' && LA28_166<='!')||(LA28_166>='#' && LA28_166<='[')||(LA28_166>=']' && LA28_166<='\uFFFF')) ) {s = 106;} + + if ( s>=0 ) return s; + break; + case 5 : + int LA28_106 = input.LA(1); + + s = -1; + if ( (LA28_106=='\"') ) {s = 107;} + + else if ( (LA28_106=='\\') ) {s = 105;} + + else if ( ((LA28_106>='\u0000' && LA28_106<='!')||(LA28_106>='#' && LA28_106<='[')||(LA28_106>=']' && LA28_106<='\uFFFF')) ) {s = 106;} + + if ( s>=0 ) return s; + break; + case 6 : + int LA28_36 = input.LA(1); + + s = -1; + if ( (LA28_36=='\\') ) {s = 105;} + + else if ( ((LA28_36>='\u0000' && LA28_36<='!')||(LA28_36>='#' && LA28_36<='[')||(LA28_36>=']' && LA28_36<='\uFFFF')) ) {s = 106;} + + else if ( (LA28_36=='\"') ) {s = 107;} + + else s = 44; + + if ( s>=0 ) return s; + break; + case 7 : + int LA28_168 = input.LA(1); + + s = -1; + if ( (LA28_168=='\'') ) {s = 110;} + + else if ( (LA28_168=='\\') ) {s = 108;} + + else if ( ((LA28_168>='\u0000' && LA28_168<='&')||(LA28_168>='(' && LA28_168<='[')||(LA28_168>=']' && LA28_168<='\uFFFF')) ) {s = 109;} + + if ( s>=0 ) return s; + break; + case 8 : + int LA28_109 = input.LA(1); + + s = -1; + if ( (LA28_109=='\'') ) {s = 110;} + + else if ( (LA28_109=='\\') ) {s = 108;} + + else if ( ((LA28_109>='\u0000' && LA28_109<='&')||(LA28_109>='(' && LA28_109<='[')||(LA28_109>=']' && LA28_109<='\uFFFF')) ) {s = 109;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 28, _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..135670e45 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.tokens @@ -0,0 +1,110 @@ +Action=53 +Action_1=36 +Actionclient=11 +Actionserver=12 +AmentPackage=14 +Any=83 +Array=47 +Artifacts=20 +Base64=48 +Bool=73 +Bool_1=54 +Boolean=34 +Byte=74 +Byte_1=55 +Colon=87 +Comma=86 +Date=71 +Default=37 +Dependencies=13 +Double=49 +Duration=26 +ExternalDependency=5 +Feedback=27 +Feedback_1=22 +Float32=38 +Float32_1=23 +Float64=39 +Float64_1=24 +FromGitRepo=16 +GlobalNamespace=8 +Goal=75 +Goal_1=63 +GraphName=21 +Header=50 +Int16=64 +Int16_1=40 +Int32=65 +Int32_1=41 +Int64=66 +Int64_1=42 +Int8=76 +Int8_1=56 +Integer=35 +LeftSquareBracket=88 +LeftSquareBracketRightSquareBracket=85 +List=72 +Message=43 +Message_1=28 +Msg=77 +Name=78 +Node=79 +Node_1=67 +Ns=84 +ParameterAny=15 +ParameterStructMember=4 +Parameters=18 +PrivateNamespace=7 +Publishers=19 +RULE_ANY_OTHER=113 +RULE_BEGIN=91 +RULE_BINARY=99 +RULE_BOOLEAN=100 +RULE_DATE_TIME=108 +RULE_DAY=103 +RULE_DECINT=101 +RULE_DIGIT=98 +RULE_DOUBLE=102 +RULE_END=92 +RULE_HOUR=106 +RULE_ID=94 +RULE_INT=109 +RULE_MESSAGE_ASIGMENT=110 +RULE_MIN_SEC=107 +RULE_ML_COMMENT=111 +RULE_MONTH=104 +RULE_ROS_CONVENTION_A=95 +RULE_ROS_CONVENTION_PARAM=97 +RULE_SL_COMMENT=93 +RULE_STRING=96 +RULE_WS=112 +RULE_YEAR=105 +RelativeNamespace=6 +Request=29 +Response=25 +Result=57 +Result_1=44 +RightCurlyBracket=90 +RightSquareBracket=89 +Service=45 +Serviceclient=9 +Serviceserver=10 +Specs=58 +Srv=80 +String=51 +String_1=59 +String_2=30 +Struct=52 +Subscribers=17 +Time=81 +Type=82 +Type_1=68 +Uint16=60 +Uint16_1=31 +Uint32=61 +Uint32_1=32 +Uint64=62 +Uint64_1=33 +Uint8=69 +Uint8_1=46 +Value=70 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..8c23394cb --- /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 de.fraunhofer.ipa.ros.scoping.RosScopeProvider; + +public abstract class AbstractRos1ScopeProvider extends RosScopeProvider { +} 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..702f7b4f7 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/serializer/Ros1SemanticSequencer.java @@ -0,0 +1,351 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.serializer; + +import com.google.inject.Inject; +import de.fraunhofer.ipa.ros.serializer.RosSemanticSequencer; +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 primitives.ArrayTopicSpecRef; +import primitives.ByteArray; +import primitives.Header; +import primitives.MessagePart; +import primitives.PrimitivesPackage; +import primitives.TopicSpecRef; +import primitives.bool; +import primitives.boolArray; +import primitives.duration; +import primitives.float32; +import primitives.float32Array; +import primitives.float64; +import primitives.float64Array; +import primitives.int16; +import primitives.int16Array; +import primitives.int32; +import primitives.int32Array; +import primitives.int64; +import primitives.int64Array; +import primitives.int8; +import primitives.int8Array; +import primitives.string; +import primitives.stringArray; +import primitives.time; +import primitives.uint16; +import primitives.uint16Array; +import primitives.uint32; +import primitives.uint32Array; +import primitives.uint64; +import primitives.uint64Array; +import primitives.uint8; +import primitives.uint8Array; +import ros.ActionClient; +import ros.ActionServer; +import ros.ActionSpec; +import ros.AmentPackage; +import ros.Artifact; +import ros.CatkinPackage; +import ros.ExternalDependency; +import ros.GlobalNamespace; +import ros.MessageDefinition; +import ros.Node; +import ros.PackageDependency; +import ros.PackageSet; +import ros.ParameterAny; +import ros.ParameterAnyType; +import ros.ParameterArrayType; +import ros.ParameterBase64; +import ros.ParameterBase64Type; +import ros.ParameterBoolean; +import ros.ParameterBooleanType; +import ros.ParameterDate; +import ros.ParameterDateType; +import ros.ParameterDouble; +import ros.ParameterDoubleType; +import ros.ParameterInteger; +import ros.ParameterIntegerType; +import ros.ParameterListType; +import ros.ParameterSequence; +import ros.ParameterString; +import ros.ParameterStringType; +import ros.ParameterStruct; +import ros.ParameterStructMember; +import ros.ParameterStructType; +import ros.ParameterStructTypeMember; +import ros.PrivateNamespace; +import ros.Publisher; +import ros.RelativeNamespace; +import ros.RosPackage; +import ros.ServiceClient; +import ros.ServiceServer; +import ros.ServiceSpec; +import ros.Subscriber; +import ros.TopicSpec; + +@SuppressWarnings("all") +public class Ros1SemanticSequencer extends RosSemanticSequencer { + + @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 == PrimitivesPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case PrimitivesPackage.ARRAY_TOPIC_SPEC_REF: + sequence_ArrayTopicSpecRef(context, (ArrayTopicSpecRef) semanticObject); + return; + case PrimitivesPackage.BYTE: + sequence_byte(context, (primitives.Byte) semanticObject); + return; + case PrimitivesPackage.BYTE_ARRAY: + sequence_byteArray(context, (ByteArray) semanticObject); + return; + case PrimitivesPackage.HEADER: + sequence_Header(context, (Header) semanticObject); + return; + case PrimitivesPackage.MESSAGE_PART: + sequence_MessagePart(context, (MessagePart) semanticObject); + return; + case PrimitivesPackage.TOPIC_SPEC_REF: + sequence_TopicSpecRef(context, (TopicSpecRef) semanticObject); + return; + case PrimitivesPackage.BOOL: + sequence_bool(context, (bool) semanticObject); + return; + case PrimitivesPackage.BOOL_ARRAY: + sequence_boolArray(context, (boolArray) semanticObject); + return; + case PrimitivesPackage.DURATION: + sequence_duration(context, (duration) semanticObject); + return; + case PrimitivesPackage.FLOAT32: + sequence_float32(context, (float32) semanticObject); + return; + case PrimitivesPackage.FLOAT32_ARRAY: + sequence_float32Array(context, (float32Array) semanticObject); + return; + case PrimitivesPackage.FLOAT64: + sequence_float64(context, (float64) semanticObject); + return; + case PrimitivesPackage.FLOAT64_ARRAY: + sequence_float64Array(context, (float64Array) semanticObject); + return; + case PrimitivesPackage.INT16: + sequence_int16(context, (int16) semanticObject); + return; + case PrimitivesPackage.INT16_ARRAY: + sequence_int16Array(context, (int16Array) semanticObject); + return; + case PrimitivesPackage.INT32: + sequence_int32(context, (int32) semanticObject); + return; + case PrimitivesPackage.INT32_ARRAY: + sequence_int32Array(context, (int32Array) semanticObject); + return; + case PrimitivesPackage.INT64: + sequence_int64(context, (int64) semanticObject); + return; + case PrimitivesPackage.INT64_ARRAY: + sequence_int64Array(context, (int64Array) semanticObject); + return; + case PrimitivesPackage.INT8: + sequence_int8(context, (int8) semanticObject); + return; + case PrimitivesPackage.INT8_ARRAY: + sequence_int8Array(context, (int8Array) semanticObject); + return; + case PrimitivesPackage.STRING: + sequence_string0(context, (string) semanticObject); + return; + case PrimitivesPackage.STRING_ARRAY: + sequence_string0Array(context, (stringArray) semanticObject); + return; + case PrimitivesPackage.TIME: + sequence_time(context, (time) semanticObject); + return; + case PrimitivesPackage.UINT16: + sequence_uint16(context, (uint16) semanticObject); + return; + case PrimitivesPackage.UINT16_ARRAY: + sequence_uint16Array(context, (uint16Array) semanticObject); + return; + case PrimitivesPackage.UINT32: + sequence_uint32(context, (uint32) semanticObject); + return; + case PrimitivesPackage.UINT32_ARRAY: + sequence_uint32Array(context, (uint32Array) semanticObject); + return; + case PrimitivesPackage.UINT64: + sequence_uint64(context, (uint64) semanticObject); + return; + case PrimitivesPackage.UINT64_ARRAY: + sequence_uint64Array(context, (uint64Array) semanticObject); + return; + case PrimitivesPackage.UINT8: + sequence_uint8(context, (uint8) semanticObject); + return; + case PrimitivesPackage.UINT8_ARRAY: + sequence_uint8Array(context, (uint8Array) semanticObject); + return; + } + else if (epackage == RosPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case RosPackage.ACTION_CLIENT: + sequence_ActionClient(context, (ActionClient) semanticObject); + return; + case RosPackage.ACTION_SERVER: + sequence_ActionServer(context, (ActionServer) semanticObject); + return; + case RosPackage.ACTION_SPEC: + sequence_ActionSpec(context, (ActionSpec) semanticObject); + return; + case RosPackage.AMENT_PACKAGE: + sequence_AmentPackage(context, (AmentPackage) semanticObject); + return; + 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.GLOBAL_NAMESPACE: + sequence_GlobalNamespace(context, (GlobalNamespace) semanticObject); + return; + case RosPackage.MESSAGE_DEFINITION: + sequence_MessageDefinition(context, (MessageDefinition) semanticObject); + return; + case RosPackage.NODE: + sequence_Node(context, (Node) semanticObject); + return; + case RosPackage.PACKAGE: + sequence_Package_Impl(context, (ros.Package) semanticObject); + return; + case RosPackage.PACKAGE_DEPENDENCY: + sequence_PackageDependency(context, (PackageDependency) semanticObject); + return; + case RosPackage.PACKAGE_SET: + sequence_PackageSet(context, (PackageSet) semanticObject); + return; + case RosPackage.PARAMETER: + sequence_Parameter(context, (ros.Parameter) semanticObject); + return; + case RosPackage.PARAMETER_ANY: + sequence_ParameterAny(context, (ParameterAny) semanticObject); + return; + case RosPackage.PARAMETER_ANY_TYPE: + sequence_ParameterAnyType(context, (ParameterAnyType) semanticObject); + return; + case RosPackage.PARAMETER_ARRAY_TYPE: + sequence_ParameterArrayType(context, (ParameterArrayType) semanticObject); + return; + case RosPackage.PARAMETER_BASE64: + sequence_ParameterBase64(context, (ParameterBase64) semanticObject); + return; + case RosPackage.PARAMETER_BASE64_TYPE: + sequence_ParameterBase64Type(context, (ParameterBase64Type) semanticObject); + return; + case RosPackage.PARAMETER_BOOLEAN: + sequence_ParameterBoolean(context, (ParameterBoolean) semanticObject); + return; + case RosPackage.PARAMETER_BOOLEAN_TYPE: + sequence_ParameterBooleanType(context, (ParameterBooleanType) semanticObject); + return; + case RosPackage.PARAMETER_DATE: + sequence_ParameterDate(context, (ParameterDate) semanticObject); + return; + case RosPackage.PARAMETER_DATE_TYPE: + sequence_ParameterDateType(context, (ParameterDateType) semanticObject); + return; + case RosPackage.PARAMETER_DOUBLE: + sequence_ParameterDouble(context, (ParameterDouble) semanticObject); + return; + case RosPackage.PARAMETER_DOUBLE_TYPE: + sequence_ParameterDoubleType(context, (ParameterDoubleType) semanticObject); + return; + case RosPackage.PARAMETER_INTEGER: + sequence_ParameterInteger(context, (ParameterInteger) semanticObject); + return; + case RosPackage.PARAMETER_INTEGER_TYPE: + sequence_ParameterIntegerType(context, (ParameterIntegerType) semanticObject); + return; + case RosPackage.PARAMETER_LIST_TYPE: + sequence_ParameterListType(context, (ParameterListType) semanticObject); + return; + case RosPackage.PARAMETER_SEQUENCE: + sequence_ParameterList(context, (ParameterSequence) semanticObject); + return; + case RosPackage.PARAMETER_STRING: + sequence_ParameterString(context, (ParameterString) semanticObject); + return; + case RosPackage.PARAMETER_STRING_TYPE: + sequence_ParameterStringType(context, (ParameterStringType) semanticObject); + return; + case RosPackage.PARAMETER_STRUCT: + sequence_ParameterStruct(context, (ParameterStruct) semanticObject); + return; + case RosPackage.PARAMETER_STRUCT_MEMBER: + sequence_ParameterStructMember(context, (ParameterStructMember) semanticObject); + return; + case RosPackage.PARAMETER_STRUCT_TYPE: + sequence_ParameterStructType(context, (ParameterStructType) semanticObject); + return; + case RosPackage.PARAMETER_STRUCT_TYPE_MEMBER: + sequence_ParameterStructTypeMember(context, (ParameterStructTypeMember) semanticObject); + return; + case RosPackage.PRIVATE_NAMESPACE: + sequence_PrivateNamespace(context, (PrivateNamespace) semanticObject); + return; + case RosPackage.PUBLISHER: + sequence_Publisher(context, (Publisher) semanticObject); + return; + case RosPackage.RELATIVE_NAMESPACE: + sequence_RelativeNamespace_Impl(context, (RelativeNamespace) semanticObject); + return; + case RosPackage.SERVICE_CLIENT: + sequence_ServiceClient(context, (ServiceClient) semanticObject); + return; + case RosPackage.SERVICE_SERVER: + sequence_ServiceServer(context, (ServiceServer) semanticObject); + return; + case RosPackage.SERVICE_SPEC: + sequence_ServiceSpec(context, (ServiceSpec) semanticObject); + return; + case RosPackage.SUBSCRIBER: + sequence_Subscriber(context, (Subscriber) semanticObject); + return; + case RosPackage.TOPIC_SPEC: + sequence_TopicSpec(context, (TopicSpec) semanticObject); + return; + } + if (errorAcceptor != null) + errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); + } + + /** + * Contexts: + * Package returns CatkinPackage + * 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); + } + + +} 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..8e97016de --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/serializer/Ros1SyntacticSequencer.java @@ -0,0 +1,2848 @@ +/* + * 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.AlternativeAlias; +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_AmentPackage___ArtifactsKeyword_6_0_BEGINTerminalRuleCall_6_1_ENDTerminalRuleCall_6_3__q; + protected AbstractElementAlias match_CatkinPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q; + protected AbstractElementAlias match_Node___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q; + + @Inject + protected void init(IGrammarAccess access) { + grammarAccess = (Ros1GrammarAccess) access; + match_AmentPackage___ArtifactsKeyword_6_0_BEGINTerminalRuleCall_6_1_ENDTerminalRuleCall_6_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getAmentPackageAccess().getArtifactsKeyword_6_0()), new TokenAlias(false, false, grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_6_1()), new TokenAlias(false, false, grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_6_3())); + 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___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()), new TokenAlias(false, false, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()), new TokenAlias(false, false, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_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_AmentPackage___ArtifactsKeyword_6_0_BEGINTerminalRuleCall_6_1_ENDTerminalRuleCall_6_3__q.equals(syntax)) + emit_AmentPackage___ArtifactsKeyword_6_0_BEGINTerminalRuleCall_6_1_ENDTerminalRuleCall_6_3__q(semanticObject, getLastNavigableState(), syntaxNodes); + else 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___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a.equals(syntax)) + emit_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q.equals(syntax)) + emit_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_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_AmentPackage___ArtifactsKeyword_6_0_BEGINTerminalRuleCall_6_1_ENDTerminalRuleCall_6_3__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 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: + * ( + * 'actionclient:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'actionserver:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + * publisher+=Publisher (ambiguity) publisher+=Publisher + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + * subscriber+=Subscriber (ambiguity) subscriber+=Subscriber + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + * serviceserver+=ServiceServer (ambiguity) serviceserver+=ServiceServer + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + * serviceclient+=ServiceClient (ambiguity) serviceclient+=ServiceClient + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + * actionserver+=ActionServer (ambiguity) actionserver+=ActionServer + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))* + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + * actionclient+=ActionClient (ambiguity) actionclient+=ActionClient + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) + * )* + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))* + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + * parameter+=Parameter (ambiguity) parameter+=Parameter + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'parameters:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'publishers:' + * BEGIN + * END + * ( + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'serviceclient:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'serviceserver:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'subscribers:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + * subscriber+=Subscriber END (ambiguity) ('subscribers:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + * serviceserver+=ServiceServer END (ambiguity) ('serviceserver:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + * serviceclient+=ServiceClient END (ambiguity) ('serviceclient:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + * publisher+=Publisher END (ambiguity) ('publishers:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + * parameter+=Parameter END (ambiguity) ('parameters:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) ('actionserver:' BEGIN END (ambiguity))* END (rule end) + * name=RosNames BEGIN (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) ('actionclient:' BEGIN END (ambiguity))* END (rule end) + * name=RosNames BEGIN (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ('specs:' 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_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_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..14c605b24 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/services/Ros1GrammarAccess.java @@ -0,0 +1,1563 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.services; + +import com.google.inject.Inject; +import com.google.inject.Singleton; +import de.fraunhofer.ipa.ros.services.RosGrammarAccess; +import java.util.List; +import org.eclipse.xtext.Action; +import org.eclipse.xtext.Assignment; +import org.eclipse.xtext.Grammar; +import org.eclipse.xtext.GrammarUtil; +import org.eclipse.xtext.Group; +import org.eclipse.xtext.Keyword; +import org.eclipse.xtext.ParserRule; +import org.eclipse.xtext.RuleCall; +import org.eclipse.xtext.TerminalRule; +import org.eclipse.xtext.common.services.TerminalsGrammarAccess; +import org.eclipse.xtext.service.AbstractElementFinder; +import org.eclipse.xtext.service.GrammarProvider; + +@Singleton +public class Ros1GrammarAccess extends AbstractElementFinder.AbstractGrammarElementFinder { + + public class PackageElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.Package"); + private final RuleCall cCatkinPackageParserRuleCall = (RuleCall)rule.eContents().get(1); + + //@Override + //Package returns Package: + // CatkinPackage + // ; + @Override public ParserRule getRule() { return rule; } + + //CatkinPackage + public RuleCall getCatkinPackageParserRuleCall() { return cCatkinPackageParserRuleCall; } + } + 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); + + //@Override + //CatkinPackage returns CatkinPackage: + // {CatkinPackage} + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; + @Override public ParserRule getRule() { return rule; } + + //{CatkinPackage} + //name=RosNames':' + //BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + //END + public Group getGroup() { return cGroup; } + + //{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; } + } + + + private final PackageElements pPackage; + private final CatkinPackageElements pCatkinPackage; + + private final Grammar grammar; + + private final RosGrammarAccess gaRos; + + private final TerminalsGrammarAccess gaTerminals; + + @Inject + public Ros1GrammarAccess(GrammarProvider grammarProvider, + RosGrammarAccess gaRos, + TerminalsGrammarAccess gaTerminals) { + this.grammar = internalFindGrammar(grammarProvider); + this.gaRos = gaRos; + this.gaTerminals = gaTerminals; + this.pPackage = new PackageElements(); + this.pCatkinPackage = new CatkinPackageElements(); + } + + 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 RosGrammarAccess getRosGrammarAccess() { + return gaRos; + } + + public TerminalsGrammarAccess getTerminalsGrammarAccess() { + return gaTerminals; + } + + + //@Override + //Package returns Package: + // CatkinPackage + // ; + public PackageElements getPackageAccess() { + return pPackage; + } + + public ParserRule getPackageRule() { + return getPackageAccess().getRule(); + } + + //@Override + //CatkinPackage returns CatkinPackage: + // {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(); + } + + //PackageSet returns PackageSet: + // {PackageSet} + // package+=Package_Impl* + // ; + public RosGrammarAccess.PackageSetElements getPackageSetAccess() { + return gaRos.getPackageSetAccess(); + } + + public ParserRule getPackageSetRule() { + return getPackageSetAccess().getRule(); + } + + ///////////////////// + //// YAML format + ///////////////////// + //terminal BEGIN: 'synthetic:BEGIN'; + public TerminalRule getBEGINRule() { + return gaRos.getBEGINRule(); + } + + //terminal END: 'synthetic:END'; + public TerminalRule getENDRule() { + return gaRos.getENDRule(); + } + + //@Override + //terminal SL_COMMENT: '#' !('\n'|'\r')*; + public TerminalRule getSL_COMMENTRule() { + return gaRos.getSL_COMMENTRule(); + } + + ///////////////////// + //// CONVENTIONS AND NAMES + ///////////////////// + //EString returns ecore::EString: + // STRING | ID; + public RosGrammarAccess.EStringElements getEStringAccess() { + return gaRos.getEStringAccess(); + } + + public ParserRule getEStringRule() { + return getEStringAccess().getRule(); + } + + //RosNames returns ecore::EString: + // ROS_CONVENTION_A | ID | 'node' + //; + public RosGrammarAccess.RosNamesElements getRosNamesAccess() { + return gaRos.getRosNamesAccess(); + } + + public ParserRule getRosNamesRule() { + return getRosNamesAccess().getRule(); + } + + //terminal ROS_CONVENTION_A: + // ( ('/' ID ) | ( ID '/' ) )* ; + public TerminalRule getROS_CONVENTION_ARule() { + return gaRos.getROS_CONVENTION_ARule(); + } + + //terminal ROS_CONVENTION_PARAM: + // ( ('/' STRING ) | ( STRING '/' ) | ('~' STRING ) )* ; + public TerminalRule getROS_CONVENTION_PARAMRule() { + return gaRos.getROS_CONVENTION_PARAMRule(); + } + + //Package_Impl returns Package: + // {Package} + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('specs:' + // BEGIN + // spec+=SpecBase* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; + public RosGrammarAccess.Package_ImplElements getPackage_ImplAccess() { + return gaRos.getPackage_ImplAccess(); + } + + public ParserRule getPackage_ImplRule() { + return getPackage_ImplAccess().getRule(); + } + + //AmentPackage returns AmentPackage: + // {AmentPackage} + // 'AmentPackage' + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; + public RosGrammarAccess.AmentPackageElements getAmentPackageAccess() { + return gaRos.getAmentPackageAccess(); + } + + public ParserRule getAmentPackageRule() { + return getAmentPackageAccess().getRule(); + } + + ///////////////////// + ////ARTIFACT AND NODE + ///////////////////// + //Artifact returns Artifact: + // {Artifact} + // name=RosNames':' + // BEGIN + // (node=Node)? + // END; + public RosGrammarAccess.ArtifactElements getArtifactAccess() { + return gaRos.getArtifactAccess(); + } + + public ParserRule getArtifactRule() { + return getArtifactAccess().getRule(); + } + + //Node returns Node: + // 'node:' name=RosNames + // BEGIN + // ( + // ('publishers:' + // BEGIN + // publisher+=Publisher* + // END + // )| + // ('subscribers:' + // BEGIN + // subscriber+=Subscriber* + // END + // )| + // ('serviceserver:' + // BEGIN + // serviceserver+=ServiceServer* + // END + // )| + // ('serviceclient:' + // BEGIN + // serviceclient+=ServiceClient* + // END + // )| + // ('actionserver:' + // BEGIN + // actionserver+=ActionServer* + // END + // )| + // ('actionclient:' + // BEGIN + // actionclient+=ActionClient* + // END + // )| + // ('parameters:' + // BEGIN + // parameter+=Parameter* + // END + // ) + // )*END + // ; + public RosGrammarAccess.NodeElements getNodeAccess() { + return gaRos.getNodeAccess(); + } + + public ParserRule getNodeRule() { + return getNodeAccess().getRule(); + } + + ///////////////////// + ////OBJECTS/SPECIFICATIONS + ///////////////////// + //SpecBase returns SpecBase: + // TopicSpec | ServiceSpec | ActionSpec; + public RosGrammarAccess.SpecBaseElements getSpecBaseAccess() { + return gaRos.getSpecBaseAccess(); + } + + public ParserRule getSpecBaseRule() { + return getSpecBaseAccess().getRule(); + } + + //TopicSpec returns TopicSpec: + // {TopicSpec} + // 'msg:'name=(EString|'Header'|'String') + // BEGIN + // 'message:' (BEGIN message=MessageDefinition END)? + // END + // ; + public RosGrammarAccess.TopicSpecElements getTopicSpecAccess() { + return gaRos.getTopicSpecAccess(); + } + + public ParserRule getTopicSpecRule() { + return getTopicSpecAccess().getRule(); + } + + //ServiceSpec returns ServiceSpec: + // {ServiceSpec} + // 'srv:'name=EString + // BEGIN + // 'request:' (BEGIN request=MessageDefinition END)? + // 'response:' (BEGIN response=MessageDefinition END)? + // END; + public RosGrammarAccess.ServiceSpecElements getServiceSpecAccess() { + return gaRos.getServiceSpecAccess(); + } + + public ParserRule getServiceSpecRule() { + return getServiceSpecAccess().getRule(); + } + + //ActionSpec returns ActionSpec: + // {ActionSpec} + // 'action:'name=EString + // BEGIN + // 'goal:' (BEGIN goal=MessageDefinition END)? + // 'result:' (BEGIN result=MessageDefinition END)? + // 'feedback:' (BEGIN feedback=MessageDefinition END)? + // END; + public RosGrammarAccess.ActionSpecElements getActionSpecAccess() { + return gaRos.getActionSpecAccess(); + } + + public ParserRule getActionSpecRule() { + return getActionSpecAccess().getRule(); + } + + //MessageDefinition returns MessageDefinition: + // {MessageDefinition} + // MessagePart+=MessagePart*; + public RosGrammarAccess.MessageDefinitionElements getMessageDefinitionAccess() { + return gaRos.getMessageDefinitionAccess(); + } + + public ParserRule getMessageDefinitionRule() { + return getMessageDefinitionAccess().getRule(); + } + + ///////////////////// + ////INTERFACES + ///////////////////// + //Publisher returns Publisher: + // {Publisher} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; + public RosGrammarAccess.PublisherElements getPublisherAccess() { + return gaRos.getPublisherAccess(); + } + + public ParserRule getPublisherRule() { + return getPublisherAccess().getRule(); + } + + //Subscriber returns Subscriber: + // {Subscriber} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; + public RosGrammarAccess.SubscriberElements getSubscriberAccess() { + return gaRos.getSubscriberAccess(); + } + + public ParserRule getSubscriberRule() { + return getSubscriberAccess().getRule(); + } + + //ServiceServer returns ServiceServer: + // {ServiceServer} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; + public RosGrammarAccess.ServiceServerElements getServiceServerAccess() { + return gaRos.getServiceServerAccess(); + } + + public ParserRule getServiceServerRule() { + return getServiceServerAccess().getRule(); + } + + //ServiceClient returns ServiceClient: + // {ServiceClient} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; + public RosGrammarAccess.ServiceClientElements getServiceClientAccess() { + return gaRos.getServiceClientAccess(); + } + + public ParserRule getServiceClientRule() { + return getServiceClientAccess().getRule(); + } + + //ActionServer returns ActionServer: + // {ActionServer} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; + public RosGrammarAccess.ActionServerElements getActionServerAccess() { + return gaRos.getActionServerAccess(); + } + + public ParserRule getActionServerRule() { + return getActionServerAccess().getRule(); + } + + //ActionClient returns ActionClient: + // {ActionClient} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // END + // ; + public RosGrammarAccess.ActionClientElements getActionClientAccess() { + return gaRos.getActionClientAccess(); + } + + public ParserRule getActionClientRule() { + return getActionClientAccess().getRule(); + } + + ///////////////////// + ////DEPENDENCIES + ///////////////////// + //Dependency returns Dependency: + // PackageDependency | ExternalDependency; + public RosGrammarAccess.DependencyElements getDependencyAccess() { + return gaRos.getDependencyAccess(); + } + + public ParserRule getDependencyRule() { + return getDependencyAccess().getRule(); + } + + //PackageDependency returns PackageDependency: + // package=[Package|EString]; + public RosGrammarAccess.PackageDependencyElements getPackageDependencyAccess() { + return gaRos.getPackageDependencyAccess(); + } + + public ParserRule getPackageDependencyRule() { + return getPackageDependencyAccess().getRule(); + } + + //ExternalDependency returns ExternalDependency: + // {ExternalDependency} + // 'ExternalDependency' + // name=EString; + public RosGrammarAccess.ExternalDependencyElements getExternalDependencyAccess() { + return gaRos.getExternalDependencyAccess(); + } + + public ParserRule getExternalDependencyRule() { + return getExternalDependencyAccess().getRule(); + } + + ///////////////////// + ////NAMESPACES + ///////////////////// + //Namespace returns Namespace: + // GlobalNamespace | RelativeNamespace_Impl | PrivateNamespace; + public RosGrammarAccess.NamespaceElements getNamespaceAccess() { + return gaRos.getNamespaceAccess(); + } + + public ParserRule getNamespaceRule() { + return getNamespaceAccess().getRule(); + } + + //GraphName returns GraphName: + // 'GraphName' ; + public RosGrammarAccess.GraphNameElements getGraphNameAccess() { + return gaRos.getGraphNameAccess(); + } + + public ParserRule getGraphNameRule() { + return getGraphNameAccess().getRule(); + } + + //GlobalNamespace returns GlobalNamespace: + // {GlobalNamespace} + // 'GlobalNamespace' + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; + public RosGrammarAccess.GlobalNamespaceElements getGlobalNamespaceAccess() { + return gaRos.getGlobalNamespaceAccess(); + } + + public ParserRule getGlobalNamespaceRule() { + return getGlobalNamespaceAccess().getRule(); + } + + //RelativeNamespace_Impl returns RelativeNamespace: + // {RelativeNamespace} + // 'RelativeNamespace' + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; + public RosGrammarAccess.RelativeNamespace_ImplElements getRelativeNamespace_ImplAccess() { + return gaRos.getRelativeNamespace_ImplAccess(); + } + + public ParserRule getRelativeNamespace_ImplRule() { + return getRelativeNamespace_ImplAccess().getRule(); + } + + //PrivateNamespace returns PrivateNamespace: + // {PrivateNamespace} + // 'PrivateNamespace' + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; + public RosGrammarAccess.PrivateNamespaceElements getPrivateNamespaceAccess() { + return gaRos.getPrivateNamespaceAccess(); + } + + public ParserRule getPrivateNamespaceRule() { + return getPrivateNamespaceAccess().getRule(); + } + + ///////////////////// + ////PARAMETERS DEFINITION + ///////////////////// + //RosParamNames returns ecore::EString: + // ROS_CONVENTION_PARAM | ID + //; + public RosGrammarAccess.RosParamNamesElements getRosParamNamesAccess() { + return gaRos.getRosParamNamesAccess(); + } + + public ParserRule getRosParamNamesRule() { + return getRosParamNamesAccess().getRule(); + } + + //Parameter returns Parameter: + // {Parameter} + // name=EString':' + // BEGIN + // 'type' type=ParameterType + // ('ns:' namespace=Namespace)? + // END + // '}'; + public RosGrammarAccess.ParameterElements getParameterAccess() { + return gaRos.getParameterAccess(); + } + + public ParserRule getParameterRule() { + return getParameterAccess().getRule(); + } + + //ParameterType returns ParameterType: + // ParameterListType | ParameterStructType | ParameterIntegerType | ParameterStringType | ParameterDoubleType | ParameterBooleanType | ParameterBase64Type | ParameterArrayType; + public RosGrammarAccess.ParameterTypeElements getParameterTypeAccess() { + return gaRos.getParameterTypeAccess(); + } + + public ParserRule getParameterTypeRule() { + return getParameterTypeAccess().getRule(); + } + + // // | ParameterDateType; + //ParameterValue returns ParameterValue: + // ParameterString | ParameterBase64 | ParameterInteger | ParameterDouble | ParameterBoolean | ParameterList | ParameterStruct; + public RosGrammarAccess.ParameterValueElements getParameterValueAccess() { + return gaRos.getParameterValueAccess(); + } + + public ParserRule getParameterValueRule() { + return getParameterValueAccess().getRule(); + } + + // // | ParameterDate; + //ParameterListType returns ParameterListType: + // {ParameterListType} + // 'List' + // '[' + // sequence+=ParameterType ( ',' sequence+=ParameterType )* + // ']'; + public RosGrammarAccess.ParameterListTypeElements getParameterListTypeAccess() { + return gaRos.getParameterListTypeAccess(); + } + + public ParserRule getParameterListTypeRule() { + return getParameterListTypeAccess().getRule(); + } + + //ParameterStructType returns ParameterStructType: + // {ParameterStructType} + // 'Struct' + // '[' + // parameterstructypetmember+=ParameterStructTypeMember ( "," parameterstructypetmember+=ParameterStructTypeMember)* + // ']'; + public RosGrammarAccess.ParameterStructTypeElements getParameterStructTypeAccess() { + return gaRos.getParameterStructTypeAccess(); + } + + public ParserRule getParameterStructTypeRule() { + return getParameterStructTypeAccess().getRule(); + } + + //ParameterIntegerType returns ParameterIntegerType: + // {ParameterIntegerType} + // 'Integer' + // ('default' default=ParameterInteger)?; + public RosGrammarAccess.ParameterIntegerTypeElements getParameterIntegerTypeAccess() { + return gaRos.getParameterIntegerTypeAccess(); + } + + public ParserRule getParameterIntegerTypeRule() { + return getParameterIntegerTypeAccess().getRule(); + } + + //ParameterStringType returns ParameterStringType: + // {ParameterStringType} + // 'String' + // ('default' default=ParameterString)?; + public RosGrammarAccess.ParameterStringTypeElements getParameterStringTypeAccess() { + return gaRos.getParameterStringTypeAccess(); + } + + public ParserRule getParameterStringTypeRule() { + return getParameterStringTypeAccess().getRule(); + } + + //ParameterDoubleType returns ParameterDoubleType: + // {ParameterDoubleType} + // 'Double' + // ('default' default=ParameterDouble)?; + public RosGrammarAccess.ParameterDoubleTypeElements getParameterDoubleTypeAccess() { + return gaRos.getParameterDoubleTypeAccess(); + } + + public ParserRule getParameterDoubleTypeRule() { + return getParameterDoubleTypeAccess().getRule(); + } + + //ParameterDateType returns ParameterDateType: + // {ParameterDateType} + // 'Date' + // ('default' default=ParameterDate)?; + public RosGrammarAccess.ParameterDateTypeElements getParameterDateTypeAccess() { + return gaRos.getParameterDateTypeAccess(); + } + + public ParserRule getParameterDateTypeRule() { + return getParameterDateTypeAccess().getRule(); + } + + //ParameterBooleanType returns ParameterBooleanType: + // {ParameterBooleanType} + // 'Boolean' + // ('default' default=ParameterBoolean)?; + public RosGrammarAccess.ParameterBooleanTypeElements getParameterBooleanTypeAccess() { + return gaRos.getParameterBooleanTypeAccess(); + } + + public ParserRule getParameterBooleanTypeRule() { + return getParameterBooleanTypeAccess().getRule(); + } + + //ParameterBase64Type returns ParameterBase64Type: + // {ParameterBase64Type} + // 'Base64' + // ('default' default=ParameterBase64)?; + public RosGrammarAccess.ParameterBase64TypeElements getParameterBase64TypeAccess() { + return gaRos.getParameterBase64TypeAccess(); + } + + public ParserRule getParameterBase64TypeRule() { + return getParameterBase64TypeAccess().getRule(); + } + + //ParameterAnyType returns ParameterAnyType: + // {ParameterAnyType} + // 'Any' + // ('default' default=ParameterAny)?; + public RosGrammarAccess.ParameterAnyTypeElements getParameterAnyTypeAccess() { + return gaRos.getParameterAnyTypeAccess(); + } + + public ParserRule getParameterAnyTypeRule() { + return getParameterAnyTypeAccess().getRule(); + } + + //ParameterArrayType returns ParameterArrayType: + // 'Array:' + // BEGIN + // 'type' type=ParameterType + // ('default' default=ParameterList)? + // END; + public RosGrammarAccess.ParameterArrayTypeElements getParameterArrayTypeAccess() { + return gaRos.getParameterArrayTypeAccess(); + } + + public ParserRule getParameterArrayTypeRule() { + return getParameterArrayTypeAccess().getRule(); + } + + //ParameterList returns ParameterSequence: + // {ParameterSequence} + // '[' value+=ParameterValue ( ',' value+=ParameterValue )* ']' + //; + public RosGrammarAccess.ParameterListElements getParameterListAccess() { + return gaRos.getParameterListAccess(); + } + + public ParserRule getParameterListRule() { + return getParameterListAccess().getRule(); + } + + //ParameterAny returns ParameterAny: + // {ParameterAny} + // 'ParameterAny' + // ('value' value=EString)? + // ; + public RosGrammarAccess.ParameterAnyElements getParameterAnyAccess() { + return gaRos.getParameterAnyAccess(); + } + + public ParserRule getParameterAnyRule() { + return getParameterAnyAccess().getRule(); + } + + //ParameterString returns ParameterString: + // value=EString + //; + public RosGrammarAccess.ParameterStringElements getParameterStringAccess() { + return gaRos.getParameterStringAccess(); + } + + public ParserRule getParameterStringRule() { + return getParameterStringAccess().getRule(); + } + + //ParameterBase64 returns ParameterBase64: + // value=Base64Binary + //; + public RosGrammarAccess.ParameterBase64Elements getParameterBase64Access() { + return gaRos.getParameterBase64Access(); + } + + public ParserRule getParameterBase64Rule() { + return getParameterBase64Access().getRule(); + } + + //ParameterInteger returns ParameterInteger: + // value=Integer0 + //; + public RosGrammarAccess.ParameterIntegerElements getParameterIntegerAccess() { + return gaRos.getParameterIntegerAccess(); + } + + public ParserRule getParameterIntegerRule() { + return getParameterIntegerAccess().getRule(); + } + + //ParameterDouble returns ParameterDouble: + // value=Double0 + //; + public RosGrammarAccess.ParameterDoubleElements getParameterDoubleAccess() { + return gaRos.getParameterDoubleAccess(); + } + + public ParserRule getParameterDoubleRule() { + return getParameterDoubleAccess().getRule(); + } + + //ParameterBoolean returns ParameterBoolean: + // value=boolean0 + //; + public RosGrammarAccess.ParameterBooleanElements getParameterBooleanAccess() { + return gaRos.getParameterBooleanAccess(); + } + + public ParserRule getParameterBooleanRule() { + return getParameterBooleanAccess().getRule(); + } + + //ParameterStruct returns ParameterStruct: + // {ParameterStruct} + // ('[' value+=ParameterStructMember ( "," '[' value+=ParameterStructMember ']')* ']' )? + //; + public RosGrammarAccess.ParameterStructElements getParameterStructAccess() { + return gaRos.getParameterStructAccess(); + } + + public ParserRule getParameterStructRule() { + return getParameterStructAccess().getRule(); + } + + //ParameterDate returns ParameterDate: + // value=DateTime0 + // ; + public RosGrammarAccess.ParameterDateElements getParameterDateAccess() { + return gaRos.getParameterDateAccess(); + } + + public ParserRule getParameterDateRule() { + return getParameterDateAccess().getRule(); + } + + //ParameterStructMember returns ParameterStructMember: + // 'ParameterStructMember' + // name=EString':' + // BEGIN + // value=ParameterValue + // END; + public RosGrammarAccess.ParameterStructMemberElements getParameterStructMemberAccess() { + return gaRos.getParameterStructMemberAccess(); + } + + public ParserRule getParameterStructMemberRule() { + return getParameterStructMemberAccess().getRule(); + } + + //ParameterStructTypeMember returns ParameterStructTypeMember: + // name=EString + // type=ParameterType + // ; + public RosGrammarAccess.ParameterStructTypeMemberElements getParameterStructTypeMemberAccess() { + return gaRos.getParameterStructTypeMemberAccess(); + } + + public ParserRule getParameterStructTypeMemberRule() { + return getParameterStructTypeMemberAccess().getRule(); + } + + ///////////////////// + ////PARAMETERS PRIMITIVES TYPES + ///////////////////// + //terminal DIGIT: '0'..'9'; + public TerminalRule getDIGITRule() { + return gaRos.getDIGITRule(); + } + + //terminal BINARY: ('0b'|'0B')('0'|'1')+; + public TerminalRule getBINARYRule() { + return gaRos.getBINARYRule(); + } + + //terminal BOOLEAN: 'true'|'false'; + public TerminalRule getBOOLEANRule() { + return gaRos.getBOOLEANRule(); + } + + //terminal DOUBLE returns ecore::EDouble: DIGIT (('.' DECINT*) | (('.' DIGIT*)? ('E'|'e') ('-'|'+')? DIGIT)); + public TerminalRule getDOUBLERule() { + return gaRos.getDOUBLERule(); + } + + // // Use terminal to avoid 'e' turning into a keyword + //terminal DECINT: '0' | ('1'..'9' DIGIT*) | ('-''0'..'9' DIGIT*) ; + public TerminalRule getDECINTRule() { + return gaRos.getDECINTRule(); + } + + //terminal DAY:'1'..'9' | '1'..'3' '0'..'9'; + public TerminalRule getDAYRule() { + return gaRos.getDAYRule(); + } + + //terminal MONTH:'1'..'9' | '1' '0'..'2'; + public TerminalRule getMONTHRule() { + return gaRos.getMONTHRule(); + } + + //terminal YEAR:'0'..'2' '0'..'9' '0'..'9' '0'..'9'; + public TerminalRule getYEARRule() { + return gaRos.getYEARRule(); + } + + //terminal HOUR: ('0'..'1')('0'..'9') | ('2')('0'..'3'); + public TerminalRule getHOURRule() { + return gaRos.getHOURRule(); + } + + //terminal MIN_SEC:('0'..'5')('0'..'9'); + public TerminalRule getMIN_SECRule() { + return gaRos.getMIN_SECRule(); + } + + //terminal DATE_TIME: YEAR'-'MONTH'-'DAY'T'HOUR':'MIN_SEC':'MIN_SEC; + public TerminalRule getDATE_TIMERule() { + return gaRos.getDATE_TIMERule(); + } + + //Base64Binary returns type::Base64Binary: + // BINARY ; + public RosGrammarAccess.Base64BinaryElements getBase64BinaryAccess() { + return gaRos.getBase64BinaryAccess(); + } + + public ParserRule getBase64BinaryRule() { + return getBase64BinaryAccess().getRule(); + } + + //boolean0 returns type::Boolean: + // BOOLEAN; + public RosGrammarAccess.Boolean0Elements getBoolean0Access() { + return gaRos.getBoolean0Access(); + } + + public ParserRule getBoolean0Rule() { + return getBoolean0Access().getRule(); + } + + //Double0 returns type::Double: + // DOUBLE; + public RosGrammarAccess.Double0Elements getDouble0Access() { + return gaRos.getDouble0Access(); + } + + public ParserRule getDouble0Rule() { + return getDouble0Access().getRule(); + } + + //Integer0 returns type::Int: + // DECINT; + public RosGrammarAccess.Integer0Elements getInteger0Access() { + return gaRos.getInteger0Access(); + } + + public ParserRule getInteger0Rule() { + return getInteger0Access().getRule(); + } + + //DateTime0 returns type::DateTime: + // DATE_TIME; + public RosGrammarAccess.DateTime0Elements getDateTime0Access() { + return gaRos.getDateTime0Access(); + } + + public ParserRule getDateTime0Rule() { + return getDateTime0Access().getRule(); + } + + ///////////////////// + ////MESSAGE PRIMITIVES DEFINITION + ///////////////////// + //MessagePart returns primitives::MessagePart: + // Type = AbstractType + // Data =(KEYWORD | MESSAGE_ASIGMENT | EString) + //; + public RosGrammarAccess.MessagePartElements getMessagePartAccess() { + return gaRos.getMessagePartAccess(); + } + + public ParserRule getMessagePartRule() { + return getMessagePartAccess().getRule(); + } + + //terminal MESSAGE_ASIGMENT: + // ((ID|STRING)'='(ID|STRING|INT|'-'INT)) + //; + public TerminalRule getMESSAGE_ASIGMENTRule() { + return gaRos.getMESSAGE_ASIGMENTRule(); + } + + //AbstractType returns primitives::AbstractType: + // bool | int8 | uint8 | int16 | uint16 | int32 | uint32 | int64 | uint64 | float32 | float64 | string0 | byte | time | duration | Header | + // boolArray | int8Array | uint8Array | int16Array | uint16Array | int32Array | uint32Array | int64Array | uint64Array | float32Array | float64Array | string0Array | byteArray | + // TopicSpecRef | ArrayTopicSpecRef ; + public RosGrammarAccess.AbstractTypeElements getAbstractTypeAccess() { + return gaRos.getAbstractTypeAccess(); + } + + public ParserRule getAbstractTypeRule() { + return getAbstractTypeAccess().getRule(); + } + + //bool returns primitives::bool: + // {primitives::bool} + // 'bool' + // ; + public RosGrammarAccess.BoolElements getBoolAccess() { + return gaRos.getBoolAccess(); + } + + public ParserRule getBoolRule() { + return getBoolAccess().getRule(); + } + + //int8 returns primitives::int8: + // {primitives::int8} + // 'int8' + // ; + public RosGrammarAccess.Int8Elements getInt8Access() { + return gaRos.getInt8Access(); + } + + public ParserRule getInt8Rule() { + return getInt8Access().getRule(); + } + + //uint8 returns primitives::uint8: + // {primitives::uint8} + // 'uint8' + // ; + public RosGrammarAccess.Uint8Elements getUint8Access() { + return gaRos.getUint8Access(); + } + + public ParserRule getUint8Rule() { + return getUint8Access().getRule(); + } + + //int16 returns primitives::int16: + // {primitives::int16} + // 'int16' + // ; + public RosGrammarAccess.Int16Elements getInt16Access() { + return gaRos.getInt16Access(); + } + + public ParserRule getInt16Rule() { + return getInt16Access().getRule(); + } + + //uint16 returns primitives::uint16: + // {primitives::uint16} + // 'uint16' + // ; + public RosGrammarAccess.Uint16Elements getUint16Access() { + return gaRos.getUint16Access(); + } + + public ParserRule getUint16Rule() { + return getUint16Access().getRule(); + } + + //int32 returns primitives::int32: + // {primitives::int32} + // 'int32' + // ; + public RosGrammarAccess.Int32Elements getInt32Access() { + return gaRos.getInt32Access(); + } + + public ParserRule getInt32Rule() { + return getInt32Access().getRule(); + } + + //uint32 returns primitives::uint32: + // {primitives::uint32} + // 'uint32' + // ; + public RosGrammarAccess.Uint32Elements getUint32Access() { + return gaRos.getUint32Access(); + } + + public ParserRule getUint32Rule() { + return getUint32Access().getRule(); + } + + //int64 returns primitives::int64: + // {primitives::int64} + // 'int64' + // ; + public RosGrammarAccess.Int64Elements getInt64Access() { + return gaRos.getInt64Access(); + } + + public ParserRule getInt64Rule() { + return getInt64Access().getRule(); + } + + //uint64 returns primitives::uint64: + // {primitives::uint64} + // 'uint64' + // ; + public RosGrammarAccess.Uint64Elements getUint64Access() { + return gaRos.getUint64Access(); + } + + public ParserRule getUint64Rule() { + return getUint64Access().getRule(); + } + + //float32 returns primitives::float32: + // {primitives::float32} + // 'float32' + // ; + public RosGrammarAccess.Float32Elements getFloat32Access() { + return gaRos.getFloat32Access(); + } + + public ParserRule getFloat32Rule() { + return getFloat32Access().getRule(); + } + + //float64 returns primitives::float64: + // {primitives::float64} + // 'float64' + // ; + public RosGrammarAccess.Float64Elements getFloat64Access() { + return gaRos.getFloat64Access(); + } + + public ParserRule getFloat64Rule() { + return getFloat64Access().getRule(); + } + + //string0 returns primitives::string: + // {primitives::string} + // 'string' + // ; + public RosGrammarAccess.String0Elements getString0Access() { + return gaRos.getString0Access(); + } + + public ParserRule getString0Rule() { + return getString0Access().getRule(); + } + + //byte returns primitives::Byte: + // {primitives::Byte} + // 'byte' + // ; + public RosGrammarAccess.ByteElements getByteAccess() { + return gaRos.getByteAccess(); + } + + public ParserRule getByteRule() { + return getByteAccess().getRule(); + } + + //time returns primitives::time: + // {primitives::time} + // 'time' + // ; + public RosGrammarAccess.TimeElements getTimeAccess() { + return gaRos.getTimeAccess(); + } + + public ParserRule getTimeRule() { + return getTimeAccess().getRule(); + } + + //duration returns primitives::duration: + // {primitives::duration} + // 'duration' + // ; + public RosGrammarAccess.DurationElements getDurationAccess() { + return gaRos.getDurationAccess(); + } + + public ParserRule getDurationRule() { + return getDurationAccess().getRule(); + } + + //boolArray returns primitives::boolArray: + // {primitives::boolArray} + // 'bool[]' + // ; + public RosGrammarAccess.BoolArrayElements getBoolArrayAccess() { + return gaRos.getBoolArrayAccess(); + } + + public ParserRule getBoolArrayRule() { + return getBoolArrayAccess().getRule(); + } + + //int8Array returns primitives::int8Array: + // {primitives::int8Array} + // 'int8[]' + // ; + public RosGrammarAccess.Int8ArrayElements getInt8ArrayAccess() { + return gaRos.getInt8ArrayAccess(); + } + + public ParserRule getInt8ArrayRule() { + return getInt8ArrayAccess().getRule(); + } + + //uint8Array returns primitives::uint8Array: + // {primitives::uint8Array} + // 'uint8[]' + // ; + public RosGrammarAccess.Uint8ArrayElements getUint8ArrayAccess() { + return gaRos.getUint8ArrayAccess(); + } + + public ParserRule getUint8ArrayRule() { + return getUint8ArrayAccess().getRule(); + } + + //int16Array returns primitives::int16Array: + // {primitives::int16Array} + // 'int16[]' + // ; + public RosGrammarAccess.Int16ArrayElements getInt16ArrayAccess() { + return gaRos.getInt16ArrayAccess(); + } + + public ParserRule getInt16ArrayRule() { + return getInt16ArrayAccess().getRule(); + } + + //uint16Array returns primitives::uint16Array: + // {primitives::uint16Array} + // 'uint16[]' + // ; + public RosGrammarAccess.Uint16ArrayElements getUint16ArrayAccess() { + return gaRos.getUint16ArrayAccess(); + } + + public ParserRule getUint16ArrayRule() { + return getUint16ArrayAccess().getRule(); + } + + //int32Array returns primitives::int32Array: + // {primitives::int32Array} + // 'int32[]' + // ; + public RosGrammarAccess.Int32ArrayElements getInt32ArrayAccess() { + return gaRos.getInt32ArrayAccess(); + } + + public ParserRule getInt32ArrayRule() { + return getInt32ArrayAccess().getRule(); + } + + //uint32Array returns primitives::uint32Array: + // {primitives::uint32Array} + // 'uint32[]' + // ; + public RosGrammarAccess.Uint32ArrayElements getUint32ArrayAccess() { + return gaRos.getUint32ArrayAccess(); + } + + public ParserRule getUint32ArrayRule() { + return getUint32ArrayAccess().getRule(); + } + + //int64Array returns primitives::int64Array: + // {primitives::int64Array} + // 'int64[]' + // ; + public RosGrammarAccess.Int64ArrayElements getInt64ArrayAccess() { + return gaRos.getInt64ArrayAccess(); + } + + public ParserRule getInt64ArrayRule() { + return getInt64ArrayAccess().getRule(); + } + + //uint64Array returns primitives::uint64Array: + // {primitives::uint64Array} + // 'uint64[]' + // ; + public RosGrammarAccess.Uint64ArrayElements getUint64ArrayAccess() { + return gaRos.getUint64ArrayAccess(); + } + + public ParserRule getUint64ArrayRule() { + return getUint64ArrayAccess().getRule(); + } + + //float32Array returns primitives::float32Array: + // {primitives::float32Array} + // 'float32[]' + // ; + public RosGrammarAccess.Float32ArrayElements getFloat32ArrayAccess() { + return gaRos.getFloat32ArrayAccess(); + } + + public ParserRule getFloat32ArrayRule() { + return getFloat32ArrayAccess().getRule(); + } + + //float64Array returns primitives::float64Array: + // {primitives::float64Array} + // 'float64[]' + // ; + public RosGrammarAccess.Float64ArrayElements getFloat64ArrayAccess() { + return gaRos.getFloat64ArrayAccess(); + } + + public ParserRule getFloat64ArrayRule() { + return getFloat64ArrayAccess().getRule(); + } + + //string0Array returns primitives::stringArray: + // {primitives::stringArray} + // 'string[]' + // ; + public RosGrammarAccess.String0ArrayElements getString0ArrayAccess() { + return gaRos.getString0ArrayAccess(); + } + + public ParserRule getString0ArrayRule() { + return getString0ArrayAccess().getRule(); + } + + //byteArray returns primitives::ByteArray: + // {primitives::ByteArray} + // 'byte[]' + // ; + public RosGrammarAccess.ByteArrayElements getByteArrayAccess() { + return gaRos.getByteArrayAccess(); + } + + public ParserRule getByteArrayRule() { + return getByteArrayAccess().getRule(); + } + + //Header returns primitives::Header: + // {primitives::Header} + // 'Header' + //; + public RosGrammarAccess.HeaderElements getHeaderAccess() { + return gaRos.getHeaderAccess(); + } + + public ParserRule getHeaderRule() { + return getHeaderAccess().getRule(); + } + + //TopicSpecRef returns primitives::TopicSpecRef: + // TopicSpec=[TopicSpec|EString] + //; + public RosGrammarAccess.TopicSpecRefElements getTopicSpecRefAccess() { + return gaRos.getTopicSpecRefAccess(); + } + + public ParserRule getTopicSpecRefRule() { + return getTopicSpecRefAccess().getRule(); + } + + //ArrayTopicSpecRef returns primitives::ArrayTopicSpecRef: + // TopicSpec=[TopicSpec|EString]'[]' + //; + public RosGrammarAccess.ArrayTopicSpecRefElements getArrayTopicSpecRefAccess() { + return gaRos.getArrayTopicSpecRefAccess(); + } + + public ParserRule getArrayTopicSpecRefRule() { + return getArrayTopicSpecRefAccess().getRule(); + } + + //KEYWORD: 'goal' | 'message' | 'result' | 'feedback' | 'name' | 'value' | 'service' | 'type' | 'action' | 'duration' | 'time' ; + public RosGrammarAccess.KEYWORDElements getKEYWORDAccess() { + return gaRos.getKEYWORDAccess(); + } + + public ParserRule getKEYWORDRule() { + return getKEYWORDAccess().getRule(); + } + + //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..7aaf7a51a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/validation/AbstractRos1Validator.java @@ -0,0 +1,20 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.validation; + +import de.fraunhofer.ipa.ros.validation.RosValidator; +import java.util.ArrayList; +import java.util.List; +import org.eclipse.emf.ecore.EPackage; + +public abstract class AbstractRos1Validator extends RosValidator { + + @Override + protected List getEPackages() { + List result = new ArrayList(super.getEPackages()); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.ipa.fraunhofer.de/ros")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.ipa.fraunhofer.de/primitives")); + 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..a2844c4b3 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1.xtext @@ -0,0 +1,25 @@ +// automatically generated by Xtext +grammar de.fraunhofer.ipa.ros1.Ros1 with de.fraunhofer.ipa.ros.Ros + +import "http://www.ipa.fraunhofer.de/primitives" +import "http://www.eclipse.org/emf/2002/Ecore" as ecore +import "http://www.ipa.fraunhofer.de/ros" + +@Override +Package returns Package: + CatkinPackage + ; + +@Override +CatkinPackage returns CatkinPackage: + {CatkinPackage} + name=RosNames':' + BEGIN + ('fromGitRepo:' fromGitRepo=EString)? + ('artifacts:' + BEGIN + artifact+=Artifact* + END + )? + ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + END; \ 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); +// } +// } + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/.classpath b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/.classpath new file mode 100644 index 000000000..a61354428 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/.classpath @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/.project b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/.project new file mode 100644 index 000000000..b2c6529c4 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/.project @@ -0,0 +1,34 @@ + + + de.fraunhofer.ipa.ros2.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.ros2.xtext.ide/.settings/org.eclipse.core.resources.prefs b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 000000000..99f26c020 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.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.ros2.xtext.ide/.settings/org.eclipse.jdt.core.prefs b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000..7adc0fb9a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.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.ros2.xtext.ide/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/META-INF/MANIFEST.MF new file mode 100644 index 000000000..4626f6149 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/META-INF/MANIFEST.MF @@ -0,0 +1,19 @@ +Manifest-Version: 1.0 +Automatic-Module-Name: de.fraunhofer.ipa.ros2.xtext.ide +Bundle-ManifestVersion: 2 +Bundle-Name: de.fraunhofer.ipa.ros2.xtext.ide +Bundle-Vendor: Fraunhofer IPA +Bundle-Version: 2.0.0.qualifier +Bundle-SymbolicName: de.fraunhofer.ipa.ros2.xtext.ide; singleton:=true +Bundle-ActivationPolicy: lazy +Require-Bundle: de.fraunhofer.ipa.ros2.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)", + de.fraunhofer.ipa.ros.xtext;bundle-version="2.0.0", + de.fraunhofer.ipa.ros.xtext.ui;bundle-version="2.0.0" +Bundle-RequiredExecutionEnvironment: JavaSE-11 +Export-Package: de.fraunhofer.ipa.ros2.ide.contentassist.antlr.internal, + de.fraunhofer.ipa.ros2.ide.contentassist.antlr, + de.fraunhofer.ipa.ros2.ide.contentassist.antlr.lexer diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/build.properties b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/build.properties new file mode 100644 index 000000000..5c6bbf99f --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.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.ros2.xtext.ide/pom.xml b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/pom.xml new file mode 100644 index 000000000..c8c5c3f0a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/pom.xml @@ -0,0 +1,33 @@ + + 4.0.0 + + de.fraunhofer.ipa.ros + de.fraunhofer.ipa.ros.parent + 2.0.0-SNAPSHOT + ../de.fraunhofer.ipa.ros.parent/pom.xml + + de.fraunhofer.ipa.ros2.xtext.ide + eclipse-plugin + + + + + org.eclipse.xtend + xtend-maven-plugin + + + org.apache.maven.plugins + maven-clean-plugin + + + xtend-gen-clean + clean + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup new file mode 100644 index 000000000..b22c54ca5 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup @@ -0,0 +1 @@ +de.fraunhofer.ipa.ros2.ide.Ros2IdeSetup diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/AbstractRos2IdeModule.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/AbstractRos2IdeModule.java new file mode 100644 index 000000000..e188eea4a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/AbstractRos2IdeModule.java @@ -0,0 +1,67 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.ide; + +import com.google.inject.Binder; +import com.google.inject.name.Names; +import de.fraunhofer.ipa.ros2.ide.contentassist.antlr.Ros2Parser; +import de.fraunhofer.ipa.ros2.ide.contentassist.antlr.lexer.InternalRos2Lexer; +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 Ros2IdeModule}. + */ +@SuppressWarnings("all") +public abstract class AbstractRos2IdeModule 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(InternalRos2Lexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIContentAssistParser() { + return Ros2Parser.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.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/PartialRos2ContentAssistParser.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/PartialRos2ContentAssistParser.java new file mode 100644 index 000000000..9e7633087 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/PartialRos2ContentAssistParser.java @@ -0,0 +1,33 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.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 PartialRos2ContentAssistParser extends Ros2Parser { + + 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.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/Ros2Parser.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/Ros2Parser.java new file mode 100644 index 000000000..21f8f2140 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/Ros2Parser.java @@ -0,0 +1,341 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.ide.contentassist.antlr; + +import com.google.common.collect.ImmutableMap; +import com.google.inject.Inject; +import com.google.inject.Singleton; +import de.fraunhofer.ipa.ros2.ide.contentassist.antlr.internal.InternalRos2Parser; +import de.fraunhofer.ipa.ros2.services.Ros2GrammarAccess; +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 Ros2Parser extends AbstractContentAssistParser { + + @Singleton + public static final class NameMappings { + + private final Map mappings; + + @Inject + public NameMappings(Ros2GrammarAccess 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, Ros2GrammarAccess grammarAccess) { + builder.put(grammarAccess.getQualityOfServiceAccess().getQoSProfileAlternatives_1_0_1_0(), "rule__QualityOfService__QoSProfileAlternatives_1_0_1_0"); + builder.put(grammarAccess.getQualityOfServiceAccess().getHistoryAlternatives_1_1_1_0(), "rule__QualityOfService__HistoryAlternatives_1_1_1_0"); + builder.put(grammarAccess.getQualityOfServiceAccess().getReliabilityAlternatives_1_3_1_0(), "rule__QualityOfService__ReliabilityAlternatives_1_3_1_0"); + builder.put(grammarAccess.getQualityOfServiceAccess().getDurabilityAlternatives_1_4_1_0(), "rule__QualityOfService__DurabilityAlternatives_1_4_1_0"); + builder.put(grammarAccess.getEStringAccess().getAlternatives(), "rule__EString__Alternatives"); + builder.put(grammarAccess.getRosNamesAccess().getAlternatives(), "rule__RosNames__Alternatives"); + builder.put(grammarAccess.getNodeAccess().getAlternatives_3(), "rule__Node__Alternatives_3"); + builder.put(grammarAccess.getSpecBaseAccess().getAlternatives(), "rule__SpecBase__Alternatives"); + builder.put(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0(), "rule__TopicSpec__NameAlternatives_2_0"); + builder.put(grammarAccess.getDependencyAccess().getAlternatives(), "rule__Dependency__Alternatives"); + builder.put(grammarAccess.getNamespaceAccess().getAlternatives(), "rule__Namespace__Alternatives"); + builder.put(grammarAccess.getRosParamNamesAccess().getAlternatives(), "rule__RosParamNames__Alternatives"); + builder.put(grammarAccess.getParameterTypeAccess().getAlternatives(), "rule__ParameterType__Alternatives"); + builder.put(grammarAccess.getParameterValueAccess().getAlternatives(), "rule__ParameterValue__Alternatives"); + builder.put(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0(), "rule__MessagePart__DataAlternatives_1_0"); + builder.put(grammarAccess.getAbstractTypeAccess().getAlternatives(), "rule__AbstractType__Alternatives"); + builder.put(grammarAccess.getKEYWORDAccess().getAlternatives(), "rule__KEYWORD__Alternatives"); + builder.put(grammarAccess.getAmentPackageAccess().getGroup(), "rule__AmentPackage__Group__0"); + builder.put(grammarAccess.getAmentPackageAccess().getGroup_4(), "rule__AmentPackage__Group_4__0"); + builder.put(grammarAccess.getAmentPackageAccess().getGroup_5(), "rule__AmentPackage__Group_5__0"); + builder.put(grammarAccess.getAmentPackageAccess().getGroup_6(), "rule__AmentPackage__Group_6__0"); + builder.put(grammarAccess.getAmentPackageAccess().getGroup_6_3(), "rule__AmentPackage__Group_6_3__0"); + builder.put(grammarAccess.getQualityOfServiceAccess().getGroup(), "rule__QualityOfService__Group__0"); + builder.put(grammarAccess.getQualityOfServiceAccess().getGroup_1_0(), "rule__QualityOfService__Group_1_0__0"); + builder.put(grammarAccess.getQualityOfServiceAccess().getGroup_1_1(), "rule__QualityOfService__Group_1_1__0"); + builder.put(grammarAccess.getQualityOfServiceAccess().getGroup_1_2(), "rule__QualityOfService__Group_1_2__0"); + builder.put(grammarAccess.getQualityOfServiceAccess().getGroup_1_3(), "rule__QualityOfService__Group_1_3__0"); + builder.put(grammarAccess.getQualityOfServiceAccess().getGroup_1_4(), "rule__QualityOfService__Group_1_4__0"); + builder.put(grammarAccess.getPublisherAccess().getGroup(), "rule__Publisher__Group__0"); + builder.put(grammarAccess.getPublisherAccess().getGroup_6(), "rule__Publisher__Group_6__0"); + builder.put(grammarAccess.getPublisherAccess().getGroup_7(), "rule__Publisher__Group_7__0"); + builder.put(grammarAccess.getSubscriberAccess().getGroup(), "rule__Subscriber__Group__0"); + builder.put(grammarAccess.getSubscriberAccess().getGroup_6(), "rule__Subscriber__Group_6__0"); + builder.put(grammarAccess.getSubscriberAccess().getGroup_7(), "rule__Subscriber__Group_7__0"); + builder.put(grammarAccess.getServiceServerAccess().getGroup(), "rule__ServiceServer__Group__0"); + builder.put(grammarAccess.getServiceServerAccess().getGroup_6(), "rule__ServiceServer__Group_6__0"); + builder.put(grammarAccess.getServiceServerAccess().getGroup_7(), "rule__ServiceServer__Group_7__0"); + builder.put(grammarAccess.getServiceClientAccess().getGroup(), "rule__ServiceClient__Group__0"); + builder.put(grammarAccess.getServiceClientAccess().getGroup_6(), "rule__ServiceClient__Group_6__0"); + builder.put(grammarAccess.getServiceClientAccess().getGroup_7(), "rule__ServiceClient__Group_7__0"); + builder.put(grammarAccess.getActionServerAccess().getGroup(), "rule__ActionServer__Group__0"); + builder.put(grammarAccess.getActionServerAccess().getGroup_6(), "rule__ActionServer__Group_6__0"); + builder.put(grammarAccess.getActionServerAccess().getGroup_7(), "rule__ActionServer__Group_7__0"); + builder.put(grammarAccess.getActionClientAccess().getGroup(), "rule__ActionClient__Group__0"); + builder.put(grammarAccess.getActionClientAccess().getGroup_6(), "rule__ActionClient__Group_6__0"); + builder.put(grammarAccess.getActionClientAccess().getGroup_7(), "rule__ActionClient__Group_7__0"); + builder.put(grammarAccess.getParameterAccess().getGroup(), "rule__Parameter__Group__0"); + builder.put(grammarAccess.getParameterAccess().getGroup_6(), "rule__Parameter__Group_6__0"); + builder.put(grammarAccess.getParameterAccess().getGroup_7(), "rule__Parameter__Group_7__0"); + builder.put(grammarAccess.getPackageSetAccess().getGroup(), "rule__PackageSet__Group__0"); + builder.put(grammarAccess.getPackage_ImplAccess().getGroup(), "rule__Package_Impl__Group__0"); + builder.put(grammarAccess.getPackage_ImplAccess().getGroup_4(), "rule__Package_Impl__Group_4__0"); + builder.put(grammarAccess.getPackage_ImplAccess().getGroup_5(), "rule__Package_Impl__Group_5__0"); + builder.put(grammarAccess.getPackage_ImplAccess().getGroup_6(), "rule__Package_Impl__Group_6__0"); + builder.put(grammarAccess.getPackage_ImplAccess().getGroup_6_3(), "rule__Package_Impl__Group_6_3__0"); + 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_0(), "rule__Node__Group_3_0__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_1(), "rule__Node__Group_3_1__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_2(), "rule__Node__Group_3_2__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_3(), "rule__Node__Group_3_3__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_4(), "rule__Node__Group_3_4__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_5(), "rule__Node__Group_3_5__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3_6(), "rule__Node__Group_3_6__0"); + builder.put(grammarAccess.getTopicSpecAccess().getGroup(), "rule__TopicSpec__Group__0"); + builder.put(grammarAccess.getTopicSpecAccess().getGroup_5(), "rule__TopicSpec__Group_5__0"); + builder.put(grammarAccess.getServiceSpecAccess().getGroup(), "rule__ServiceSpec__Group__0"); + builder.put(grammarAccess.getServiceSpecAccess().getGroup_5(), "rule__ServiceSpec__Group_5__0"); + builder.put(grammarAccess.getServiceSpecAccess().getGroup_7(), "rule__ServiceSpec__Group_7__0"); + builder.put(grammarAccess.getActionSpecAccess().getGroup(), "rule__ActionSpec__Group__0"); + builder.put(grammarAccess.getActionSpecAccess().getGroup_5(), "rule__ActionSpec__Group_5__0"); + builder.put(grammarAccess.getActionSpecAccess().getGroup_7(), "rule__ActionSpec__Group_7__0"); + builder.put(grammarAccess.getActionSpecAccess().getGroup_9(), "rule__ActionSpec__Group_9__0"); + builder.put(grammarAccess.getMessageDefinitionAccess().getGroup(), "rule__MessageDefinition__Group__0"); + builder.put(grammarAccess.getExternalDependencyAccess().getGroup(), "rule__ExternalDependency__Group__0"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getGroup(), "rule__GlobalNamespace__Group__0"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getGroup_2(), "rule__GlobalNamespace__Group_2__0"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2(), "rule__GlobalNamespace__Group_2_2__0"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getGroup(), "rule__RelativeNamespace_Impl__Group__0"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2(), "rule__RelativeNamespace_Impl__Group_2__0"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2(), "rule__RelativeNamespace_Impl__Group_2_2__0"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getGroup(), "rule__PrivateNamespace__Group__0"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getGroup_2(), "rule__PrivateNamespace__Group_2__0"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2(), "rule__PrivateNamespace__Group_2_2__0"); + builder.put(grammarAccess.getParameterListTypeAccess().getGroup(), "rule__ParameterListType__Group__0"); + builder.put(grammarAccess.getParameterListTypeAccess().getGroup_4(), "rule__ParameterListType__Group_4__0"); + builder.put(grammarAccess.getParameterStructTypeAccess().getGroup(), "rule__ParameterStructType__Group__0"); + builder.put(grammarAccess.getParameterStructTypeAccess().getGroup_4(), "rule__ParameterStructType__Group_4__0"); + builder.put(grammarAccess.getParameterIntegerTypeAccess().getGroup(), "rule__ParameterIntegerType__Group__0"); + builder.put(grammarAccess.getParameterIntegerTypeAccess().getGroup_2(), "rule__ParameterIntegerType__Group_2__0"); + builder.put(grammarAccess.getParameterStringTypeAccess().getGroup(), "rule__ParameterStringType__Group__0"); + builder.put(grammarAccess.getParameterStringTypeAccess().getGroup_2(), "rule__ParameterStringType__Group_2__0"); + builder.put(grammarAccess.getParameterDoubleTypeAccess().getGroup(), "rule__ParameterDoubleType__Group__0"); + builder.put(grammarAccess.getParameterDoubleTypeAccess().getGroup_2(), "rule__ParameterDoubleType__Group_2__0"); + builder.put(grammarAccess.getParameterDateTypeAccess().getGroup(), "rule__ParameterDateType__Group__0"); + builder.put(grammarAccess.getParameterDateTypeAccess().getGroup_2(), "rule__ParameterDateType__Group_2__0"); + builder.put(grammarAccess.getParameterBooleanTypeAccess().getGroup(), "rule__ParameterBooleanType__Group__0"); + builder.put(grammarAccess.getParameterBooleanTypeAccess().getGroup_2(), "rule__ParameterBooleanType__Group_2__0"); + builder.put(grammarAccess.getParameterBase64TypeAccess().getGroup(), "rule__ParameterBase64Type__Group__0"); + builder.put(grammarAccess.getParameterBase64TypeAccess().getGroup_2(), "rule__ParameterBase64Type__Group_2__0"); + builder.put(grammarAccess.getParameterAnyTypeAccess().getGroup(), "rule__ParameterAnyType__Group__0"); + builder.put(grammarAccess.getParameterAnyTypeAccess().getGroup_2(), "rule__ParameterAnyType__Group_2__0"); + builder.put(grammarAccess.getParameterArrayTypeAccess().getGroup(), "rule__ParameterArrayType__Group__0"); + builder.put(grammarAccess.getParameterArrayTypeAccess().getGroup_4(), "rule__ParameterArrayType__Group_4__0"); + builder.put(grammarAccess.getParameterListAccess().getGroup(), "rule__ParameterList__Group__0"); + builder.put(grammarAccess.getParameterListAccess().getGroup_3(), "rule__ParameterList__Group_3__0"); + builder.put(grammarAccess.getParameterAnyAccess().getGroup(), "rule__ParameterAny__Group__0"); + builder.put(grammarAccess.getParameterAnyAccess().getGroup_2(), "rule__ParameterAny__Group_2__0"); + builder.put(grammarAccess.getParameterStructAccess().getGroup(), "rule__ParameterStruct__Group__0"); + builder.put(grammarAccess.getParameterStructAccess().getGroup_1(), "rule__ParameterStruct__Group_1__0"); + builder.put(grammarAccess.getParameterStructAccess().getGroup_1_2(), "rule__ParameterStruct__Group_1_2__0"); + builder.put(grammarAccess.getParameterStructMemberAccess().getGroup(), "rule__ParameterStructMember__Group__0"); + builder.put(grammarAccess.getParameterStructTypeMemberAccess().getGroup(), "rule__ParameterStructTypeMember__Group__0"); + builder.put(grammarAccess.getMessagePartAccess().getGroup(), "rule__MessagePart__Group__0"); + builder.put(grammarAccess.getBoolAccess().getGroup(), "rule__Bool__Group__0"); + builder.put(grammarAccess.getInt8Access().getGroup(), "rule__Int8__Group__0"); + builder.put(grammarAccess.getUint8Access().getGroup(), "rule__Uint8__Group__0"); + builder.put(grammarAccess.getInt16Access().getGroup(), "rule__Int16__Group__0"); + builder.put(grammarAccess.getUint16Access().getGroup(), "rule__Uint16__Group__0"); + builder.put(grammarAccess.getInt32Access().getGroup(), "rule__Int32__Group__0"); + builder.put(grammarAccess.getUint32Access().getGroup(), "rule__Uint32__Group__0"); + builder.put(grammarAccess.getInt64Access().getGroup(), "rule__Int64__Group__0"); + builder.put(grammarAccess.getUint64Access().getGroup(), "rule__Uint64__Group__0"); + builder.put(grammarAccess.getFloat32Access().getGroup(), "rule__Float32__Group__0"); + builder.put(grammarAccess.getFloat64Access().getGroup(), "rule__Float64__Group__0"); + builder.put(grammarAccess.getString0Access().getGroup(), "rule__String0__Group__0"); + builder.put(grammarAccess.getByteAccess().getGroup(), "rule__Byte__Group__0"); + builder.put(grammarAccess.getTimeAccess().getGroup(), "rule__Time__Group__0"); + builder.put(grammarAccess.getDurationAccess().getGroup(), "rule__Duration__Group__0"); + builder.put(grammarAccess.getBoolArrayAccess().getGroup(), "rule__BoolArray__Group__0"); + builder.put(grammarAccess.getInt8ArrayAccess().getGroup(), "rule__Int8Array__Group__0"); + builder.put(grammarAccess.getUint8ArrayAccess().getGroup(), "rule__Uint8Array__Group__0"); + builder.put(grammarAccess.getInt16ArrayAccess().getGroup(), "rule__Int16Array__Group__0"); + builder.put(grammarAccess.getUint16ArrayAccess().getGroup(), "rule__Uint16Array__Group__0"); + builder.put(grammarAccess.getInt32ArrayAccess().getGroup(), "rule__Int32Array__Group__0"); + builder.put(grammarAccess.getUint32ArrayAccess().getGroup(), "rule__Uint32Array__Group__0"); + builder.put(grammarAccess.getInt64ArrayAccess().getGroup(), "rule__Int64Array__Group__0"); + builder.put(grammarAccess.getUint64ArrayAccess().getGroup(), "rule__Uint64Array__Group__0"); + builder.put(grammarAccess.getFloat32ArrayAccess().getGroup(), "rule__Float32Array__Group__0"); + builder.put(grammarAccess.getFloat64ArrayAccess().getGroup(), "rule__Float64Array__Group__0"); + builder.put(grammarAccess.getString0ArrayAccess().getGroup(), "rule__String0Array__Group__0"); + builder.put(grammarAccess.getByteArrayAccess().getGroup(), "rule__ByteArray__Group__0"); + builder.put(grammarAccess.getHeaderAccess().getGroup(), "rule__Header__Group__0"); + builder.put(grammarAccess.getArrayTopicSpecRefAccess().getGroup(), "rule__ArrayTopicSpecRef__Group__0"); + builder.put(grammarAccess.getAmentPackageAccess().getNameAssignment_1(), "rule__AmentPackage__NameAssignment_1"); + builder.put(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_4_1(), "rule__AmentPackage__FromGitRepoAssignment_4_1"); + builder.put(grammarAccess.getAmentPackageAccess().getArtifactAssignment_5_2(), "rule__AmentPackage__ArtifactAssignment_5_2"); + builder.put(grammarAccess.getAmentPackageAccess().getDependencyAssignment_6_2(), "rule__AmentPackage__DependencyAssignment_6_2"); + builder.put(grammarAccess.getAmentPackageAccess().getDependencyAssignment_6_3_1(), "rule__AmentPackage__DependencyAssignment_6_3_1"); + builder.put(grammarAccess.getQualityOfServiceAccess().getQoSProfileAssignment_1_0_1(), "rule__QualityOfService__QoSProfileAssignment_1_0_1"); + builder.put(grammarAccess.getQualityOfServiceAccess().getHistoryAssignment_1_1_1(), "rule__QualityOfService__HistoryAssignment_1_1_1"); + builder.put(grammarAccess.getQualityOfServiceAccess().getDepthAssignment_1_2_1(), "rule__QualityOfService__DepthAssignment_1_2_1"); + builder.put(grammarAccess.getQualityOfServiceAccess().getReliabilityAssignment_1_3_1(), "rule__QualityOfService__ReliabilityAssignment_1_3_1"); + builder.put(grammarAccess.getQualityOfServiceAccess().getDurabilityAssignment_1_4_1(), "rule__QualityOfService__DurabilityAssignment_1_4_1"); + builder.put(grammarAccess.getPublisherAccess().getNameAssignment_1(), "rule__Publisher__NameAssignment_1"); + builder.put(grammarAccess.getPublisherAccess().getMessageAssignment_5(), "rule__Publisher__MessageAssignment_5"); + builder.put(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1(), "rule__Publisher__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getPublisherAccess().getQosAssignment_7_2(), "rule__Publisher__QosAssignment_7_2"); + builder.put(grammarAccess.getSubscriberAccess().getNameAssignment_1(), "rule__Subscriber__NameAssignment_1"); + builder.put(grammarAccess.getSubscriberAccess().getMessageAssignment_5(), "rule__Subscriber__MessageAssignment_5"); + builder.put(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1(), "rule__Subscriber__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getSubscriberAccess().getQosAssignment_7_1(), "rule__Subscriber__QosAssignment_7_1"); + builder.put(grammarAccess.getServiceServerAccess().getNameAssignment_1(), "rule__ServiceServer__NameAssignment_1"); + builder.put(grammarAccess.getServiceServerAccess().getServiceAssignment_5(), "rule__ServiceServer__ServiceAssignment_5"); + builder.put(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1(), "rule__ServiceServer__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getServiceServerAccess().getQosAssignment_7_1(), "rule__ServiceServer__QosAssignment_7_1"); + builder.put(grammarAccess.getServiceClientAccess().getNameAssignment_1(), "rule__ServiceClient__NameAssignment_1"); + builder.put(grammarAccess.getServiceClientAccess().getServiceAssignment_5(), "rule__ServiceClient__ServiceAssignment_5"); + builder.put(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1(), "rule__ServiceClient__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getServiceClientAccess().getQosAssignment_7_1(), "rule__ServiceClient__QosAssignment_7_1"); + builder.put(grammarAccess.getActionServerAccess().getNameAssignment_1(), "rule__ActionServer__NameAssignment_1"); + builder.put(grammarAccess.getActionServerAccess().getActionAssignment_5(), "rule__ActionServer__ActionAssignment_5"); + builder.put(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1(), "rule__ActionServer__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getActionServerAccess().getQosAssignment_7_1(), "rule__ActionServer__QosAssignment_7_1"); + builder.put(grammarAccess.getActionClientAccess().getNameAssignment_1(), "rule__ActionClient__NameAssignment_1"); + builder.put(grammarAccess.getActionClientAccess().getActionAssignment_5(), "rule__ActionClient__ActionAssignment_5"); + builder.put(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1(), "rule__ActionClient__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getActionClientAccess().getQosAssignment_7_1(), "rule__ActionClient__QosAssignment_7_1"); + builder.put(grammarAccess.getParameterAccess().getNameAssignment_1(), "rule__Parameter__NameAssignment_1"); + builder.put(grammarAccess.getParameterAccess().getTypeAssignment_5(), "rule__Parameter__TypeAssignment_5"); + builder.put(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1(), "rule__Parameter__NamespaceAssignment_6_1"); + builder.put(grammarAccess.getParameterAccess().getQosAssignment_7_1(), "rule__Parameter__QosAssignment_7_1"); + builder.put(grammarAccess.getPackageSetAccess().getPackageAssignment_1(), "rule__PackageSet__PackageAssignment_1"); + builder.put(grammarAccess.getPackage_ImplAccess().getNameAssignment_1(), "rule__Package_Impl__NameAssignment_1"); + builder.put(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1(), "rule__Package_Impl__FromGitRepoAssignment_4_1"); + builder.put(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2(), "rule__Package_Impl__SpecAssignment_5_2"); + builder.put(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2(), "rule__Package_Impl__DependencyAssignment_6_2"); + builder.put(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1(), "rule__Package_Impl__DependencyAssignment_6_3_1"); + 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_0_2(), "rule__Node__PublisherAssignment_3_0_2"); + builder.put(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2(), "rule__Node__SubscriberAssignment_3_1_2"); + builder.put(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2(), "rule__Node__ServiceserverAssignment_3_2_2"); + builder.put(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2(), "rule__Node__ServiceclientAssignment_3_3_2"); + builder.put(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2(), "rule__Node__ActionserverAssignment_3_4_2"); + builder.put(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2(), "rule__Node__ActionclientAssignment_3_5_2"); + builder.put(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2(), "rule__Node__ParameterAssignment_3_6_2"); + builder.put(grammarAccess.getTopicSpecAccess().getNameAssignment_2(), "rule__TopicSpec__NameAssignment_2"); + builder.put(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1(), "rule__TopicSpec__MessageAssignment_5_1"); + builder.put(grammarAccess.getServiceSpecAccess().getNameAssignment_2(), "rule__ServiceSpec__NameAssignment_2"); + builder.put(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1(), "rule__ServiceSpec__RequestAssignment_5_1"); + builder.put(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1(), "rule__ServiceSpec__ResponseAssignment_7_1"); + builder.put(grammarAccess.getActionSpecAccess().getNameAssignment_2(), "rule__ActionSpec__NameAssignment_2"); + builder.put(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1(), "rule__ActionSpec__GoalAssignment_5_1"); + builder.put(grammarAccess.getActionSpecAccess().getResultAssignment_7_1(), "rule__ActionSpec__ResultAssignment_7_1"); + builder.put(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1(), "rule__ActionSpec__FeedbackAssignment_9_1"); + builder.put(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1(), "rule__MessageDefinition__MessagePartAssignment_1"); + builder.put(grammarAccess.getPackageDependencyAccess().getPackageAssignment(), "rule__PackageDependency__PackageAssignment"); + builder.put(grammarAccess.getExternalDependencyAccess().getNameAssignment_2(), "rule__ExternalDependency__NameAssignment_2"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1(), "rule__GlobalNamespace__PartsAssignment_2_1"); + builder.put(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1(), "rule__GlobalNamespace__PartsAssignment_2_2_1"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1(), "rule__RelativeNamespace_Impl__PartsAssignment_2_1"); + builder.put(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1(), "rule__RelativeNamespace_Impl__PartsAssignment_2_2_1"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1(), "rule__PrivateNamespace__PartsAssignment_2_1"); + builder.put(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1(), "rule__PrivateNamespace__PartsAssignment_2_2_1"); + builder.put(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3(), "rule__ParameterListType__SequenceAssignment_3"); + builder.put(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1(), "rule__ParameterListType__SequenceAssignment_4_1"); + builder.put(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3(), "rule__ParameterStructType__ParameterstructypetmemberAssignment_3"); + builder.put(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1(), "rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1"); + builder.put(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterIntegerType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterStringType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterDoubleType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterDateTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterDateType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterBooleanType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1(), "rule__ParameterBase64Type__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterAnyTypeAccess().getDefaultAssignment_2_1(), "rule__ParameterAnyType__DefaultAssignment_2_1"); + builder.put(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3(), "rule__ParameterArrayType__TypeAssignment_3"); + builder.put(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1(), "rule__ParameterArrayType__DefaultAssignment_4_1"); + builder.put(grammarAccess.getParameterListAccess().getValueAssignment_2(), "rule__ParameterList__ValueAssignment_2"); + builder.put(grammarAccess.getParameterListAccess().getValueAssignment_3_1(), "rule__ParameterList__ValueAssignment_3_1"); + builder.put(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1(), "rule__ParameterAny__ValueAssignment_2_1"); + builder.put(grammarAccess.getParameterStringAccess().getValueAssignment(), "rule__ParameterString__ValueAssignment"); + builder.put(grammarAccess.getParameterBase64Access().getValueAssignment(), "rule__ParameterBase64__ValueAssignment"); + builder.put(grammarAccess.getParameterIntegerAccess().getValueAssignment(), "rule__ParameterInteger__ValueAssignment"); + builder.put(grammarAccess.getParameterDoubleAccess().getValueAssignment(), "rule__ParameterDouble__ValueAssignment"); + builder.put(grammarAccess.getParameterBooleanAccess().getValueAssignment(), "rule__ParameterBoolean__ValueAssignment"); + builder.put(grammarAccess.getParameterStructAccess().getValueAssignment_1_1(), "rule__ParameterStruct__ValueAssignment_1_1"); + builder.put(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2(), "rule__ParameterStruct__ValueAssignment_1_2_2"); + builder.put(grammarAccess.getParameterDateAccess().getValueAssignment(), "rule__ParameterDate__ValueAssignment"); + builder.put(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1(), "rule__ParameterStructMember__NameAssignment_1"); + builder.put(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4(), "rule__ParameterStructMember__ValueAssignment_4"); + builder.put(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0(), "rule__ParameterStructTypeMember__NameAssignment_0"); + builder.put(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1(), "rule__ParameterStructTypeMember__TypeAssignment_1"); + builder.put(grammarAccess.getMessagePartAccess().getTypeAssignment_0(), "rule__MessagePart__TypeAssignment_0"); + builder.put(grammarAccess.getMessagePartAccess().getDataAssignment_1(), "rule__MessagePart__DataAssignment_1"); + builder.put(grammarAccess.getTopicSpecRefAccess().getTopicSpecAssignment(), "rule__TopicSpecRef__TopicSpecAssignment"); + builder.put(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0(), "rule__ArrayTopicSpecRef__TopicSpecAssignment_0"); + builder.put(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), "rule__QualityOfService__UnorderedGroup_1"); + } + } + + @Inject + private NameMappings nameMappings; + + @Inject + private Ros2GrammarAccess grammarAccess; + + @Override + protected InternalRos2Parser createParser() { + InternalRos2Parser result = new InternalRos2Parser(null); + result.setGrammarAccess(grammarAccess); + return result; + } + + @Override + protected TokenSource createLexer(CharStream stream) { + return new Ros2TokenSource(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 Ros2GrammarAccess getGrammarAccess() { + return this.grammarAccess; + } + + public void setGrammarAccess(Ros2GrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } + + public NameMappings getNameMappings() { + return nameMappings; + } + + public void setNameMappings(NameMappings nameMappings) { + this.nameMappings = nameMappings; + } +} diff --git a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRos.g b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/internal/InternalRos2Parser.g similarity index 75% rename from plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRos.g rename to plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/internal/InternalRos2Parser.g index 6ead1225b..ee37d703b 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext.ide/src-gen/de/fraunhofer/ipa/ros/ide/contentassist/antlr/internal/InternalRos.g +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/internal/InternalRos2Parser.g @@ -1,22 +1,17 @@ /* * generated by Xtext 2.25.0 */ -grammar InternalRos; +parser grammar InternalRos2Parser; options { + tokenVocab=InternalRos2Lexer; superClass=AbstractInternalContentAssistParser; } -@lexer::header { -package de.fraunhofer.ipa.ros.ide.contentassist.antlr.internal; - -// Hack: Use our own Lexer superclass by means of import. -// Currently there is no other way to specify the superclass for the lexer. -import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; -} - -@parser::header { -package de.fraunhofer.ipa.ros.ide.contentassist.antlr.internal; +@header { +package de.fraunhofer.ipa.ros2.ide.contentassist.antlr.internal; +import java.util.Map; +import java.util.HashMap; import java.io.InputStream; import org.eclipse.xtext.*; @@ -28,13 +23,119 @@ 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.ros.services.RosGrammarAccess; - -} -@parser::members { - private RosGrammarAccess grammarAccess; - - public void setGrammarAccess(RosGrammarAccess grammarAccess) { +import de.fraunhofer.ipa.ros2.services.Ros2GrammarAccess; + +} +@members { + private Ros2GrammarAccess grammarAccess; + private final Map tokenNameToValue = new HashMap(); + + { + tokenNameToValue.put("Comma", "','"); + tokenNameToValue.put("Colon", "':'"); + tokenNameToValue.put("LeftSquareBracket", "'['"); + tokenNameToValue.put("RightSquareBracket", "']'"); + tokenNameToValue.put("RightCurlyBracket", "'}'"); + tokenNameToValue.put("LeftSquareBracketRightSquareBracket", "'[]'"); + tokenNameToValue.put("Any", "'Any'"); + tokenNameToValue.put("Ns", "'ns:'"); + tokenNameToValue.put("Date", "'Date'"); + tokenNameToValue.put("List", "'List'"); + tokenNameToValue.put("Bool", "'bool'"); + tokenNameToValue.put("Byte", "'byte'"); + tokenNameToValue.put("Goal", "'goal'"); + tokenNameToValue.put("Int8", "'int8'"); + tokenNameToValue.put("Msg", "'msg:'"); + tokenNameToValue.put("Name", "'name'"); + tokenNameToValue.put("Node", "'node'"); + tokenNameToValue.put("Qos", "'qos:'"); + tokenNameToValue.put("Srv", "'srv:'"); + tokenNameToValue.put("Time", "'time'"); + tokenNameToValue.put("Type", "'type'"); + tokenNameToValue.put("Goal_1", "'goal:'"); + tokenNameToValue.put("Int16", "'int16'"); + tokenNameToValue.put("Int32", "'int32'"); + tokenNameToValue.put("Int64", "'int64'"); + tokenNameToValue.put("Node_1", "'node:'"); + tokenNameToValue.put("Type_1", "'type:'"); + tokenNameToValue.put("Uint8", "'uint8'"); + tokenNameToValue.put("Value", "'value'"); + tokenNameToValue.put("Array", "'Array:'"); + tokenNameToValue.put("Base64", "'Base64'"); + tokenNameToValue.put("Double", "'Double'"); + tokenNameToValue.put("Header", "'Header'"); + tokenNameToValue.put("String", "'String'"); + tokenNameToValue.put("Struct", "'Struct'"); + tokenNameToValue.put("Action", "'action'"); + tokenNameToValue.put("Bool_1", "'bool[]'"); + tokenNameToValue.put("Byte_1", "'byte[]'"); + tokenNameToValue.put("Depth", "'depth:'"); + tokenNameToValue.put("Int8_1", "'int8[]'"); + tokenNameToValue.put("Result", "'result'"); + tokenNameToValue.put("Specs", "'specs:'"); + tokenNameToValue.put("String_1", "'string'"); + tokenNameToValue.put("Uint16", "'uint16'"); + tokenNameToValue.put("Uint32", "'uint32'"); + tokenNameToValue.put("Uint64", "'uint64'"); + tokenNameToValue.put("Boolean", "'Boolean'"); + tokenNameToValue.put("Integer", "'Integer'"); + tokenNameToValue.put("Action_1", "'action:'"); + tokenNameToValue.put("Default", "'default'"); + tokenNameToValue.put("Float32", "'float32'"); + tokenNameToValue.put("Float64", "'float64'"); + tokenNameToValue.put("Int16_1", "'int16[]'"); + tokenNameToValue.put("Int32_1", "'int32[]'"); + tokenNameToValue.put("Int64_1", "'int64[]'"); + tokenNameToValue.put("Message", "'message'"); + tokenNameToValue.put("Result_1", "'result:'"); + tokenNameToValue.put("Service", "'service'"); + tokenNameToValue.put("Uint8_1", "'uint8[]'"); + tokenNameToValue.put("Duration", "'duration'"); + tokenNameToValue.put("Feedback", "'feedback'"); + tokenNameToValue.put("History", "'history:'"); + tokenNameToValue.put("Keep_all", "'keep_all'"); + tokenNameToValue.put("Message_1", "'message:'"); + tokenNameToValue.put("Profile", "'profile:'"); + tokenNameToValue.put("Reliable", "'reliable'"); + tokenNameToValue.put("Request", "'request:'"); + tokenNameToValue.put("String_2", "'string[]'"); + tokenNameToValue.put("Uint16_1", "'uint16[]'"); + tokenNameToValue.put("Uint32_1", "'uint32[]'"); + tokenNameToValue.put("Uint64_1", "'uint64[]'"); + tokenNameToValue.put("Volatile", "'volatile'"); + tokenNameToValue.put("GraphName", "'GraphName'"); + tokenNameToValue.put("Feedback_1", "'feedback:'"); + tokenNameToValue.put("Float32_1", "'float32[]'"); + tokenNameToValue.put("Float64_1", "'float64[]'"); + tokenNameToValue.put("Keep_last", "'keep_last'"); + tokenNameToValue.put("Response", "'response:'"); + tokenNameToValue.put("Artifacts", "'artifacts:'"); + tokenNameToValue.put("Sensor_qos", "'sensor_qos'"); + tokenNameToValue.put("Best_effort", "'best_effort'"); + tokenNameToValue.put("Default_qos", "'default_qos'"); + tokenNameToValue.put("Durability", "'durability:'"); + tokenNameToValue.put("Parameters", "'parameters:'"); + tokenNameToValue.put("Publishers", "'publishers:'"); + tokenNameToValue.put("ParameterAny", "'ParameterAny'"); + tokenNameToValue.put("FromGitRepo", "'fromGitRepo:'"); + tokenNameToValue.put("Reliability", "'reliability:'"); + tokenNameToValue.put("Services_qos", "'services_qos'"); + tokenNameToValue.put("Subscribers", "'subscribers:'"); + tokenNameToValue.put("Actionclient", "'actionclient:'"); + tokenNameToValue.put("Actionserver", "'actionserver:'"); + tokenNameToValue.put("Dependencies", "'dependencies:'"); + tokenNameToValue.put("Parameter_qos", "'parameter_qos'"); + tokenNameToValue.put("Serviceclient", "'serviceclient:'"); + tokenNameToValue.put("Serviceserver", "'serviceserver:'"); + tokenNameToValue.put("GlobalNamespace", "'GlobalNamespace'"); + tokenNameToValue.put("Transient_local", "'transient_local'"); + tokenNameToValue.put("PrivateNamespace", "'PrivateNamespace'"); + tokenNameToValue.put("RelativeNamespace", "'RelativeNamespace'"); + tokenNameToValue.put("ExternalDependency", "'ExternalDependency'"); + tokenNameToValue.put("ParameterStructMember", "'ParameterStructMember'"); + } + + public void setGrammarAccess(Ros2GrammarAccess grammarAccess) { this.grammarAccess = grammarAccess; } @@ -45,33 +146,11 @@ import de.fraunhofer.ipa.ros.services.RosGrammarAccess; @Override protected String getValueForTokenName(String tokenName) { - return tokenName; - } -} - -// Entry rule entryRulePackageSet -entryRulePackageSet -: -{ before(grammarAccess.getPackageSetRule()); } - rulePackageSet -{ after(grammarAccess.getPackageSetRule()); } - EOF -; - -// Rule PackageSet -rulePackageSet - @init { - int stackSize = keepStackSize(); + String result = tokenNameToValue.get(tokenName); + if (result == null) + result = tokenName; + return result; } - : - ( - { before(grammarAccess.getPackageSetAccess().getGroup()); } - (rule__PackageSet__Group__0) - { after(grammarAccess.getPackageSetAccess().getGroup()); } - ) -; -finally { - restoreStackSize(stackSize); } // Entry rule entryRulePackage @@ -90,334 +169,334 @@ rulePackage } : ( - { before(grammarAccess.getPackageAccess().getAlternatives()); } - (rule__Package__Alternatives) - { after(grammarAccess.getPackageAccess().getAlternatives()); } + { before(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall()); } + ruleAmentPackage + { after(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleSpecBase -entryRuleSpecBase +// Entry rule entryRuleAmentPackage +entryRuleAmentPackage : -{ before(grammarAccess.getSpecBaseRule()); } - ruleSpecBase -{ after(grammarAccess.getSpecBaseRule()); } +{ before(grammarAccess.getAmentPackageRule()); } + ruleAmentPackage +{ after(grammarAccess.getAmentPackageRule()); } EOF ; -// Rule SpecBase -ruleSpecBase +// Rule AmentPackage +ruleAmentPackage @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSpecBaseAccess().getAlternatives()); } - (rule__SpecBase__Alternatives) - { after(grammarAccess.getSpecBaseAccess().getAlternatives()); } + { before(grammarAccess.getAmentPackageAccess().getGroup()); } + (rule__AmentPackage__Group__0) + { after(grammarAccess.getAmentPackageAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleDependency -entryRuleDependency +// Entry rule entryRuleQualityOfService +entryRuleQualityOfService : -{ before(grammarAccess.getDependencyRule()); } - ruleDependency -{ after(grammarAccess.getDependencyRule()); } +{ before(grammarAccess.getQualityOfServiceRule()); } + ruleQualityOfService +{ after(grammarAccess.getQualityOfServiceRule()); } EOF ; -// Rule Dependency -ruleDependency +// Rule QualityOfService +ruleQualityOfService @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getDependencyAccess().getAlternatives()); } - (rule__Dependency__Alternatives) - { after(grammarAccess.getDependencyAccess().getAlternatives()); } + { before(grammarAccess.getQualityOfServiceAccess().getGroup()); } + (rule__QualityOfService__Group__0) + { after(grammarAccess.getQualityOfServiceAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleNamespace -entryRuleNamespace +// Entry rule entryRulePublisher +entryRulePublisher : -{ before(grammarAccess.getNamespaceRule()); } - ruleNamespace -{ after(grammarAccess.getNamespaceRule()); } +{ before(grammarAccess.getPublisherRule()); } + rulePublisher +{ after(grammarAccess.getPublisherRule()); } EOF ; -// Rule Namespace -ruleNamespace +// Rule Publisher +rulePublisher @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamespaceAccess().getAlternatives()); } - (rule__Namespace__Alternatives) - { after(grammarAccess.getNamespaceAccess().getAlternatives()); } + { before(grammarAccess.getPublisherAccess().getGroup()); } + (rule__Publisher__Group__0) + { after(grammarAccess.getPublisherAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRulePackage_Impl -entryRulePackage_Impl +// Entry rule entryRuleSubscriber +entryRuleSubscriber : -{ before(grammarAccess.getPackage_ImplRule()); } - rulePackage_Impl -{ after(grammarAccess.getPackage_ImplRule()); } +{ before(grammarAccess.getSubscriberRule()); } + ruleSubscriber +{ after(grammarAccess.getSubscriberRule()); } EOF ; -// Rule Package_Impl -rulePackage_Impl +// Rule Subscriber +ruleSubscriber @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPackage_ImplAccess().getGroup()); } - (rule__Package_Impl__Group__0) - { after(grammarAccess.getPackage_ImplAccess().getGroup()); } + { before(grammarAccess.getSubscriberAccess().getGroup()); } + (rule__Subscriber__Group__0) + { after(grammarAccess.getSubscriberAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleEString -entryRuleEString +// Entry rule entryRuleServiceServer +entryRuleServiceServer : -{ before(grammarAccess.getEStringRule()); } - ruleEString -{ after(grammarAccess.getEStringRule()); } +{ before(grammarAccess.getServiceServerRule()); } + ruleServiceServer +{ after(grammarAccess.getServiceServerRule()); } EOF ; -// Rule EString -ruleEString +// Rule ServiceServer +ruleServiceServer @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getEStringAccess().getAlternatives()); } - (rule__EString__Alternatives) - { after(grammarAccess.getEStringAccess().getAlternatives()); } + { before(grammarAccess.getServiceServerAccess().getGroup()); } + (rule__ServiceServer__Group__0) + { after(grammarAccess.getServiceServerAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleRosNames -entryRuleRosNames +// Entry rule entryRuleServiceClient +entryRuleServiceClient : -{ before(grammarAccess.getRosNamesRule()); } - ruleRosNames -{ after(grammarAccess.getRosNamesRule()); } +{ before(grammarAccess.getServiceClientRule()); } + ruleServiceClient +{ after(grammarAccess.getServiceClientRule()); } EOF ; -// Rule RosNames -ruleRosNames +// Rule ServiceClient +ruleServiceClient @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRosNamesAccess().getAlternatives()); } - (rule__RosNames__Alternatives) - { after(grammarAccess.getRosNamesAccess().getAlternatives()); } + { before(grammarAccess.getServiceClientAccess().getGroup()); } + (rule__ServiceClient__Group__0) + { after(grammarAccess.getServiceClientAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleArtifact -entryRuleArtifact +// Entry rule entryRuleActionServer +entryRuleActionServer : -{ before(grammarAccess.getArtifactRule()); } - ruleArtifact -{ after(grammarAccess.getArtifactRule()); } +{ before(grammarAccess.getActionServerRule()); } + ruleActionServer +{ after(grammarAccess.getActionServerRule()); } EOF ; -// Rule Artifact -ruleArtifact +// Rule ActionServer +ruleActionServer @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getArtifactAccess().getGroup()); } - (rule__Artifact__Group__0) - { after(grammarAccess.getArtifactAccess().getGroup()); } + { before(grammarAccess.getActionServerAccess().getGroup()); } + (rule__ActionServer__Group__0) + { after(grammarAccess.getActionServerAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleCatkinPackage -entryRuleCatkinPackage +// Entry rule entryRuleActionClient +entryRuleActionClient : -{ before(grammarAccess.getCatkinPackageRule()); } - ruleCatkinPackage -{ after(grammarAccess.getCatkinPackageRule()); } +{ before(grammarAccess.getActionClientRule()); } + ruleActionClient +{ after(grammarAccess.getActionClientRule()); } EOF ; -// Rule CatkinPackage -ruleCatkinPackage +// Rule ActionClient +ruleActionClient @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getGroup()); } - (rule__CatkinPackage__Group__0) - { after(grammarAccess.getCatkinPackageAccess().getGroup()); } + { before(grammarAccess.getActionClientAccess().getGroup()); } + (rule__ActionClient__Group__0) + { after(grammarAccess.getActionClientAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleAmentPackage -entryRuleAmentPackage +// Entry rule entryRuleParameter +entryRuleParameter : -{ before(grammarAccess.getAmentPackageRule()); } - ruleAmentPackage -{ after(grammarAccess.getAmentPackageRule()); } +{ before(grammarAccess.getParameterRule()); } + ruleParameter +{ after(grammarAccess.getParameterRule()); } EOF ; -// Rule AmentPackage -ruleAmentPackage +// Rule Parameter +ruleParameter @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getGroup()); } - (rule__AmentPackage__Group__0) - { after(grammarAccess.getAmentPackageAccess().getGroup()); } + { before(grammarAccess.getParameterAccess().getGroup()); } + (rule__Parameter__Group__0) + { after(grammarAccess.getParameterAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleServiceSpec -entryRuleServiceSpec +// Entry rule entryRuleEString +entryRuleEString : -{ before(grammarAccess.getServiceSpecRule()); } - ruleServiceSpec -{ after(grammarAccess.getServiceSpecRule()); } +{ before(grammarAccess.getEStringRule()); } + ruleEString +{ after(grammarAccess.getEStringRule()); } EOF ; -// Rule ServiceSpec -ruleServiceSpec +// Rule EString +ruleEString @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getGroup()); } - (rule__ServiceSpec__Group__0) - { after(grammarAccess.getServiceSpecAccess().getGroup()); } + { before(grammarAccess.getEStringAccess().getAlternatives()); } + (rule__EString__Alternatives) + { after(grammarAccess.getEStringAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleTopicSpec -entryRuleTopicSpec +// Entry rule entryRuleRosNames +entryRuleRosNames : -{ before(grammarAccess.getTopicSpecRule()); } - ruleTopicSpec -{ after(grammarAccess.getTopicSpecRule()); } +{ before(grammarAccess.getRosNamesRule()); } + ruleRosNames +{ after(grammarAccess.getRosNamesRule()); } EOF ; -// Rule TopicSpec -ruleTopicSpec +// Rule RosNames +ruleRosNames @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTopicSpecAccess().getGroup()); } - (rule__TopicSpec__Group__0) - { after(grammarAccess.getTopicSpecAccess().getGroup()); } + { before(grammarAccess.getRosNamesAccess().getAlternatives()); } + (rule__RosNames__Alternatives) + { after(grammarAccess.getRosNamesAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleActionSpec -entryRuleActionSpec +// Entry rule entryRulePackage_Impl +entryRulePackage_Impl : -{ before(grammarAccess.getActionSpecRule()); } - ruleActionSpec -{ after(grammarAccess.getActionSpecRule()); } +{ before(grammarAccess.getPackage_ImplRule()); } + rulePackage_Impl +{ after(grammarAccess.getPackage_ImplRule()); } EOF ; -// Rule ActionSpec -ruleActionSpec +// Rule Package_Impl +rulePackage_Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getGroup()); } - (rule__ActionSpec__Group__0) - { after(grammarAccess.getActionSpecAccess().getGroup()); } + { before(grammarAccess.getPackage_ImplAccess().getGroup()); } + (rule__Package_Impl__Group__0) + { after(grammarAccess.getPackage_ImplAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleMessageDefinition -entryRuleMessageDefinition +// Entry rule entryRuleArtifact +entryRuleArtifact : -{ before(grammarAccess.getMessageDefinitionRule()); } - ruleMessageDefinition -{ after(grammarAccess.getMessageDefinitionRule()); } +{ before(grammarAccess.getArtifactRule()); } + ruleArtifact +{ after(grammarAccess.getArtifactRule()); } EOF ; -// Rule MessageDefinition -ruleMessageDefinition +// Rule Artifact +ruleArtifact @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMessageDefinitionAccess().getGroup()); } - (rule__MessageDefinition__Group__0) - { after(grammarAccess.getMessageDefinitionAccess().getGroup()); } + { before(grammarAccess.getArtifactAccess().getGroup()); } + (rule__Artifact__Group__0) + { after(grammarAccess.getArtifactAccess().getGroup()); } ) ; finally { @@ -449,175 +528,150 @@ finally { restoreStackSize(stackSize); } -// Entry rule entryRuleServiceServer -entryRuleServiceServer -: -{ before(grammarAccess.getServiceServerRule()); } - ruleServiceServer -{ after(grammarAccess.getServiceServerRule()); } - EOF -; - -// Rule ServiceServer -ruleServiceServer - @init { - int stackSize = keepStackSize(); - } - : - ( - { before(grammarAccess.getServiceServerAccess().getGroup()); } - (rule__ServiceServer__Group__0) - { after(grammarAccess.getServiceServerAccess().getGroup()); } - ) -; -finally { - restoreStackSize(stackSize); -} - -// Entry rule entryRulePublisher -entryRulePublisher +// Entry rule entryRuleSpecBase +entryRuleSpecBase : -{ before(grammarAccess.getPublisherRule()); } - rulePublisher -{ after(grammarAccess.getPublisherRule()); } +{ before(grammarAccess.getSpecBaseRule()); } + ruleSpecBase +{ after(grammarAccess.getSpecBaseRule()); } EOF ; -// Rule Publisher -rulePublisher +// Rule SpecBase +ruleSpecBase @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getGroup()); } - (rule__Publisher__Group__0) - { after(grammarAccess.getPublisherAccess().getGroup()); } + { before(grammarAccess.getSpecBaseAccess().getAlternatives()); } + (rule__SpecBase__Alternatives) + { after(grammarAccess.getSpecBaseAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleSubscriber -entryRuleSubscriber +// Entry rule entryRuleTopicSpec +entryRuleTopicSpec : -{ before(grammarAccess.getSubscriberRule()); } - ruleSubscriber -{ after(grammarAccess.getSubscriberRule()); } +{ before(grammarAccess.getTopicSpecRule()); } + ruleTopicSpec +{ after(grammarAccess.getTopicSpecRule()); } EOF ; -// Rule Subscriber -ruleSubscriber +// Rule TopicSpec +ruleTopicSpec @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getGroup()); } - (rule__Subscriber__Group__0) - { after(grammarAccess.getSubscriberAccess().getGroup()); } + { before(grammarAccess.getTopicSpecAccess().getGroup()); } + (rule__TopicSpec__Group__0) + { after(grammarAccess.getTopicSpecAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleServiceClient -entryRuleServiceClient +// Entry rule entryRuleServiceSpec +entryRuleServiceSpec : -{ before(grammarAccess.getServiceClientRule()); } - ruleServiceClient -{ after(grammarAccess.getServiceClientRule()); } +{ before(grammarAccess.getServiceSpecRule()); } + ruleServiceSpec +{ after(grammarAccess.getServiceSpecRule()); } EOF ; -// Rule ServiceClient -ruleServiceClient +// Rule ServiceSpec +ruleServiceSpec @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getGroup()); } - (rule__ServiceClient__Group__0) - { after(grammarAccess.getServiceClientAccess().getGroup()); } + { before(grammarAccess.getServiceSpecAccess().getGroup()); } + (rule__ServiceSpec__Group__0) + { after(grammarAccess.getServiceSpecAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleActionServer -entryRuleActionServer +// Entry rule entryRuleActionSpec +entryRuleActionSpec : -{ before(grammarAccess.getActionServerRule()); } - ruleActionServer -{ after(grammarAccess.getActionServerRule()); } +{ before(grammarAccess.getActionSpecRule()); } + ruleActionSpec +{ after(grammarAccess.getActionSpecRule()); } EOF ; -// Rule ActionServer -ruleActionServer +// Rule ActionSpec +ruleActionSpec @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getGroup()); } - (rule__ActionServer__Group__0) - { after(grammarAccess.getActionServerAccess().getGroup()); } + { before(grammarAccess.getActionSpecAccess().getGroup()); } + (rule__ActionSpec__Group__0) + { after(grammarAccess.getActionSpecAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleActionClient -entryRuleActionClient +// Entry rule entryRuleMessageDefinition +entryRuleMessageDefinition : -{ before(grammarAccess.getActionClientRule()); } - ruleActionClient -{ after(grammarAccess.getActionClientRule()); } +{ before(grammarAccess.getMessageDefinitionRule()); } + ruleMessageDefinition +{ after(grammarAccess.getMessageDefinitionRule()); } EOF ; -// Rule ActionClient -ruleActionClient +// Rule MessageDefinition +ruleMessageDefinition @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getGroup()); } - (rule__ActionClient__Group__0) - { after(grammarAccess.getActionClientAccess().getGroup()); } + { before(grammarAccess.getMessageDefinitionAccess().getGroup()); } + (rule__MessageDefinition__Group__0) + { after(grammarAccess.getMessageDefinitionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleGraphName -entryRuleGraphName +// Entry rule entryRuleDependency +entryRuleDependency : -{ before(grammarAccess.getGraphNameRule()); } - ruleGraphName -{ after(grammarAccess.getGraphNameRule()); } +{ before(grammarAccess.getDependencyRule()); } + ruleDependency +{ after(grammarAccess.getDependencyRule()); } EOF ; -// Rule GraphName -ruleGraphName +// Rule Dependency +ruleDependency @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); } - 'GraphName' - { after(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); } + { before(grammarAccess.getDependencyAccess().getAlternatives()); } + (rule__Dependency__Alternatives) + { after(grammarAccess.getDependencyAccess().getAlternatives()); } ) ; finally { @@ -674,6 +728,56 @@ finally { restoreStackSize(stackSize); } +// Entry rule entryRuleNamespace +entryRuleNamespace +: +{ before(grammarAccess.getNamespaceRule()); } + ruleNamespace +{ after(grammarAccess.getNamespaceRule()); } + EOF +; + +// Rule Namespace +ruleNamespace + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getNamespaceAccess().getAlternatives()); } + (rule__Namespace__Alternatives) + { after(grammarAccess.getNamespaceAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleGraphName +entryRuleGraphName +: +{ before(grammarAccess.getGraphNameRule()); } + ruleGraphName +{ after(grammarAccess.getGraphNameRule()); } + EOF +; + +// Rule GraphName +ruleGraphName + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); } + GraphName + { after(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); } + ) +; +finally { + restoreStackSize(stackSize); +} + // Entry rule entryRuleGlobalNamespace entryRuleGlobalNamespace : @@ -749,31 +853,6 @@ 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 entryRuleParameterType entryRuleParameterType : @@ -2274,102 +2353,96 @@ finally { restoreStackSize(stackSize); } -rule__Package__Alternatives +rule__QualityOfService__QoSProfileAlternatives_1_0_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPackageAccess().getPackage_ImplParserRuleCall_0()); } - rulePackage_Impl - { after(grammarAccess.getPackageAccess().getPackage_ImplParserRuleCall_0()); } + { before(grammarAccess.getQualityOfServiceAccess().getQoSProfileDefault_qosKeyword_1_0_1_0_0()); } + Default_qos + { after(grammarAccess.getQualityOfServiceAccess().getQoSProfileDefault_qosKeyword_1_0_1_0_0()); } ) | ( - { before(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall_1()); } - ruleCatkinPackage - { after(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall_1()); } + { before(grammarAccess.getQualityOfServiceAccess().getQoSProfileServices_qosKeyword_1_0_1_0_1()); } + Services_qos + { after(grammarAccess.getQualityOfServiceAccess().getQoSProfileServices_qosKeyword_1_0_1_0_1()); } ) | ( - { before(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall_2()); } - ruleAmentPackage - { after(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall_2()); } + { before(grammarAccess.getQualityOfServiceAccess().getQoSProfileSensor_qosKeyword_1_0_1_0_2()); } + Sensor_qos + { after(grammarAccess.getQualityOfServiceAccess().getQoSProfileSensor_qosKeyword_1_0_1_0_2()); } + ) + | + ( + { before(grammarAccess.getQualityOfServiceAccess().getQoSProfileParameter_qosKeyword_1_0_1_0_3()); } + Parameter_qos + { after(grammarAccess.getQualityOfServiceAccess().getQoSProfileParameter_qosKeyword_1_0_1_0_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__SpecBase__Alternatives +rule__QualityOfService__HistoryAlternatives_1_1_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_0()); } - ruleServiceSpec - { after(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_1()); } - ruleTopicSpec - { after(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_1()); } + { before(grammarAccess.getQualityOfServiceAccess().getHistoryKeep_lastKeyword_1_1_1_0_0()); } + Keep_last + { after(grammarAccess.getQualityOfServiceAccess().getHistoryKeep_lastKeyword_1_1_1_0_0()); } ) | ( - { before(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); } - ruleActionSpec - { after(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); } + { before(grammarAccess.getQualityOfServiceAccess().getHistoryKeep_allKeyword_1_1_1_0_1()); } + Keep_all + { after(grammarAccess.getQualityOfServiceAccess().getHistoryKeep_allKeyword_1_1_1_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Dependency__Alternatives +rule__QualityOfService__ReliabilityAlternatives_1_3_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); } - rulePackageDependency - { after(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); } + { before(grammarAccess.getQualityOfServiceAccess().getReliabilityBest_effortKeyword_1_3_1_0_0()); } + Best_effort + { after(grammarAccess.getQualityOfServiceAccess().getReliabilityBest_effortKeyword_1_3_1_0_0()); } ) | ( - { before(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); } - ruleExternalDependency - { after(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); } + { before(grammarAccess.getQualityOfServiceAccess().getReliabilityReliableKeyword_1_3_1_0_1()); } + Reliable + { after(grammarAccess.getQualityOfServiceAccess().getReliabilityReliableKeyword_1_3_1_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Namespace__Alternatives +rule__QualityOfService__DurabilityAlternatives_1_4_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); } - ruleGlobalNamespace - { after(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); } + { before(grammarAccess.getQualityOfServiceAccess().getDurabilityTransient_localKeyword_1_4_1_0_0()); } + Transient_local + { after(grammarAccess.getQualityOfServiceAccess().getDurabilityTransient_localKeyword_1_4_1_0_0()); } ) | ( - { before(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); } - ruleRelativeNamespace_Impl - { after(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); } - ) - | - ( - { before(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); } - rulePrivateNamespace - { after(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); } + { before(grammarAccess.getQualityOfServiceAccess().getDurabilityVolatileKeyword_1_4_1_0_1()); } + Volatile + { after(grammarAccess.getQualityOfServiceAccess().getDurabilityVolatileKeyword_1_4_1_0_1()); } ) ; finally { @@ -2416,7 +2489,7 @@ rule__RosNames__Alternatives | ( { before(grammarAccess.getRosNamesAccess().getNodeKeyword_2()); } - 'node' + Node { after(grammarAccess.getRosNamesAccess().getNodeKeyword_2()); } ) ; @@ -2424,6 +2497,84 @@ finally { restoreStackSize(stackSize); } +rule__Node__Alternatives_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getGroup_3_0()); } + (rule__Node__Group_3_0__0) + { after(grammarAccess.getNodeAccess().getGroup_3_0()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_1()); } + (rule__Node__Group_3_1__0) + { after(grammarAccess.getNodeAccess().getGroup_3_1()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_2()); } + (rule__Node__Group_3_2__0) + { after(grammarAccess.getNodeAccess().getGroup_3_2()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_3()); } + (rule__Node__Group_3_3__0) + { after(grammarAccess.getNodeAccess().getGroup_3_3()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_4()); } + (rule__Node__Group_3_4__0) + { after(grammarAccess.getNodeAccess().getGroup_3_4()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_5()); } + (rule__Node__Group_3_5__0) + { after(grammarAccess.getNodeAccess().getGroup_3_5()); } + ) + | + ( + { before(grammarAccess.getNodeAccess().getGroup_3_6()); } + (rule__Node__Group_3_6__0) + { after(grammarAccess.getNodeAccess().getGroup_3_6()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__SpecBase__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); } + ruleTopicSpec + { after(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); } + ruleServiceSpec + { after(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); } + ruleActionSpec + { after(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + rule__TopicSpec__NameAlternatives_2_0 @init { int stackSize = keepStackSize(); @@ -2437,13 +2588,13 @@ rule__TopicSpec__NameAlternatives_2_0 | ( { before(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); } - 'Header' + Header { after(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); } ) | ( { before(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); } - 'String' + String { after(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); } ) ; @@ -2451,6 +2602,54 @@ 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__Namespace__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); } + ruleGlobalNamespace + { after(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); } + ruleRelativeNamespace_Impl + { after(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); } + rulePrivateNamespace + { after(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + rule__ParameterType__Alternatives @init { int stackSize = keepStackSize(); @@ -2711,1359 +2910,360 @@ rule__AbstractType__Alternatives { after(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); } ) | - ( - { before(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); } - ruleuint16Array - { after(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); } - ) - | - ( - { before(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); } - ruleint32Array - { after(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); } - ) - | - ( - { before(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); } - ruleuint32Array - { after(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); } - ) - | - ( - { before(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); } - ruleint64Array - { after(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); } - ) - | - ( - { before(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); } - ruleuint64Array - { after(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); } - ) - | - ( - { before(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); } - rulefloat32Array - { after(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); } - ) - | - ( - { before(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); } - rulefloat64Array - { after(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); } - ) - | - ( - { before(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); } - rulestring0Array - { after(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); } - ) - | - ( - { before(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); } - rulebyteArray - { after(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); } - ) - | - ( - { before(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); } - ruleTopicSpecRef - { after(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); } - ) - | - ( - { before(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); } - ruleArrayTopicSpecRef - { after(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); } - ) -; -finally { - restoreStackSize(stackSize); -} - -rule__KEYWORD__Alternatives - @init { - int stackSize = keepStackSize(); - } -: - ( - { before(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); } - 'goal' - { after(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); } - ) - | - ( - { before(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); } - 'message' - { after(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); } - ) - | - ( - { before(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); } - 'result' - { after(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); } - ) - | - ( - { before(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); } - 'feedback' - { after(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); } - ) - | - ( - { before(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); } - 'name' - { after(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); } - ) - | - ( - { before(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); } - 'value' - { after(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); } - ) - | - ( - { before(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); } - 'service' - { after(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); } - ) - | - ( - { before(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); } - 'type' - { after(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); } - ) - | - ( - { before(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); } - 'action' - { after(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); } - ) - | - ( - { before(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); } - 'duration' - { after(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); } - ) - | - ( - { before(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); } - 'time' - { after(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); } - ) -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__PackageSet__Group__0__Impl - rule__PackageSet__Group__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackageSetAccess().getPackageSetAction_0()); } - () - { after(grammarAccess.getPackageSetAccess().getPackageSetAction_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group__1 - @init { - int stackSize = keepStackSize(); - } -: - rule__PackageSet__Group__1__Impl - rule__PackageSet__Group__2 -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group__1__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackageSetAccess().getPackageSetKeyword_1()); } - 'PackageSet' - { after(grammarAccess.getPackageSetAccess().getPackageSetKeyword_1()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group__2 - @init { - int stackSize = keepStackSize(); - } -: - rule__PackageSet__Group__2__Impl - rule__PackageSet__Group__3 -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group__2__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackageSetAccess().getLeftCurlyBracketKeyword_2()); } - '{' - { after(grammarAccess.getPackageSetAccess().getLeftCurlyBracketKeyword_2()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group__3 - @init { - int stackSize = keepStackSize(); - } -: - rule__PackageSet__Group__3__Impl - rule__PackageSet__Group__4 -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group__3__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackageSetAccess().getGroup_3()); } - (rule__PackageSet__Group_3__0)? - { after(grammarAccess.getPackageSetAccess().getGroup_3()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group__4 - @init { - int stackSize = keepStackSize(); - } -: - rule__PackageSet__Group__4__Impl -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group__4__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackageSetAccess().getRightCurlyBracketKeyword_4()); } - '}' - { after(grammarAccess.getPackageSetAccess().getRightCurlyBracketKeyword_4()); } -) -; -finally { - restoreStackSize(stackSize); -} - - -rule__PackageSet__Group_3__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__PackageSet__Group_3__0__Impl - rule__PackageSet__Group_3__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group_3__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackageSetAccess().getPackageAssignment_3_0()); } - (rule__PackageSet__PackageAssignment_3_0) - { after(grammarAccess.getPackageSetAccess().getPackageAssignment_3_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group_3__1 - @init { - int stackSize = keepStackSize(); - } -: - rule__PackageSet__Group_3__1__Impl -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group_3__1__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackageSetAccess().getGroup_3_1()); } - (rule__PackageSet__Group_3_1__0)* - { after(grammarAccess.getPackageSetAccess().getGroup_3_1()); } -) -; -finally { - restoreStackSize(stackSize); -} - - -rule__PackageSet__Group_3_1__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__PackageSet__Group_3_1__0__Impl - rule__PackageSet__Group_3_1__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group_3_1__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackageSetAccess().getCommaKeyword_3_1_0()); } - ',' - { after(grammarAccess.getPackageSetAccess().getCommaKeyword_3_1_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group_3_1__1 - @init { - int stackSize = keepStackSize(); - } -: - rule__PackageSet__Group_3_1__1__Impl -; -finally { - restoreStackSize(stackSize); -} - -rule__PackageSet__Group_3_1__1__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackageSetAccess().getPackageAssignment_3_1_1()); } - (rule__PackageSet__PackageAssignment_3_1_1) - { after(grammarAccess.getPackageSetAccess().getPackageAssignment_3_1_1()); } -) -; -finally { - restoreStackSize(stackSize); -} - - -rule__Package_Impl__Group__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group__0__Impl - rule__Package_Impl__Group__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); } - () - { after(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__1 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group__1__Impl - rule__Package_Impl__Group__2 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__1__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getPackageKeyword_1()); } - 'Package' - { after(grammarAccess.getPackage_ImplAccess().getPackageKeyword_1()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__2 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group__2__Impl - rule__Package_Impl__Group__3 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__2__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getNameAssignment_2()); } - (rule__Package_Impl__NameAssignment_2) - { after(grammarAccess.getPackage_ImplAccess().getNameAssignment_2()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__3 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group__3__Impl - rule__Package_Impl__Group__4 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__3__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_3()); } - '{' - { after(grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_3()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__4 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group__4__Impl - rule__Package_Impl__Group__5 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__4__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getGroup_4()); } - (rule__Package_Impl__Group_4__0)? - { after(grammarAccess.getPackage_ImplAccess().getGroup_4()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__5 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group__5__Impl - rule__Package_Impl__Group__6 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__5__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getGroup_5()); } - (rule__Package_Impl__Group_5__0)? - { after(grammarAccess.getPackage_ImplAccess().getGroup_5()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__6 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group__6__Impl - rule__Package_Impl__Group__7 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__6__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getGroup_6()); } - (rule__Package_Impl__Group_6__0)? - { after(grammarAccess.getPackage_ImplAccess().getGroup_6()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__7 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group__7__Impl -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group__7__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_7()); } -) -; -finally { - restoreStackSize(stackSize); -} - - -rule__Package_Impl__Group_4__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_4__0__Impl - rule__Package_Impl__Group_4__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_4__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); } - 'FromGitRepo' - { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_4__1 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_4__1__Impl -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_4__1__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); } - (rule__Package_Impl__FromGitRepoAssignment_4_1) - { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); } -) -; -finally { - restoreStackSize(stackSize); -} - - -rule__Package_Impl__Group_5__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_5__0__Impl - rule__Package_Impl__Group_5__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); } - 'Specs' - { after(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5__1 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_5__1__Impl - rule__Package_Impl__Group_5__2 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5__1__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_5_1()); } - '{' - { after(grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_5_1()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5__2 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_5__2__Impl - rule__Package_Impl__Group_5__3 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5__2__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); } - (rule__Package_Impl__SpecAssignment_5_2) - { after(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5__3 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_5__3__Impl - rule__Package_Impl__Group_5__4 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5__3__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getGroup_5_3()); } - (rule__Package_Impl__Group_5_3__0)* - { after(grammarAccess.getPackage_ImplAccess().getGroup_5_3()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5__4 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_5__4__Impl -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5__4__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_5_4()); } - '}' - { after(grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_5_4()); } -) -; -finally { - restoreStackSize(stackSize); -} - - -rule__Package_Impl__Group_5_3__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_5_3__0__Impl - rule__Package_Impl__Group_5_3__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5_3__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getCommaKeyword_5_3_0()); } - ',' - { after(grammarAccess.getPackage_ImplAccess().getCommaKeyword_5_3_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5_3__1 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_5_3__1__Impl -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_5_3__1__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_3_1()); } - (rule__Package_Impl__SpecAssignment_5_3_1) - { after(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_3_1()); } -) -; -finally { - restoreStackSize(stackSize); -} - - -rule__Package_Impl__Group_6__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_6__0__Impl - rule__Package_Impl__Group_6__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_6__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getArtifactAssignment_6_0()); } - (rule__Package_Impl__ArtifactAssignment_6_0) - { after(grammarAccess.getPackage_ImplAccess().getArtifactAssignment_6_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_6__1 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_6__1__Impl -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_6__1__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getGroup_6_1()); } - (rule__Package_Impl__Group_6_1__0)* - { after(grammarAccess.getPackage_ImplAccess().getGroup_6_1()); } -) -; -finally { - restoreStackSize(stackSize); -} - - -rule__Package_Impl__Group_6_1__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_6_1__0__Impl - rule__Package_Impl__Group_6_1__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_6_1__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_1_0()); } - ',' - { after(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_1_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_6_1__1 - @init { - int stackSize = keepStackSize(); - } -: - rule__Package_Impl__Group_6_1__1__Impl -; -finally { - restoreStackSize(stackSize); -} - -rule__Package_Impl__Group_6_1__1__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getPackage_ImplAccess().getArtifactAssignment_6_1_1()); } - (rule__Package_Impl__ArtifactAssignment_6_1_1) - { after(grammarAccess.getPackage_ImplAccess().getArtifactAssignment_6_1_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().getArtifactKeyword_1()); } - 'Artifact' - { after(grammarAccess.getArtifactAccess().getArtifactKeyword_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().getNameAssignment_2()); } - (rule__Artifact__NameAssignment_2) - { after(grammarAccess.getArtifactAccess().getNameAssignment_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().getLeftCurlyBracketKeyword_3()); } - '{' - { after(grammarAccess.getArtifactAccess().getLeftCurlyBracketKeyword_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 + ( + { before(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); } + ruleuint16Array + { after(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); } + ruleint32Array + { after(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); } + ruleuint32Array + { after(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); } + ruleint64Array + { after(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); } + ruleuint64Array + { after(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); } + rulefloat32Array + { after(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); } + rulefloat64Array + { after(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); } + rulestring0Array + { after(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); } + rulebyteArray + { after(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); } + ruleTopicSpecRef + { after(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); } + ) + | + ( + { before(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); } + ruleArrayTopicSpecRef + { after(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); } + ) ; finally { restoreStackSize(stackSize); } -rule__Artifact__Group__5__Impl +rule__KEYWORD__Alternatives @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getArtifactAccess().getRightCurlyBracketKeyword_5()); } - '}' - { after(grammarAccess.getArtifactAccess().getRightCurlyBracketKeyword_5()); } -) + ( + { before(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); } + Goal + { after(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); } + Message + { after(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); } + Result + { after(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); } + Feedback + { after(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); } + Name + { after(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); } + Value + { after(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); } + Service + { after(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); } + Type + { after(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); } + Action + { after(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); } + Duration + { after(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); } + ) + | + ( + { before(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); } + Time + { after(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__CatkinPackage__Group__0 +rule__AmentPackage__Group__0 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group__0__Impl - rule__CatkinPackage__Group__1 + rule__AmentPackage__Group__0__Impl + rule__AmentPackage__Group__1 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__0__Impl +rule__AmentPackage__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0()); } + { before(grammarAccess.getAmentPackageAccess().getAmentPackageAction_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().getCatkinPackageKeyword_1()); } - 'CatkinPackage' - { after(grammarAccess.getCatkinPackageAccess().getCatkinPackageKeyword_1()); } + { after(grammarAccess.getAmentPackageAccess().getAmentPackageAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__2 +rule__AmentPackage__Group__1 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group__2__Impl - rule__CatkinPackage__Group__3 + rule__AmentPackage__Group__1__Impl + rule__AmentPackage__Group__2 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__2__Impl +rule__AmentPackage__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getNameAssignment_2()); } - (rule__CatkinPackage__NameAssignment_2) - { after(grammarAccess.getCatkinPackageAccess().getNameAssignment_2()); } + { before(grammarAccess.getAmentPackageAccess().getNameAssignment_1()); } + (rule__AmentPackage__NameAssignment_1) + { after(grammarAccess.getAmentPackageAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__3 +rule__AmentPackage__Group__2 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group__3__Impl - rule__CatkinPackage__Group__4 + rule__AmentPackage__Group__2__Impl + rule__AmentPackage__Group__3 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__3__Impl +rule__AmentPackage__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_3()); } - '{' - { after(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_3()); } + { before(grammarAccess.getAmentPackageAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getAmentPackageAccess().getColonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__4 +rule__AmentPackage__Group__3 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group__4__Impl - rule__CatkinPackage__Group__5 + rule__AmentPackage__Group__3__Impl + rule__AmentPackage__Group__4 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__4__Impl +rule__AmentPackage__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getGroup_4()); } - (rule__CatkinPackage__Group_4__0)? - { after(grammarAccess.getCatkinPackageAccess().getGroup_4()); } + { before(grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__5 +rule__AmentPackage__Group__4 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group__5__Impl - rule__CatkinPackage__Group__6 + rule__AmentPackage__Group__4__Impl + rule__AmentPackage__Group__5 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__5__Impl +rule__AmentPackage__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getGroup_5()); } - (rule__CatkinPackage__Group_5__0)? - { after(grammarAccess.getCatkinPackageAccess().getGroup_5()); } + { before(grammarAccess.getAmentPackageAccess().getGroup_4()); } + (rule__AmentPackage__Group_4__0)? + { after(grammarAccess.getAmentPackageAccess().getGroup_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__6 +rule__AmentPackage__Group__5 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group__6__Impl - rule__CatkinPackage__Group__7 + rule__AmentPackage__Group__5__Impl + rule__AmentPackage__Group__6 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__6__Impl +rule__AmentPackage__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getGroup_6()); } - (rule__CatkinPackage__Group_6__0)? - { after(grammarAccess.getCatkinPackageAccess().getGroup_6()); } + { before(grammarAccess.getAmentPackageAccess().getGroup_5()); } + (rule__AmentPackage__Group_5__0)? + { after(grammarAccess.getAmentPackageAccess().getGroup_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__7 +rule__AmentPackage__Group__6 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group__7__Impl - rule__CatkinPackage__Group__8 + rule__AmentPackage__Group__6__Impl + rule__AmentPackage__Group__7 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__7__Impl +rule__AmentPackage__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getGroup_7()); } - (rule__CatkinPackage__Group_7__0)? - { after(grammarAccess.getCatkinPackageAccess().getGroup_7()); } + { before(grammarAccess.getAmentPackageAccess().getGroup_6()); } + (rule__AmentPackage__Group_6__0)? + { after(grammarAccess.getAmentPackageAccess().getGroup_6()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__8 +rule__AmentPackage__Group__7 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group__8__Impl + rule__AmentPackage__Group__7__Impl ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group__8__Impl +rule__AmentPackage__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_8()); } - '}' - { after(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_8()); } + { before(grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_7()); } ) ; finally { @@ -4071,53 +3271,53 @@ finally { } -rule__CatkinPackage__Group_4__0 +rule__AmentPackage__Group_4__0 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_4__0__Impl - rule__CatkinPackage__Group_4__1 + rule__AmentPackage__Group_4__0__Impl + rule__AmentPackage__Group_4__1 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_4__0__Impl +rule__AmentPackage__Group_4__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getFromGitRepoKeyword_4_0()); } - 'FromGitRepo' - { after(grammarAccess.getCatkinPackageAccess().getFromGitRepoKeyword_4_0()); } + { before(grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); } + FromGitRepo + { after(grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_4__1 +rule__AmentPackage__Group_4__1 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_4__1__Impl + rule__AmentPackage__Group_4__1__Impl ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_4__1__Impl +rule__AmentPackage__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()); } + { before(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_4_1()); } + (rule__AmentPackage__FromGitRepoAssignment_4_1) + { after(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_4_1()); } ) ; finally { @@ -4125,134 +3325,107 @@ finally { } -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().getDependenciesKeyword_5_0()); } - 'Dependencies' - { after(grammarAccess.getCatkinPackageAccess().getDependenciesKeyword_5_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__CatkinPackage__Group_5__1 +rule__AmentPackage__Group_5__0 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_5__1__Impl - rule__CatkinPackage__Group_5__2 + rule__AmentPackage__Group_5__0__Impl + rule__AmentPackage__Group_5__1 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_5__1__Impl +rule__AmentPackage__Group_5__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_5_1()); } - '{' - { after(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_5_1()); } + { before(grammarAccess.getAmentPackageAccess().getArtifactsKeyword_5_0()); } + Artifacts + { after(grammarAccess.getAmentPackageAccess().getArtifactsKeyword_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_5__2 +rule__AmentPackage__Group_5__1 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_5__2__Impl - rule__CatkinPackage__Group_5__3 + rule__AmentPackage__Group_5__1__Impl + rule__AmentPackage__Group_5__2 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_5__2__Impl +rule__AmentPackage__Group_5__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_5_2()); } - (rule__CatkinPackage__DependencyAssignment_5_2) - { after(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_5_2()); } + { before(grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_5_1()); } + RULE_BEGIN + { after(grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_5_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_5__3 +rule__AmentPackage__Group_5__2 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_5__3__Impl - rule__CatkinPackage__Group_5__4 + rule__AmentPackage__Group_5__2__Impl + rule__AmentPackage__Group_5__3 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_5__3__Impl +rule__AmentPackage__Group_5__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getGroup_5_3()); } - (rule__CatkinPackage__Group_5_3__0)* - { after(grammarAccess.getCatkinPackageAccess().getGroup_5_3()); } + { before(grammarAccess.getAmentPackageAccess().getArtifactAssignment_5_2()); } + (rule__AmentPackage__ArtifactAssignment_5_2)* + { after(grammarAccess.getAmentPackageAccess().getArtifactAssignment_5_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_5__4 +rule__AmentPackage__Group_5__3 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_5__4__Impl + rule__AmentPackage__Group_5__3__Impl ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_5__4__Impl +rule__AmentPackage__Group_5__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_5_4()); } - '}' - { after(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_5_4()); } + { before(grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_5_3()); } + RULE_END + { after(grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_5_3()); } ) ; finally { @@ -4260,782 +3433,755 @@ finally { } -rule__CatkinPackage__Group_5_3__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__CatkinPackage__Group_5_3__0__Impl - rule__CatkinPackage__Group_5_3__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__CatkinPackage__Group_5_3__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getCatkinPackageAccess().getCommaKeyword_5_3_0()); } - ',' - { after(grammarAccess.getCatkinPackageAccess().getCommaKeyword_5_3_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__CatkinPackage__Group_5_3__1 +rule__AmentPackage__Group_6__0 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_5_3__1__Impl + rule__AmentPackage__Group_6__0__Impl + rule__AmentPackage__Group_6__1 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_5_3__1__Impl +rule__AmentPackage__Group_6__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_5_3_1()); } - (rule__CatkinPackage__DependencyAssignment_5_3_1) - { after(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_5_3_1()); } + { before(grammarAccess.getAmentPackageAccess().getDependenciesKeyword_6_0()); } + Dependencies + { after(grammarAccess.getAmentPackageAccess().getDependenciesKeyword_6_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__CatkinPackage__Group_6__0 +rule__AmentPackage__Group_6__1 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_6__0__Impl - rule__CatkinPackage__Group_6__1 + rule__AmentPackage__Group_6__1__Impl + rule__AmentPackage__Group_6__2 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6__0__Impl +rule__AmentPackage__Group_6__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getSpecsKeyword_6_0()); } - 'Specs' - { after(grammarAccess.getCatkinPackageAccess().getSpecsKeyword_6_0()); } + { before(grammarAccess.getAmentPackageAccess().getLeftSquareBracketKeyword_6_1()); } + LeftSquareBracket + { after(grammarAccess.getAmentPackageAccess().getLeftSquareBracketKeyword_6_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6__1 +rule__AmentPackage__Group_6__2 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_6__1__Impl - rule__CatkinPackage__Group_6__2 + rule__AmentPackage__Group_6__2__Impl + rule__AmentPackage__Group_6__3 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6__1__Impl +rule__AmentPackage__Group_6__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_6_1()); } - '{' - { after(grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_6_1()); } + { before(grammarAccess.getAmentPackageAccess().getDependencyAssignment_6_2()); } + (rule__AmentPackage__DependencyAssignment_6_2) + { after(grammarAccess.getAmentPackageAccess().getDependencyAssignment_6_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6__2 +rule__AmentPackage__Group_6__3 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_6__2__Impl - rule__CatkinPackage__Group_6__3 + rule__AmentPackage__Group_6__3__Impl + rule__AmentPackage__Group_6__4 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6__2__Impl +rule__AmentPackage__Group_6__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getSpecAssignment_6_2()); } - (rule__CatkinPackage__SpecAssignment_6_2) - { after(grammarAccess.getCatkinPackageAccess().getSpecAssignment_6_2()); } + { before(grammarAccess.getAmentPackageAccess().getGroup_6_3()); } + (rule__AmentPackage__Group_6_3__0)* + { after(grammarAccess.getAmentPackageAccess().getGroup_6_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6__3 +rule__AmentPackage__Group_6__4 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_6__3__Impl - rule__CatkinPackage__Group_6__4 + rule__AmentPackage__Group_6__4__Impl ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6__3__Impl +rule__AmentPackage__Group_6__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getGroup_6_3()); } - (rule__CatkinPackage__Group_6_3__0)* - { after(grammarAccess.getCatkinPackageAccess().getGroup_6_3()); } + { before(grammarAccess.getAmentPackageAccess().getRightSquareBracketKeyword_6_4()); } + RightSquareBracket + { after(grammarAccess.getAmentPackageAccess().getRightSquareBracketKeyword_6_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6__4 + +rule__AmentPackage__Group_6_3__0 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_6__4__Impl + rule__AmentPackage__Group_6_3__0__Impl + rule__AmentPackage__Group_6_3__1 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6__4__Impl +rule__AmentPackage__Group_6_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_6_4()); } - '}' - { after(grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_6_4()); } + { before(grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); } + Comma + { after(grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__CatkinPackage__Group_6_3__0 +rule__AmentPackage__Group_6_3__1 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_6_3__0__Impl - rule__CatkinPackage__Group_6_3__1 + rule__AmentPackage__Group_6_3__1__Impl ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6_3__0__Impl +rule__AmentPackage__Group_6_3__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); } - ',' - { after(grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); } + { before(grammarAccess.getAmentPackageAccess().getDependencyAssignment_6_3_1()); } + (rule__AmentPackage__DependencyAssignment_6_3_1) + { after(grammarAccess.getAmentPackageAccess().getDependencyAssignment_6_3_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6_3__1 + +rule__QualityOfService__Group__0 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_6_3__1__Impl + rule__QualityOfService__Group__0__Impl + rule__QualityOfService__Group__1 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_6_3__1__Impl +rule__QualityOfService__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getSpecAssignment_6_3_1()); } - (rule__CatkinPackage__SpecAssignment_6_3_1) - { after(grammarAccess.getCatkinPackageAccess().getSpecAssignment_6_3_1()); } + { before(grammarAccess.getQualityOfServiceAccess().getQualityOfServiceAction_0()); } + () + { after(grammarAccess.getQualityOfServiceAccess().getQualityOfServiceAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__CatkinPackage__Group_7__0 +rule__QualityOfService__Group__1 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_7__0__Impl - rule__CatkinPackage__Group_7__1 + rule__QualityOfService__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_7__0__Impl +rule__QualityOfService__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_7_0()); } - (rule__CatkinPackage__ArtifactAssignment_7_0) - { after(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_7_0()); } + { before(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); } + (rule__QualityOfService__UnorderedGroup_1) + { after(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_7__1 + +rule__QualityOfService__Group_1_0__0 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_7__1__Impl + rule__QualityOfService__Group_1_0__0__Impl + rule__QualityOfService__Group_1_0__1 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_7__1__Impl +rule__QualityOfService__Group_1_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getGroup_7_1()); } - (rule__CatkinPackage__Group_7_1__0)* - { after(grammarAccess.getCatkinPackageAccess().getGroup_7_1()); } + { before(grammarAccess.getQualityOfServiceAccess().getProfileKeyword_1_0_0()); } + Profile + { after(grammarAccess.getQualityOfServiceAccess().getProfileKeyword_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__CatkinPackage__Group_7_1__0 +rule__QualityOfService__Group_1_0__1 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_7_1__0__Impl - rule__CatkinPackage__Group_7_1__1 + rule__QualityOfService__Group_1_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_7_1__0__Impl +rule__QualityOfService__Group_1_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getCommaKeyword_7_1_0()); } - ',' - { after(grammarAccess.getCatkinPackageAccess().getCommaKeyword_7_1_0()); } + { before(grammarAccess.getQualityOfServiceAccess().getQoSProfileAssignment_1_0_1()); } + (rule__QualityOfService__QoSProfileAssignment_1_0_1) + { after(grammarAccess.getQualityOfServiceAccess().getQoSProfileAssignment_1_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_7_1__1 + +rule__QualityOfService__Group_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__CatkinPackage__Group_7_1__1__Impl + rule__QualityOfService__Group_1_1__0__Impl + rule__QualityOfService__Group_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__Group_7_1__1__Impl +rule__QualityOfService__Group_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_7_1_1()); } - (rule__CatkinPackage__ArtifactAssignment_7_1_1) - { after(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_7_1_1()); } + { before(grammarAccess.getQualityOfServiceAccess().getHistoryKeyword_1_1_0()); } + History + { after(grammarAccess.getQualityOfServiceAccess().getHistoryKeyword_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AmentPackage__Group__0 +rule__QualityOfService__Group_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group__0__Impl - rule__AmentPackage__Group__1 + rule__QualityOfService__Group_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__0__Impl +rule__QualityOfService__Group_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getAmentPackageAction_0()); } - () - { after(grammarAccess.getAmentPackageAccess().getAmentPackageAction_0()); } + { before(grammarAccess.getQualityOfServiceAccess().getHistoryAssignment_1_1_1()); } + (rule__QualityOfService__HistoryAssignment_1_1_1) + { after(grammarAccess.getQualityOfServiceAccess().getHistoryAssignment_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__1 + +rule__QualityOfService__Group_1_2__0 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group__1__Impl - rule__AmentPackage__Group__2 + rule__QualityOfService__Group_1_2__0__Impl + rule__QualityOfService__Group_1_2__1 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__1__Impl +rule__QualityOfService__Group_1_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getAmentPackageKeyword_1()); } - 'AmentPackage' - { after(grammarAccess.getAmentPackageAccess().getAmentPackageKeyword_1()); } + { before(grammarAccess.getQualityOfServiceAccess().getDepthKeyword_1_2_0()); } + Depth + { after(grammarAccess.getQualityOfServiceAccess().getDepthKeyword_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__2 +rule__QualityOfService__Group_1_2__1 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group__2__Impl - rule__AmentPackage__Group__3 + rule__QualityOfService__Group_1_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__2__Impl +rule__QualityOfService__Group_1_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getNameAssignment_2()); } - (rule__AmentPackage__NameAssignment_2) - { after(grammarAccess.getAmentPackageAccess().getNameAssignment_2()); } + { before(grammarAccess.getQualityOfServiceAccess().getDepthAssignment_1_2_1()); } + (rule__QualityOfService__DepthAssignment_1_2_1) + { after(grammarAccess.getQualityOfServiceAccess().getDepthAssignment_1_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__3 + +rule__QualityOfService__Group_1_3__0 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group__3__Impl - rule__AmentPackage__Group__4 + rule__QualityOfService__Group_1_3__0__Impl + rule__QualityOfService__Group_1_3__1 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__3__Impl +rule__QualityOfService__Group_1_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_3()); } - '{' - { after(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_3()); } + { before(grammarAccess.getQualityOfServiceAccess().getReliabilityKeyword_1_3_0()); } + Reliability + { after(grammarAccess.getQualityOfServiceAccess().getReliabilityKeyword_1_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__4 +rule__QualityOfService__Group_1_3__1 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group__4__Impl - rule__AmentPackage__Group__5 + rule__QualityOfService__Group_1_3__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__4__Impl +rule__QualityOfService__Group_1_3__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getGroup_4()); } - (rule__AmentPackage__Group_4__0)? - { after(grammarAccess.getAmentPackageAccess().getGroup_4()); } + { before(grammarAccess.getQualityOfServiceAccess().getReliabilityAssignment_1_3_1()); } + (rule__QualityOfService__ReliabilityAssignment_1_3_1) + { after(grammarAccess.getQualityOfServiceAccess().getReliabilityAssignment_1_3_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__5 + +rule__QualityOfService__Group_1_4__0 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group__5__Impl - rule__AmentPackage__Group__6 + rule__QualityOfService__Group_1_4__0__Impl + rule__QualityOfService__Group_1_4__1 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__5__Impl +rule__QualityOfService__Group_1_4__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getGroup_5()); } - (rule__AmentPackage__Group_5__0)? - { after(grammarAccess.getAmentPackageAccess().getGroup_5()); } + { before(grammarAccess.getQualityOfServiceAccess().getDurabilityKeyword_1_4_0()); } + Durability + { after(grammarAccess.getQualityOfServiceAccess().getDurabilityKeyword_1_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__6 +rule__QualityOfService__Group_1_4__1 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group__6__Impl - rule__AmentPackage__Group__7 + rule__QualityOfService__Group_1_4__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__6__Impl +rule__QualityOfService__Group_1_4__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getGroup_6()); } - (rule__AmentPackage__Group_6__0)? - { after(grammarAccess.getAmentPackageAccess().getGroup_6()); } + { before(grammarAccess.getQualityOfServiceAccess().getDurabilityAssignment_1_4_1()); } + (rule__QualityOfService__DurabilityAssignment_1_4_1) + { after(grammarAccess.getQualityOfServiceAccess().getDurabilityAssignment_1_4_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__7 + +rule__Publisher__Group__0 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group__7__Impl - rule__AmentPackage__Group__8 + rule__Publisher__Group__0__Impl + rule__Publisher__Group__1 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__7__Impl +rule__Publisher__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getGroup_7()); } - (rule__AmentPackage__Group_7__0)? - { after(grammarAccess.getAmentPackageAccess().getGroup_7()); } + { before(grammarAccess.getPublisherAccess().getPublisherAction_0()); } + () + { after(grammarAccess.getPublisherAccess().getPublisherAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__8 +rule__Publisher__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group__8__Impl + rule__Publisher__Group__1__Impl + rule__Publisher__Group__2 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group__8__Impl +rule__Publisher__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_8()); } - '}' - { after(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_8()); } + { before(grammarAccess.getPublisherAccess().getNameAssignment_1()); } + (rule__Publisher__NameAssignment_1) + { after(grammarAccess.getPublisherAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AmentPackage__Group_4__0 +rule__Publisher__Group__2 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_4__0__Impl - rule__AmentPackage__Group_4__1 + rule__Publisher__Group__2__Impl + rule__Publisher__Group__3 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_4__0__Impl +rule__Publisher__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); } - 'FromGitRepo' - { after(grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); } + { before(grammarAccess.getPublisherAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getPublisherAccess().getColonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_4__1 +rule__Publisher__Group__3 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_4__1__Impl + rule__Publisher__Group__3__Impl + rule__Publisher__Group__4 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_4__1__Impl +rule__Publisher__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_4_1()); } - (rule__AmentPackage__FromGitRepoAssignment_4_1) - { after(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_4_1()); } + { before(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AmentPackage__Group_5__0 +rule__Publisher__Group__4 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_5__0__Impl - rule__AmentPackage__Group_5__1 + rule__Publisher__Group__4__Impl + rule__Publisher__Group__5 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5__0__Impl +rule__Publisher__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getDependenciesKeyword_5_0()); } - 'Dependencies' - { after(grammarAccess.getAmentPackageAccess().getDependenciesKeyword_5_0()); } + { before(grammarAccess.getPublisherAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getPublisherAccess().getTypeKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5__1 +rule__Publisher__Group__5 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_5__1__Impl - rule__AmentPackage__Group_5__2 + rule__Publisher__Group__5__Impl + rule__Publisher__Group__6 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5__1__Impl +rule__Publisher__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_5_1()); } - '{' - { after(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_5_1()); } + { before(grammarAccess.getPublisherAccess().getMessageAssignment_5()); } + (rule__Publisher__MessageAssignment_5) + { after(grammarAccess.getPublisherAccess().getMessageAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5__2 +rule__Publisher__Group__6 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_5__2__Impl - rule__AmentPackage__Group_5__3 + rule__Publisher__Group__6__Impl + rule__Publisher__Group__7 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5__2__Impl +rule__Publisher__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getDependencyAssignment_5_2()); } - (rule__AmentPackage__DependencyAssignment_5_2) - { after(grammarAccess.getAmentPackageAccess().getDependencyAssignment_5_2()); } + { before(grammarAccess.getPublisherAccess().getGroup_6()); } + (rule__Publisher__Group_6__0)? + { after(grammarAccess.getPublisherAccess().getGroup_6()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5__3 +rule__Publisher__Group__7 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_5__3__Impl - rule__AmentPackage__Group_5__4 + rule__Publisher__Group__7__Impl + rule__Publisher__Group__8 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5__3__Impl +rule__Publisher__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getGroup_5_3()); } - (rule__AmentPackage__Group_5_3__0)* - { after(grammarAccess.getAmentPackageAccess().getGroup_5_3()); } + { before(grammarAccess.getPublisherAccess().getGroup_7()); } + (rule__Publisher__Group_7__0)? + { after(grammarAccess.getPublisherAccess().getGroup_7()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5__4 +rule__Publisher__Group__8 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_5__4__Impl + rule__Publisher__Group__8__Impl ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5__4__Impl +rule__Publisher__Group__8__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_5_4()); } - '}' - { after(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_5_4()); } + { before(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_8()); } + RULE_END + { after(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_8()); } ) ; finally { @@ -5043,53 +4189,53 @@ finally { } -rule__AmentPackage__Group_5_3__0 +rule__Publisher__Group_6__0 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_5_3__0__Impl - rule__AmentPackage__Group_5_3__1 + rule__Publisher__Group_6__0__Impl + rule__Publisher__Group_6__1 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5_3__0__Impl +rule__Publisher__Group_6__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getCommaKeyword_5_3_0()); } - ',' - { after(grammarAccess.getAmentPackageAccess().getCommaKeyword_5_3_0()); } + { before(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5_3__1 +rule__Publisher__Group_6__1 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_5_3__1__Impl + rule__Publisher__Group_6__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_5_3__1__Impl +rule__Publisher__Group_6__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getDependencyAssignment_5_3_1()); } - (rule__AmentPackage__DependencyAssignment_5_3_1) - { after(grammarAccess.getAmentPackageAccess().getDependencyAssignment_5_3_1()); } + { before(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); } + (rule__Publisher__NamespaceAssignment_6_1) + { after(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); } ) ; finally { @@ -5097,755 +4243,755 @@ finally { } -rule__AmentPackage__Group_6__0 +rule__Publisher__Group_7__0 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_6__0__Impl - rule__AmentPackage__Group_6__1 + rule__Publisher__Group_7__0__Impl + rule__Publisher__Group_7__1 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6__0__Impl +rule__Publisher__Group_7__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getSpecsKeyword_6_0()); } - 'Specs' - { after(grammarAccess.getAmentPackageAccess().getSpecsKeyword_6_0()); } + { before(grammarAccess.getPublisherAccess().getQosKeyword_7_0()); } + Qos + { after(grammarAccess.getPublisherAccess().getQosKeyword_7_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6__1 +rule__Publisher__Group_7__1 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_6__1__Impl - rule__AmentPackage__Group_6__2 + rule__Publisher__Group_7__1__Impl + rule__Publisher__Group_7__2 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6__1__Impl +rule__Publisher__Group_7__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_6_1()); } - '{' - { after(grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_6_1()); } + { before(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_7_1()); } + RULE_BEGIN + { after(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_7_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6__2 +rule__Publisher__Group_7__2 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_6__2__Impl - rule__AmentPackage__Group_6__3 + rule__Publisher__Group_7__2__Impl + rule__Publisher__Group_7__3 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6__2__Impl +rule__Publisher__Group_7__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getSpecAssignment_6_2()); } - (rule__AmentPackage__SpecAssignment_6_2) - { after(grammarAccess.getAmentPackageAccess().getSpecAssignment_6_2()); } + { before(grammarAccess.getPublisherAccess().getQosAssignment_7_2()); } + (rule__Publisher__QosAssignment_7_2) + { after(grammarAccess.getPublisherAccess().getQosAssignment_7_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6__3 +rule__Publisher__Group_7__3 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_6__3__Impl - rule__AmentPackage__Group_6__4 + rule__Publisher__Group_7__3__Impl ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6__3__Impl +rule__Publisher__Group_7__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getGroup_6_3()); } - (rule__AmentPackage__Group_6_3__0)* - { after(grammarAccess.getAmentPackageAccess().getGroup_6_3()); } + { before(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7_3()); } + RULE_END + { after(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6__4 + +rule__Subscriber__Group__0 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_6__4__Impl + rule__Subscriber__Group__0__Impl + rule__Subscriber__Group__1 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6__4__Impl +rule__Subscriber__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_6_4()); } - '}' - { after(grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_6_4()); } + { before(grammarAccess.getSubscriberAccess().getSubscriberAction_0()); } + () + { after(grammarAccess.getSubscriberAccess().getSubscriberAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AmentPackage__Group_6_3__0 +rule__Subscriber__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_6_3__0__Impl - rule__AmentPackage__Group_6_3__1 + rule__Subscriber__Group__1__Impl + rule__Subscriber__Group__2 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6_3__0__Impl +rule__Subscriber__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); } - ',' - { after(grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); } + { before(grammarAccess.getSubscriberAccess().getNameAssignment_1()); } + (rule__Subscriber__NameAssignment_1) + { after(grammarAccess.getSubscriberAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6_3__1 +rule__Subscriber__Group__2 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_6_3__1__Impl + rule__Subscriber__Group__2__Impl + rule__Subscriber__Group__3 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_6_3__1__Impl +rule__Subscriber__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getSpecAssignment_6_3_1()); } - (rule__AmentPackage__SpecAssignment_6_3_1) - { after(grammarAccess.getAmentPackageAccess().getSpecAssignment_6_3_1()); } + { before(grammarAccess.getSubscriberAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getSubscriberAccess().getColonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AmentPackage__Group_7__0 +rule__Subscriber__Group__3 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_7__0__Impl - rule__AmentPackage__Group_7__1 + rule__Subscriber__Group__3__Impl + rule__Subscriber__Group__4 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_7__0__Impl +rule__Subscriber__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getArtifactAssignment_7_0()); } - (rule__AmentPackage__ArtifactAssignment_7_0) - { after(grammarAccess.getAmentPackageAccess().getArtifactAssignment_7_0()); } + { before(grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_7__1 +rule__Subscriber__Group__4 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_7__1__Impl + rule__Subscriber__Group__4__Impl + rule__Subscriber__Group__5 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_7__1__Impl +rule__Subscriber__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getGroup_7_1()); } - (rule__AmentPackage__Group_7_1__0)* - { after(grammarAccess.getAmentPackageAccess().getGroup_7_1()); } + { before(grammarAccess.getSubscriberAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getSubscriberAccess().getTypeKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AmentPackage__Group_7_1__0 +rule__Subscriber__Group__5 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_7_1__0__Impl - rule__AmentPackage__Group_7_1__1 + rule__Subscriber__Group__5__Impl + rule__Subscriber__Group__6 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_7_1__0__Impl +rule__Subscriber__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getCommaKeyword_7_1_0()); } - ',' - { after(grammarAccess.getAmentPackageAccess().getCommaKeyword_7_1_0()); } + { before(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); } + (rule__Subscriber__MessageAssignment_5) + { after(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_7_1__1 +rule__Subscriber__Group__6 @init { int stackSize = keepStackSize(); } : - rule__AmentPackage__Group_7_1__1__Impl + rule__Subscriber__Group__6__Impl + rule__Subscriber__Group__7 ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__Group_7_1__1__Impl +rule__Subscriber__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getArtifactAssignment_7_1_1()); } - (rule__AmentPackage__ArtifactAssignment_7_1_1) - { after(grammarAccess.getAmentPackageAccess().getArtifactAssignment_7_1_1()); } + { before(grammarAccess.getSubscriberAccess().getGroup_6()); } + (rule__Subscriber__Group_6__0)? + { after(grammarAccess.getSubscriberAccess().getGroup_6()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ServiceSpec__Group__0 +rule__Subscriber__Group__7 @init { int stackSize = keepStackSize(); } : - rule__ServiceSpec__Group__0__Impl - rule__ServiceSpec__Group__1 + rule__Subscriber__Group__7__Impl + rule__Subscriber__Group__8 ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__0__Impl +rule__Subscriber__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); } - () - { after(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); } + { before(grammarAccess.getSubscriberAccess().getGroup_7()); } + (rule__Subscriber__Group_7__0)? + { after(grammarAccess.getSubscriberAccess().getGroup_7()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__1 +rule__Subscriber__Group__8 @init { int stackSize = keepStackSize(); } : - rule__ServiceSpec__Group__1__Impl - rule__ServiceSpec__Group__2 + rule__Subscriber__Group__8__Impl ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__1__Impl +rule__Subscriber__Group__8__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getServiceSpecKeyword_1()); } - 'ServiceSpec' - { after(grammarAccess.getServiceSpecAccess().getServiceSpecKeyword_1()); } + { before(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_8()); } + RULE_END + { after(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_8()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__2 + +rule__Subscriber__Group_6__0 @init { int stackSize = keepStackSize(); } : - rule__ServiceSpec__Group__2__Impl - rule__ServiceSpec__Group__3 + rule__Subscriber__Group_6__0__Impl + rule__Subscriber__Group_6__1 ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__2__Impl +rule__Subscriber__Group_6__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); } - (rule__ServiceSpec__NameAssignment_2) - { after(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); } + { before(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__3 +rule__Subscriber__Group_6__1 @init { int stackSize = keepStackSize(); } : - rule__ServiceSpec__Group__3__Impl - rule__ServiceSpec__Group__4 + rule__Subscriber__Group_6__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__3__Impl +rule__Subscriber__Group_6__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getLeftCurlyBracketKeyword_3()); } - '{' - { after(grammarAccess.getServiceSpecAccess().getLeftCurlyBracketKeyword_3()); } + { before(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); } + (rule__Subscriber__NamespaceAssignment_6_1) + { after(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__4 + +rule__Subscriber__Group_7__0 @init { int stackSize = keepStackSize(); } : - rule__ServiceSpec__Group__4__Impl - rule__ServiceSpec__Group__5 + rule__Subscriber__Group_7__0__Impl + rule__Subscriber__Group_7__1 ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__4__Impl +rule__Subscriber__Group_7__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getGroup_4()); } - (rule__ServiceSpec__Group_4__0)? - { after(grammarAccess.getServiceSpecAccess().getGroup_4()); } + { before(grammarAccess.getSubscriberAccess().getQosKeyword_7_0()); } + Qos + { after(grammarAccess.getSubscriberAccess().getQosKeyword_7_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__5 +rule__Subscriber__Group_7__1 @init { int stackSize = keepStackSize(); } : - rule__ServiceSpec__Group__5__Impl - rule__ServiceSpec__Group__6 + rule__Subscriber__Group_7__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__5__Impl +rule__Subscriber__Group_7__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getGroup_5()); } - (rule__ServiceSpec__Group_5__0)? - { after(grammarAccess.getServiceSpecAccess().getGroup_5()); } + { before(grammarAccess.getSubscriberAccess().getQosAssignment_7_1()); } + (rule__Subscriber__QosAssignment_7_1) + { after(grammarAccess.getSubscriberAccess().getQosAssignment_7_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__6 + +rule__ServiceServer__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ServiceSpec__Group__6__Impl + rule__ServiceServer__Group__0__Impl + rule__ServiceServer__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group__6__Impl +rule__ServiceServer__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getRightCurlyBracketKeyword_6()); } - '}' - { after(grammarAccess.getServiceSpecAccess().getRightCurlyBracketKeyword_6()); } + { before(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); } + () + { after(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ServiceSpec__Group_4__0 +rule__ServiceServer__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ServiceSpec__Group_4__0__Impl - rule__ServiceSpec__Group_4__1 + rule__ServiceServer__Group__1__Impl + rule__ServiceServer__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group_4__0__Impl +rule__ServiceServer__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getRequestKeyword_4_0()); } - 'request' - { after(grammarAccess.getServiceSpecAccess().getRequestKeyword_4_0()); } + { before(grammarAccess.getServiceServerAccess().getNameAssignment_1()); } + (rule__ServiceServer__NameAssignment_1) + { after(grammarAccess.getServiceServerAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group_4__1 +rule__ServiceServer__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ServiceSpec__Group_4__1__Impl + rule__ServiceServer__Group__2__Impl + rule__ServiceServer__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group_4__1__Impl +rule__ServiceServer__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getRequestAssignment_4_1()); } - (rule__ServiceSpec__RequestAssignment_4_1) - { after(grammarAccess.getServiceSpecAccess().getRequestAssignment_4_1()); } + { before(grammarAccess.getServiceServerAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getServiceServerAccess().getColonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ServiceSpec__Group_5__0 +rule__ServiceServer__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ServiceSpec__Group_5__0__Impl - rule__ServiceSpec__Group_5__1 + rule__ServiceServer__Group__3__Impl + rule__ServiceServer__Group__4 ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group_5__0__Impl +rule__ServiceServer__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getResponseKeyword_5_0()); } - 'response' - { after(grammarAccess.getServiceSpecAccess().getResponseKeyword_5_0()); } + { before(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group_5__1 +rule__ServiceServer__Group__4 @init { int stackSize = keepStackSize(); } : - rule__ServiceSpec__Group_5__1__Impl + rule__ServiceServer__Group__4__Impl + rule__ServiceServer__Group__5 ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__Group_5__1__Impl +rule__ServiceServer__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getResponseAssignment_5_1()); } - (rule__ServiceSpec__ResponseAssignment_5_1) - { after(grammarAccess.getServiceSpecAccess().getResponseAssignment_5_1()); } + { before(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } - -rule__TopicSpec__Group__0 +rule__ServiceServer__Group__5 @init { int stackSize = keepStackSize(); } : - rule__TopicSpec__Group__0__Impl - rule__TopicSpec__Group__1 + rule__ServiceServer__Group__5__Impl + rule__ServiceServer__Group__6 ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group__0__Impl +rule__ServiceServer__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); } - () - { after(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); } + { before(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); } + (rule__ServiceServer__ServiceAssignment_5) + { after(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group__1 +rule__ServiceServer__Group__6 @init { int stackSize = keepStackSize(); } : - rule__TopicSpec__Group__1__Impl - rule__TopicSpec__Group__2 + rule__ServiceServer__Group__6__Impl + rule__ServiceServer__Group__7 ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group__1__Impl +rule__ServiceServer__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTopicSpecAccess().getTopicSpecKeyword_1()); } - 'TopicSpec' - { after(grammarAccess.getTopicSpecAccess().getTopicSpecKeyword_1()); } + { before(grammarAccess.getServiceServerAccess().getGroup_6()); } + (rule__ServiceServer__Group_6__0)? + { after(grammarAccess.getServiceServerAccess().getGroup_6()); } ) ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group__2 +rule__ServiceServer__Group__7 @init { int stackSize = keepStackSize(); } : - rule__TopicSpec__Group__2__Impl - rule__TopicSpec__Group__3 + rule__ServiceServer__Group__7__Impl + rule__ServiceServer__Group__8 ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group__2__Impl +rule__ServiceServer__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); } - (rule__TopicSpec__NameAssignment_2) - { after(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); } + { before(grammarAccess.getServiceServerAccess().getGroup_7()); } + (rule__ServiceServer__Group_7__0)? + { after(grammarAccess.getServiceServerAccess().getGroup_7()); } ) ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group__3 +rule__ServiceServer__Group__8 @init { int stackSize = keepStackSize(); } : - rule__TopicSpec__Group__3__Impl - rule__TopicSpec__Group__4 + rule__ServiceServer__Group__8__Impl ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group__3__Impl +rule__ServiceServer__Group__8__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTopicSpecAccess().getLeftCurlyBracketKeyword_3()); } - '{' - { after(grammarAccess.getTopicSpecAccess().getLeftCurlyBracketKeyword_3()); } + { before(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_8()); } + RULE_END + { after(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_8()); } ) ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group__4 + +rule__ServiceServer__Group_6__0 @init { int stackSize = keepStackSize(); } : - rule__TopicSpec__Group__4__Impl - rule__TopicSpec__Group__5 + rule__ServiceServer__Group_6__0__Impl + rule__ServiceServer__Group_6__1 ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group__4__Impl +rule__ServiceServer__Group_6__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTopicSpecAccess().getGroup_4()); } - (rule__TopicSpec__Group_4__0)? - { after(grammarAccess.getTopicSpecAccess().getGroup_4()); } + { before(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group__5 +rule__ServiceServer__Group_6__1 @init { int stackSize = keepStackSize(); } : - rule__TopicSpec__Group__5__Impl + rule__ServiceServer__Group_6__1__Impl ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group__5__Impl +rule__ServiceServer__Group_6__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTopicSpecAccess().getRightCurlyBracketKeyword_5()); } - '}' - { after(grammarAccess.getTopicSpecAccess().getRightCurlyBracketKeyword_5()); } + { before(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); } + (rule__ServiceServer__NamespaceAssignment_6_1) + { after(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); } ) ; finally { @@ -5853,53 +4999,53 @@ finally { } -rule__TopicSpec__Group_4__0 +rule__ServiceServer__Group_7__0 @init { int stackSize = keepStackSize(); } : - rule__TopicSpec__Group_4__0__Impl - rule__TopicSpec__Group_4__1 + rule__ServiceServer__Group_7__0__Impl + rule__ServiceServer__Group_7__1 ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group_4__0__Impl +rule__ServiceServer__Group_7__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTopicSpecAccess().getMessageKeyword_4_0()); } - 'message' - { after(grammarAccess.getTopicSpecAccess().getMessageKeyword_4_0()); } + { before(grammarAccess.getServiceServerAccess().getQosKeyword_7_0()); } + Qos + { after(grammarAccess.getServiceServerAccess().getQosKeyword_7_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group_4__1 +rule__ServiceServer__Group_7__1 @init { int stackSize = keepStackSize(); } : - rule__TopicSpec__Group_4__1__Impl + rule__ServiceServer__Group_7__1__Impl ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__Group_4__1__Impl +rule__ServiceServer__Group_7__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTopicSpecAccess().getMessageAssignment_4_1()); } - (rule__TopicSpec__MessageAssignment_4_1) - { after(grammarAccess.getTopicSpecAccess().getMessageAssignment_4_1()); } + { before(grammarAccess.getServiceServerAccess().getQosAssignment_7_1()); } + (rule__ServiceServer__QosAssignment_7_1) + { after(grammarAccess.getServiceServerAccess().getQosAssignment_7_1()); } ) ; finally { @@ -5907,998 +5053,998 @@ finally { } -rule__ActionSpec__Group__0 +rule__ServiceClient__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group__0__Impl - rule__ActionSpec__Group__1 + rule__ServiceClient__Group__0__Impl + rule__ServiceClient__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__0__Impl +rule__ServiceClient__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); } + { before(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); } () - { after(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); } + { after(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__1 +rule__ServiceClient__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group__1__Impl - rule__ActionSpec__Group__2 + rule__ServiceClient__Group__1__Impl + rule__ServiceClient__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__1__Impl +rule__ServiceClient__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getActionSpecKeyword_1()); } - 'ActionSpec' - { after(grammarAccess.getActionSpecAccess().getActionSpecKeyword_1()); } + { before(grammarAccess.getServiceClientAccess().getNameAssignment_1()); } + (rule__ServiceClient__NameAssignment_1) + { after(grammarAccess.getServiceClientAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__2 +rule__ServiceClient__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group__2__Impl - rule__ActionSpec__Group__3 + rule__ServiceClient__Group__2__Impl + rule__ServiceClient__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__2__Impl +rule__ServiceClient__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getNameAssignment_2()); } - (rule__ActionSpec__NameAssignment_2) - { after(grammarAccess.getActionSpecAccess().getNameAssignment_2()); } + { before(grammarAccess.getServiceClientAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getServiceClientAccess().getColonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__3 +rule__ServiceClient__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group__3__Impl - rule__ActionSpec__Group__4 + rule__ServiceClient__Group__3__Impl + rule__ServiceClient__Group__4 ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__3__Impl +rule__ServiceClient__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getLeftCurlyBracketKeyword_3()); } - '{' - { after(grammarAccess.getActionSpecAccess().getLeftCurlyBracketKeyword_3()); } + { before(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__4 +rule__ServiceClient__Group__4 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group__4__Impl - rule__ActionSpec__Group__5 + rule__ServiceClient__Group__4__Impl + rule__ServiceClient__Group__5 ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__4__Impl +rule__ServiceClient__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getGroup_4()); } - (rule__ActionSpec__Group_4__0)? - { after(grammarAccess.getActionSpecAccess().getGroup_4()); } + { before(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__5 +rule__ServiceClient__Group__5 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group__5__Impl - rule__ActionSpec__Group__6 + rule__ServiceClient__Group__5__Impl + rule__ServiceClient__Group__6 ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__5__Impl +rule__ServiceClient__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getGroup_5()); } - (rule__ActionSpec__Group_5__0)? - { after(grammarAccess.getActionSpecAccess().getGroup_5()); } + { before(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); } + (rule__ServiceClient__ServiceAssignment_5) + { after(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__6 +rule__ServiceClient__Group__6 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group__6__Impl - rule__ActionSpec__Group__7 + rule__ServiceClient__Group__6__Impl + rule__ServiceClient__Group__7 ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__6__Impl +rule__ServiceClient__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getGroup_6()); } - (rule__ActionSpec__Group_6__0)? - { after(grammarAccess.getActionSpecAccess().getGroup_6()); } + { before(grammarAccess.getServiceClientAccess().getGroup_6()); } + (rule__ServiceClient__Group_6__0)? + { after(grammarAccess.getServiceClientAccess().getGroup_6()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__7 +rule__ServiceClient__Group__7 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group__7__Impl + rule__ServiceClient__Group__7__Impl + rule__ServiceClient__Group__8 ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group__7__Impl +rule__ServiceClient__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getActionSpecAccess().getRightCurlyBracketKeyword_7()); } + { before(grammarAccess.getServiceClientAccess().getGroup_7()); } + (rule__ServiceClient__Group_7__0)? + { after(grammarAccess.getServiceClientAccess().getGroup_7()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ActionSpec__Group_4__0 +rule__ServiceClient__Group__8 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group_4__0__Impl - rule__ActionSpec__Group_4__1 + rule__ServiceClient__Group__8__Impl ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group_4__0__Impl +rule__ServiceClient__Group__8__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getGoalKeyword_4_0()); } - 'goal' - { after(grammarAccess.getActionSpecAccess().getGoalKeyword_4_0()); } + { before(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_8()); } + RULE_END + { after(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_8()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group_4__1 + +rule__ServiceClient__Group_6__0 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group_4__1__Impl + rule__ServiceClient__Group_6__0__Impl + rule__ServiceClient__Group_6__1 ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group_4__1__Impl +rule__ServiceClient__Group_6__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getGoalAssignment_4_1()); } - (rule__ActionSpec__GoalAssignment_4_1) - { after(grammarAccess.getActionSpecAccess().getGoalAssignment_4_1()); } + { before(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ActionSpec__Group_5__0 +rule__ServiceClient__Group_6__1 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group_5__0__Impl - rule__ActionSpec__Group_5__1 + rule__ServiceClient__Group_6__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group_5__0__Impl +rule__ServiceClient__Group_6__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getResultKeyword_5_0()); } - 'result' - { after(grammarAccess.getActionSpecAccess().getResultKeyword_5_0()); } + { before(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); } + (rule__ServiceClient__NamespaceAssignment_6_1) + { after(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group_5__1 + +rule__ServiceClient__Group_7__0 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group_5__1__Impl + rule__ServiceClient__Group_7__0__Impl + rule__ServiceClient__Group_7__1 ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group_5__1__Impl +rule__ServiceClient__Group_7__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getResultAssignment_5_1()); } - (rule__ActionSpec__ResultAssignment_5_1) - { after(grammarAccess.getActionSpecAccess().getResultAssignment_5_1()); } + { before(grammarAccess.getServiceClientAccess().getQosKeyword_7_0()); } + Qos + { after(grammarAccess.getServiceClientAccess().getQosKeyword_7_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ActionSpec__Group_6__0 +rule__ServiceClient__Group_7__1 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group_6__0__Impl - rule__ActionSpec__Group_6__1 + rule__ServiceClient__Group_7__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group_6__0__Impl +rule__ServiceClient__Group_7__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getFeedbackKeyword_6_0()); } - 'feedback' - { after(grammarAccess.getActionSpecAccess().getFeedbackKeyword_6_0()); } + { before(grammarAccess.getServiceClientAccess().getQosAssignment_7_1()); } + (rule__ServiceClient__QosAssignment_7_1) + { after(grammarAccess.getServiceClientAccess().getQosAssignment_7_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group_6__1 + +rule__ActionServer__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ActionSpec__Group_6__1__Impl + rule__ActionServer__Group__0__Impl + rule__ActionServer__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__Group_6__1__Impl +rule__ActionServer__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getFeedbackAssignment_6_1()); } - (rule__ActionSpec__FeedbackAssignment_6_1) - { after(grammarAccess.getActionSpecAccess().getFeedbackAssignment_6_1()); } + { before(grammarAccess.getActionServerAccess().getActionServerAction_0()); } + () + { after(grammarAccess.getActionServerAccess().getActionServerAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__MessageDefinition__Group__0 +rule__ActionServer__Group__1 @init { int stackSize = keepStackSize(); } : - rule__MessageDefinition__Group__0__Impl - rule__MessageDefinition__Group__1 + rule__ActionServer__Group__1__Impl + rule__ActionServer__Group__2 ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__Group__0__Impl +rule__ActionServer__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); } - () - { after(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); } + { before(grammarAccess.getActionServerAccess().getNameAssignment_1()); } + (rule__ActionServer__NameAssignment_1) + { after(grammarAccess.getActionServerAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__Group__1 +rule__ActionServer__Group__2 @init { int stackSize = keepStackSize(); } : - rule__MessageDefinition__Group__1__Impl - rule__MessageDefinition__Group__2 + rule__ActionServer__Group__2__Impl + rule__ActionServer__Group__3 ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__Group__1__Impl +rule__ActionServer__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMessageDefinitionAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getMessageDefinitionAccess().getLeftCurlyBracketKeyword_1()); } + { before(grammarAccess.getActionServerAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getActionServerAccess().getColonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__Group__2 +rule__ActionServer__Group__3 @init { int stackSize = keepStackSize(); } : - rule__MessageDefinition__Group__2__Impl - rule__MessageDefinition__Group__3 + rule__ActionServer__Group__3__Impl + rule__ActionServer__Group__4 ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__Group__2__Impl +rule__ActionServer__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMessageDefinitionAccess().getGroup_2()); } - (rule__MessageDefinition__Group_2__0)? - { after(grammarAccess.getMessageDefinitionAccess().getGroup_2()); } + { before(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__Group__3 +rule__ActionServer__Group__4 @init { int stackSize = keepStackSize(); } : - rule__MessageDefinition__Group__3__Impl + rule__ActionServer__Group__4__Impl + rule__ActionServer__Group__5 ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__Group__3__Impl +rule__ActionServer__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMessageDefinitionAccess().getRightCurlyBracketKeyword_3()); } - '}' - { after(grammarAccess.getMessageDefinitionAccess().getRightCurlyBracketKeyword_3()); } + { before(grammarAccess.getActionServerAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getActionServerAccess().getTypeKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } - -rule__MessageDefinition__Group_2__0 +rule__ActionServer__Group__5 @init { int stackSize = keepStackSize(); } : - rule__MessageDefinition__Group_2__0__Impl - rule__MessageDefinition__Group_2__1 + rule__ActionServer__Group__5__Impl + rule__ActionServer__Group__6 ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__Group_2__0__Impl +rule__ActionServer__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_2_0()); } - (rule__MessageDefinition__MessagePartAssignment_2_0) - { after(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_2_0()); } + { before(grammarAccess.getActionServerAccess().getActionAssignment_5()); } + (rule__ActionServer__ActionAssignment_5) + { after(grammarAccess.getActionServerAccess().getActionAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__Group_2__1 +rule__ActionServer__Group__6 @init { int stackSize = keepStackSize(); } : - rule__MessageDefinition__Group_2__1__Impl + rule__ActionServer__Group__6__Impl + rule__ActionServer__Group__7 ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__Group_2__1__Impl +rule__ActionServer__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_2_1()); } - (rule__MessageDefinition__MessagePartAssignment_2_1)* - { after(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_2_1()); } + { before(grammarAccess.getActionServerAccess().getGroup_6()); } + (rule__ActionServer__Group_6__0)? + { after(grammarAccess.getActionServerAccess().getGroup_6()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Node__Group__0 +rule__ActionServer__Group__7 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__0__Impl - rule__Node__Group__1 + rule__ActionServer__Group__7__Impl + rule__ActionServer__Group__8 ; finally { restoreStackSize(stackSize); } -rule__Node__Group__0__Impl +rule__ActionServer__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getNodeKeyword_0()); } - 'Node' - { after(grammarAccess.getNodeAccess().getNodeKeyword_0()); } + { before(grammarAccess.getActionServerAccess().getGroup_7()); } + (rule__ActionServer__Group_7__0)? + { after(grammarAccess.getActionServerAccess().getGroup_7()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group__1 +rule__ActionServer__Group__8 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__1__Impl - rule__Node__Group__2 + rule__ActionServer__Group__8__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group__1__Impl +rule__ActionServer__Group__8__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_1()); } + { before(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_8()); } + RULE_END + { after(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_8()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group__2 + +rule__ActionServer__Group_6__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__2__Impl - rule__Node__Group__3 + rule__ActionServer__Group_6__0__Impl + rule__ActionServer__Group_6__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group__2__Impl +rule__ActionServer__Group_6__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getNameKeyword_2()); } - 'name' - { after(grammarAccess.getNodeAccess().getNameKeyword_2()); } + { before(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group__3 +rule__ActionServer__Group_6__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__3__Impl - rule__Node__Group__4 + rule__ActionServer__Group_6__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group__3__Impl +rule__ActionServer__Group_6__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getNameAssignment_3()); } - (rule__Node__NameAssignment_3) - { after(grammarAccess.getNodeAccess().getNameAssignment_3()); } + { before(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); } + (rule__ActionServer__NamespaceAssignment_6_1) + { after(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group__4 + +rule__ActionServer__Group_7__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__4__Impl - rule__Node__Group__5 + rule__ActionServer__Group_7__0__Impl + rule__ActionServer__Group_7__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group__4__Impl +rule__ActionServer__Group_7__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_4()); } - (rule__Node__Group_4__0)? - { after(grammarAccess.getNodeAccess().getGroup_4()); } + { before(grammarAccess.getActionServerAccess().getQosKeyword_7_0()); } + Qos + { after(grammarAccess.getActionServerAccess().getQosKeyword_7_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group__5 +rule__ActionServer__Group_7__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__5__Impl - rule__Node__Group__6 + rule__ActionServer__Group_7__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group__5__Impl +rule__ActionServer__Group_7__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_5()); } - (rule__Node__Group_5__0)? - { after(grammarAccess.getNodeAccess().getGroup_5()); } + { before(grammarAccess.getActionServerAccess().getQosAssignment_7_1()); } + (rule__ActionServer__QosAssignment_7_1) + { after(grammarAccess.getActionServerAccess().getQosAssignment_7_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group__6 + +rule__ActionClient__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__6__Impl - rule__Node__Group__7 + rule__ActionClient__Group__0__Impl + rule__ActionClient__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group__6__Impl +rule__ActionClient__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_6()); } - (rule__Node__Group_6__0)? - { after(grammarAccess.getNodeAccess().getGroup_6()); } + { before(grammarAccess.getActionClientAccess().getActionClientAction_0()); } + () + { after(grammarAccess.getActionClientAccess().getActionClientAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group__7 +rule__ActionClient__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__7__Impl - rule__Node__Group__8 + rule__ActionClient__Group__1__Impl + rule__ActionClient__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Node__Group__7__Impl +rule__ActionClient__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_7()); } - (rule__Node__Group_7__0)? - { after(grammarAccess.getNodeAccess().getGroup_7()); } + { before(grammarAccess.getActionClientAccess().getNameAssignment_1()); } + (rule__ActionClient__NameAssignment_1) + { after(grammarAccess.getActionClientAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group__8 +rule__ActionClient__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__8__Impl - rule__Node__Group__9 + rule__ActionClient__Group__2__Impl + rule__ActionClient__Group__3 ; finally { restoreStackSize(stackSize); } -rule__Node__Group__8__Impl +rule__ActionClient__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_8()); } - (rule__Node__Group_8__0)? - { after(grammarAccess.getNodeAccess().getGroup_8()); } + { before(grammarAccess.getActionClientAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getActionClientAccess().getColonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group__9 +rule__ActionClient__Group__3 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__9__Impl - rule__Node__Group__10 + rule__ActionClient__Group__3__Impl + rule__ActionClient__Group__4 ; finally { restoreStackSize(stackSize); } -rule__Node__Group__9__Impl +rule__ActionClient__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_9()); } - (rule__Node__Group_9__0)? - { after(grammarAccess.getNodeAccess().getGroup_9()); } + { before(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group__10 +rule__ActionClient__Group__4 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__10__Impl - rule__Node__Group__11 + rule__ActionClient__Group__4__Impl + rule__ActionClient__Group__5 ; finally { restoreStackSize(stackSize); } -rule__Node__Group__10__Impl +rule__ActionClient__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_10()); } - (rule__Node__Group_10__0)? - { after(grammarAccess.getNodeAccess().getGroup_10()); } + { before(grammarAccess.getActionClientAccess().getTypeKeyword_4()); } + Type_1 + { after(grammarAccess.getActionClientAccess().getTypeKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group__11 +rule__ActionClient__Group__5 @init { int stackSize = keepStackSize(); } : - rule__Node__Group__11__Impl + rule__ActionClient__Group__5__Impl + rule__ActionClient__Group__6 ; finally { restoreStackSize(stackSize); } -rule__Node__Group__11__Impl +rule__ActionClient__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_11()); } - '}' - { after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_11()); } + { before(grammarAccess.getActionClientAccess().getActionAssignment_5()); } + (rule__ActionClient__ActionAssignment_5) + { after(grammarAccess.getActionClientAccess().getActionAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Node__Group_4__0 +rule__ActionClient__Group__6 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_4__0__Impl - rule__Node__Group_4__1 + rule__ActionClient__Group__6__Impl + rule__ActionClient__Group__7 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4__0__Impl +rule__ActionClient__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getServiceServersKeyword_4_0()); } - 'ServiceServers' - { after(grammarAccess.getNodeAccess().getServiceServersKeyword_4_0()); } + { before(grammarAccess.getActionClientAccess().getGroup_6()); } + (rule__ActionClient__Group_6__0)? + { after(grammarAccess.getActionClientAccess().getGroup_6()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4__1 +rule__ActionClient__Group__7 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_4__1__Impl - rule__Node__Group_4__2 + rule__ActionClient__Group__7__Impl + rule__ActionClient__Group__8 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4__1__Impl +rule__ActionClient__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_4_1()); } - '{' - { after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_4_1()); } + { before(grammarAccess.getActionClientAccess().getGroup_7()); } + (rule__ActionClient__Group_7__0)? + { after(grammarAccess.getActionClientAccess().getGroup_7()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4__2 +rule__ActionClient__Group__8 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_4__2__Impl - rule__Node__Group_4__3 + rule__ActionClient__Group__8__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4__2__Impl +rule__ActionClient__Group__8__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getServiceserverAssignment_4_2()); } - (rule__Node__ServiceserverAssignment_4_2) - { after(grammarAccess.getNodeAccess().getServiceserverAssignment_4_2()); } + { before(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_8()); } + RULE_END + { after(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_8()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4__3 + +rule__ActionClient__Group_6__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_4__3__Impl - rule__Node__Group_4__4 + rule__ActionClient__Group_6__0__Impl + rule__ActionClient__Group_6__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4__3__Impl +rule__ActionClient__Group_6__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_4_3()); } - (rule__Node__Group_4_3__0)* - { after(grammarAccess.getNodeAccess().getGroup_4_3()); } + { before(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4__4 +rule__ActionClient__Group_6__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_4__4__Impl + rule__ActionClient__Group_6__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4__4__Impl +rule__ActionClient__Group_6__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_4_4()); } - '}' - { after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_4_4()); } + { before(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); } + (rule__ActionClient__NamespaceAssignment_6_1) + { after(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); } ) ; finally { @@ -6906,53 +6052,53 @@ finally { } -rule__Node__Group_4_3__0 +rule__ActionClient__Group_7__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_4_3__0__Impl - rule__Node__Group_4_3__1 + rule__ActionClient__Group_7__0__Impl + rule__ActionClient__Group_7__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4_3__0__Impl +rule__ActionClient__Group_7__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getCommaKeyword_4_3_0()); } - ',' - { after(grammarAccess.getNodeAccess().getCommaKeyword_4_3_0()); } + { before(grammarAccess.getActionClientAccess().getQosKeyword_7_0()); } + Qos + { after(grammarAccess.getActionClientAccess().getQosKeyword_7_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4_3__1 +rule__ActionClient__Group_7__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_4_3__1__Impl + rule__ActionClient__Group_7__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_4_3__1__Impl +rule__ActionClient__Group_7__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getServiceserverAssignment_4_3_1()); } - (rule__Node__ServiceserverAssignment_4_3_1) - { after(grammarAccess.getNodeAccess().getServiceserverAssignment_4_3_1()); } + { before(grammarAccess.getActionClientAccess().getQosAssignment_7_1()); } + (rule__ActionClient__QosAssignment_7_1) + { after(grammarAccess.getActionClientAccess().getQosAssignment_7_1()); } ) ; finally { @@ -6960,323 +6106,323 @@ finally { } -rule__Node__Group_5__0 +rule__Parameter__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_5__0__Impl - rule__Node__Group_5__1 + rule__Parameter__Group__0__Impl + rule__Parameter__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5__0__Impl +rule__Parameter__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getPublishersKeyword_5_0()); } - 'Publishers' - { after(grammarAccess.getNodeAccess().getPublishersKeyword_5_0()); } + { before(grammarAccess.getParameterAccess().getParameterAction_0()); } + () + { after(grammarAccess.getParameterAccess().getParameterAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5__1 +rule__Parameter__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_5__1__Impl - rule__Node__Group_5__2 + rule__Parameter__Group__1__Impl + rule__Parameter__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5__1__Impl +rule__Parameter__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_5_1()); } - '{' - { after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_5_1()); } + { before(grammarAccess.getParameterAccess().getNameAssignment_1()); } + (rule__Parameter__NameAssignment_1) + { after(grammarAccess.getParameterAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5__2 +rule__Parameter__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_5__2__Impl - rule__Node__Group_5__3 + rule__Parameter__Group__2__Impl + rule__Parameter__Group__3 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5__2__Impl +rule__Parameter__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getPublisherAssignment_5_2()); } - (rule__Node__PublisherAssignment_5_2) - { after(grammarAccess.getNodeAccess().getPublisherAssignment_5_2()); } + { before(grammarAccess.getParameterAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getParameterAccess().getColonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5__3 +rule__Parameter__Group__3 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_5__3__Impl - rule__Node__Group_5__4 + rule__Parameter__Group__3__Impl + rule__Parameter__Group__4 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5__3__Impl +rule__Parameter__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_5_3()); } - (rule__Node__Group_5_3__0)* - { after(grammarAccess.getNodeAccess().getGroup_5_3()); } + { before(grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5__4 +rule__Parameter__Group__4 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_5__4__Impl + rule__Parameter__Group__4__Impl + rule__Parameter__Group__5 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5__4__Impl +rule__Parameter__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_5_4()); } - '}' - { after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_5_4()); } + { before(grammarAccess.getParameterAccess().getTypeKeyword_4()); } + Type + { after(grammarAccess.getParameterAccess().getTypeKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Node__Group_5_3__0 +rule__Parameter__Group__5 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_5_3__0__Impl - rule__Node__Group_5_3__1 + rule__Parameter__Group__5__Impl + rule__Parameter__Group__6 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5_3__0__Impl +rule__Parameter__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getCommaKeyword_5_3_0()); } - ',' - { after(grammarAccess.getNodeAccess().getCommaKeyword_5_3_0()); } + { before(grammarAccess.getParameterAccess().getTypeAssignment_5()); } + (rule__Parameter__TypeAssignment_5) + { after(grammarAccess.getParameterAccess().getTypeAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5_3__1 +rule__Parameter__Group__6 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_5_3__1__Impl + rule__Parameter__Group__6__Impl + rule__Parameter__Group__7 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_5_3__1__Impl +rule__Parameter__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getPublisherAssignment_5_3_1()); } - (rule__Node__PublisherAssignment_5_3_1) - { after(grammarAccess.getNodeAccess().getPublisherAssignment_5_3_1()); } + { before(grammarAccess.getParameterAccess().getGroup_6()); } + (rule__Parameter__Group_6__0)? + { after(grammarAccess.getParameterAccess().getGroup_6()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Node__Group_6__0 +rule__Parameter__Group__7 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_6__0__Impl - rule__Node__Group_6__1 + rule__Parameter__Group__7__Impl + rule__Parameter__Group__8 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6__0__Impl +rule__Parameter__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getSubscribersKeyword_6_0()); } - 'Subscribers' - { after(grammarAccess.getNodeAccess().getSubscribersKeyword_6_0()); } + { before(grammarAccess.getParameterAccess().getGroup_7()); } + (rule__Parameter__Group_7__0)? + { after(grammarAccess.getParameterAccess().getGroup_7()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6__1 +rule__Parameter__Group__8 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_6__1__Impl - rule__Node__Group_6__2 + rule__Parameter__Group__8__Impl + rule__Parameter__Group__9 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6__1__Impl +rule__Parameter__Group__8__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_6_1()); } - '{' - { after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_6_1()); } + { before(grammarAccess.getParameterAccess().getENDTerminalRuleCall_8()); } + RULE_END + { after(grammarAccess.getParameterAccess().getENDTerminalRuleCall_8()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6__2 +rule__Parameter__Group__9 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_6__2__Impl - rule__Node__Group_6__3 + rule__Parameter__Group__9__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6__2__Impl +rule__Parameter__Group__9__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getSubscriberAssignment_6_2()); } - (rule__Node__SubscriberAssignment_6_2) - { after(grammarAccess.getNodeAccess().getSubscriberAssignment_6_2()); } + { before(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_9()); } + RightCurlyBracket + { after(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_9()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6__3 + +rule__Parameter__Group_6__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_6__3__Impl - rule__Node__Group_6__4 + rule__Parameter__Group_6__0__Impl + rule__Parameter__Group_6__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6__3__Impl +rule__Parameter__Group_6__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_6_3()); } - (rule__Node__Group_6_3__0)* - { after(grammarAccess.getNodeAccess().getGroup_6_3()); } + { before(grammarAccess.getParameterAccess().getNsKeyword_6_0()); } + Ns + { after(grammarAccess.getParameterAccess().getNsKeyword_6_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6__4 +rule__Parameter__Group_6__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_6__4__Impl + rule__Parameter__Group_6__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6__4__Impl +rule__Parameter__Group_6__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_6_4()); } - '}' - { after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_6_4()); } + { before(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); } + (rule__Parameter__NamespaceAssignment_6_1) + { after(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); } ) ; finally { @@ -7284,53 +6430,53 @@ finally { } -rule__Node__Group_6_3__0 +rule__Parameter__Group_7__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_6_3__0__Impl - rule__Node__Group_6_3__1 + rule__Parameter__Group_7__0__Impl + rule__Parameter__Group_7__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6_3__0__Impl +rule__Parameter__Group_7__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getCommaKeyword_6_3_0()); } - ',' - { after(grammarAccess.getNodeAccess().getCommaKeyword_6_3_0()); } + { before(grammarAccess.getParameterAccess().getQosKeyword_7_0()); } + Qos + { after(grammarAccess.getParameterAccess().getQosKeyword_7_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6_3__1 +rule__Parameter__Group_7__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_6_3__1__Impl + rule__Parameter__Group_7__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_6_3__1__Impl +rule__Parameter__Group_7__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getSubscriberAssignment_6_3_1()); } - (rule__Node__SubscriberAssignment_6_3_1) - { after(grammarAccess.getNodeAccess().getSubscriberAssignment_6_3_1()); } + { before(grammarAccess.getParameterAccess().getQosAssignment_7_1()); } + (rule__Parameter__QosAssignment_7_1) + { after(grammarAccess.getParameterAccess().getQosAssignment_7_1()); } ) ; finally { @@ -7338,377 +6484,377 @@ finally { } -rule__Node__Group_7__0 +rule__Package_Impl__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_7__0__Impl - rule__Node__Group_7__1 + rule__Package_Impl__Group__0__Impl + rule__Package_Impl__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7__0__Impl +rule__Package_Impl__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getServiceClientsKeyword_7_0()); } - 'ServiceClients' - { after(grammarAccess.getNodeAccess().getServiceClientsKeyword_7_0()); } + { before(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); } + () + { after(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7__1 +rule__Package_Impl__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_7__1__Impl - rule__Node__Group_7__2 + rule__Package_Impl__Group__1__Impl + rule__Package_Impl__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7__1__Impl +rule__Package_Impl__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_7_1()); } - '{' - { after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_7_1()); } + { before(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); } + (rule__Package_Impl__NameAssignment_1) + { after(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7__2 +rule__Package_Impl__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_7__2__Impl - rule__Node__Group_7__3 + rule__Package_Impl__Group__2__Impl + rule__Package_Impl__Group__3 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7__2__Impl +rule__Package_Impl__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getServiceclientAssignment_7_2()); } - (rule__Node__ServiceclientAssignment_7_2) - { after(grammarAccess.getNodeAccess().getServiceclientAssignment_7_2()); } + { before(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7__3 +rule__Package_Impl__Group__3 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_7__3__Impl - rule__Node__Group_7__4 + rule__Package_Impl__Group__3__Impl + rule__Package_Impl__Group__4 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7__3__Impl +rule__Package_Impl__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_7_3()); } - (rule__Node__Group_7_3__0)* - { after(grammarAccess.getNodeAccess().getGroup_7_3()); } + { before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7__4 +rule__Package_Impl__Group__4 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_7__4__Impl + rule__Package_Impl__Group__4__Impl + rule__Package_Impl__Group__5 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7__4__Impl +rule__Package_Impl__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_7_4()); } - '}' - { after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_7_4()); } + { before(grammarAccess.getPackage_ImplAccess().getGroup_4()); } + (rule__Package_Impl__Group_4__0)? + { after(grammarAccess.getPackage_ImplAccess().getGroup_4()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Node__Group_7_3__0 +rule__Package_Impl__Group__5 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_7_3__0__Impl - rule__Node__Group_7_3__1 + rule__Package_Impl__Group__5__Impl + rule__Package_Impl__Group__6 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7_3__0__Impl +rule__Package_Impl__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getCommaKeyword_7_3_0()); } - ',' - { after(grammarAccess.getNodeAccess().getCommaKeyword_7_3_0()); } + { before(grammarAccess.getPackage_ImplAccess().getGroup_5()); } + (rule__Package_Impl__Group_5__0)? + { after(grammarAccess.getPackage_ImplAccess().getGroup_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7_3__1 +rule__Package_Impl__Group__6 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_7_3__1__Impl + rule__Package_Impl__Group__6__Impl + rule__Package_Impl__Group__7 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_7_3__1__Impl +rule__Package_Impl__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getServiceclientAssignment_7_3_1()); } - (rule__Node__ServiceclientAssignment_7_3_1) - { after(grammarAccess.getNodeAccess().getServiceclientAssignment_7_3_1()); } + { before(grammarAccess.getPackage_ImplAccess().getGroup_6()); } + (rule__Package_Impl__Group_6__0)? + { after(grammarAccess.getPackage_ImplAccess().getGroup_6()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Node__Group_8__0 +rule__Package_Impl__Group__7 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_8__0__Impl - rule__Node__Group_8__1 + rule__Package_Impl__Group__7__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8__0__Impl +rule__Package_Impl__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getActionServersKeyword_8_0()); } - 'ActionServers' - { after(grammarAccess.getNodeAccess().getActionServersKeyword_8_0()); } + { before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8__1 + +rule__Package_Impl__Group_4__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_8__1__Impl - rule__Node__Group_8__2 + rule__Package_Impl__Group_4__0__Impl + rule__Package_Impl__Group_4__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8__1__Impl +rule__Package_Impl__Group_4__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_8_1()); } - '{' - { after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_8_1()); } + { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); } + FromGitRepo + { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8__2 +rule__Package_Impl__Group_4__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_8__2__Impl - rule__Node__Group_8__3 + rule__Package_Impl__Group_4__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8__2__Impl +rule__Package_Impl__Group_4__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getActionserverAssignment_8_2()); } - (rule__Node__ActionserverAssignment_8_2) - { after(grammarAccess.getNodeAccess().getActionserverAssignment_8_2()); } + { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); } + (rule__Package_Impl__FromGitRepoAssignment_4_1) + { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8__3 + +rule__Package_Impl__Group_5__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_8__3__Impl - rule__Node__Group_8__4 + rule__Package_Impl__Group_5__0__Impl + rule__Package_Impl__Group_5__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8__3__Impl +rule__Package_Impl__Group_5__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_8_3()); } - (rule__Node__Group_8_3__0)* - { after(grammarAccess.getNodeAccess().getGroup_8_3()); } + { before(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); } + Specs + { after(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8__4 +rule__Package_Impl__Group_5__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_8__4__Impl + rule__Package_Impl__Group_5__1__Impl + rule__Package_Impl__Group_5__2 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8__4__Impl +rule__Package_Impl__Group_5__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_8_4()); } - '}' - { after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_8_4()); } + { before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); } + RULE_BEGIN + { after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Node__Group_8_3__0 +rule__Package_Impl__Group_5__2 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_8_3__0__Impl - rule__Node__Group_8_3__1 + rule__Package_Impl__Group_5__2__Impl + rule__Package_Impl__Group_5__3 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8_3__0__Impl +rule__Package_Impl__Group_5__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getCommaKeyword_8_3_0()); } - ',' - { after(grammarAccess.getNodeAccess().getCommaKeyword_8_3_0()); } + { before(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); } + (rule__Package_Impl__SpecAssignment_5_2)* + { after(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8_3__1 +rule__Package_Impl__Group_5__3 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_8_3__1__Impl + rule__Package_Impl__Group_5__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_8_3__1__Impl +rule__Package_Impl__Group_5__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getActionserverAssignment_8_3_1()); } - (rule__Node__ActionserverAssignment_8_3_1) - { after(grammarAccess.getNodeAccess().getActionserverAssignment_8_3_1()); } + { before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); } + RULE_END + { after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); } ) ; finally { @@ -7716,134 +6862,134 @@ finally { } -rule__Node__Group_9__0 +rule__Package_Impl__Group_6__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_9__0__Impl - rule__Node__Group_9__1 + rule__Package_Impl__Group_6__0__Impl + rule__Package_Impl__Group_6__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9__0__Impl +rule__Package_Impl__Group_6__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getActionClientsKeyword_9_0()); } - 'ActionClients' - { after(grammarAccess.getNodeAccess().getActionClientsKeyword_9_0()); } + { before(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); } + Dependencies + { after(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9__1 +rule__Package_Impl__Group_6__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_9__1__Impl - rule__Node__Group_9__2 + rule__Package_Impl__Group_6__1__Impl + rule__Package_Impl__Group_6__2 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9__1__Impl +rule__Package_Impl__Group_6__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_9_1()); } - '{' - { after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_9_1()); } + { before(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); } + LeftSquareBracket + { after(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9__2 +rule__Package_Impl__Group_6__2 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_9__2__Impl - rule__Node__Group_9__3 + rule__Package_Impl__Group_6__2__Impl + rule__Package_Impl__Group_6__3 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9__2__Impl +rule__Package_Impl__Group_6__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getActionclientAssignment_9_2()); } - (rule__Node__ActionclientAssignment_9_2) - { after(grammarAccess.getNodeAccess().getActionclientAssignment_9_2()); } + { before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); } + (rule__Package_Impl__DependencyAssignment_6_2) + { after(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9__3 +rule__Package_Impl__Group_6__3 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_9__3__Impl - rule__Node__Group_9__4 + rule__Package_Impl__Group_6__3__Impl + rule__Package_Impl__Group_6__4 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9__3__Impl +rule__Package_Impl__Group_6__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_9_3()); } - (rule__Node__Group_9_3__0)* - { after(grammarAccess.getNodeAccess().getGroup_9_3()); } + { before(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); } + (rule__Package_Impl__Group_6_3__0)* + { after(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9__4 +rule__Package_Impl__Group_6__4 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_9__4__Impl + rule__Package_Impl__Group_6__4__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9__4__Impl +rule__Package_Impl__Group_6__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_9_4()); } - '}' - { after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_9_4()); } + { before(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); } + RightSquareBracket + { after(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); } ) ; finally { @@ -7851,53 +6997,53 @@ finally { } -rule__Node__Group_9_3__0 +rule__Package_Impl__Group_6_3__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_9_3__0__Impl - rule__Node__Group_9_3__1 + rule__Package_Impl__Group_6_3__0__Impl + rule__Package_Impl__Group_6_3__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9_3__0__Impl +rule__Package_Impl__Group_6_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getCommaKeyword_9_3_0()); } - ',' - { after(grammarAccess.getNodeAccess().getCommaKeyword_9_3_0()); } + { before(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); } + Comma + { after(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9_3__1 +rule__Package_Impl__Group_6_3__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_9_3__1__Impl + rule__Package_Impl__Group_6_3__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_9_3__1__Impl +rule__Package_Impl__Group_6_3__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getActionclientAssignment_9_3_1()); } - (rule__Node__ActionclientAssignment_9_3_1) - { after(grammarAccess.getNodeAccess().getActionclientAssignment_9_3_1()); } + { before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1()); } + (rule__Package_Impl__DependencyAssignment_6_3_1) + { after(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1()); } ) ; finally { @@ -7905,404 +7051,404 @@ finally { } -rule__Node__Group_10__0 +rule__Artifact__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_10__0__Impl - rule__Node__Group_10__1 + rule__Artifact__Group__0__Impl + rule__Artifact__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10__0__Impl +rule__Artifact__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getParametersKeyword_10_0()); } - 'Parameters' - { after(grammarAccess.getNodeAccess().getParametersKeyword_10_0()); } + { before(grammarAccess.getArtifactAccess().getArtifactAction_0()); } + () + { after(grammarAccess.getArtifactAccess().getArtifactAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10__1 +rule__Artifact__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_10__1__Impl - rule__Node__Group_10__2 + rule__Artifact__Group__1__Impl + rule__Artifact__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10__1__Impl +rule__Artifact__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_10_1()); } - '{' - { after(grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_10_1()); } + { before(grammarAccess.getArtifactAccess().getNameAssignment_1()); } + (rule__Artifact__NameAssignment_1) + { after(grammarAccess.getArtifactAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10__2 +rule__Artifact__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_10__2__Impl - rule__Node__Group_10__3 + rule__Artifact__Group__2__Impl + rule__Artifact__Group__3 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10__2__Impl +rule__Artifact__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getParameterAssignment_10_2()); } - (rule__Node__ParameterAssignment_10_2) - { after(grammarAccess.getNodeAccess().getParameterAssignment_10_2()); } + { before(grammarAccess.getArtifactAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getArtifactAccess().getColonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10__3 +rule__Artifact__Group__3 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_10__3__Impl - rule__Node__Group_10__4 + rule__Artifact__Group__3__Impl + rule__Artifact__Group__4 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10__3__Impl +rule__Artifact__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getGroup_10_3()); } - (rule__Node__Group_10_3__0)* - { after(grammarAccess.getNodeAccess().getGroup_10_3()); } + { before(grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10__4 +rule__Artifact__Group__4 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_10__4__Impl + rule__Artifact__Group__4__Impl + rule__Artifact__Group__5 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10__4__Impl +rule__Artifact__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_10_4()); } - '}' - { after(grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_10_4()); } + { before(grammarAccess.getArtifactAccess().getNodeAssignment_4()); } + (rule__Artifact__NodeAssignment_4)? + { after(grammarAccess.getArtifactAccess().getNodeAssignment_4()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Node__Group_10_3__0 +rule__Artifact__Group__5 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_10_3__0__Impl - rule__Node__Group_10_3__1 + rule__Artifact__Group__5__Impl ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10_3__0__Impl +rule__Artifact__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getCommaKeyword_10_3_0()); } - ',' - { after(grammarAccess.getNodeAccess().getCommaKeyword_10_3_0()); } + { before(grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); } + RULE_END + { after(grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10_3__1 + +rule__Node__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Node__Group_10_3__1__Impl + rule__Node__Group__0__Impl + rule__Node__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Node__Group_10_3__1__Impl +rule__Node__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getParameterAssignment_10_3_1()); } - (rule__Node__ParameterAssignment_10_3_1) - { after(grammarAccess.getNodeAccess().getParameterAssignment_10_3_1()); } + { before(grammarAccess.getNodeAccess().getNodeKeyword_0()); } + Node_1 + { after(grammarAccess.getNodeAccess().getNodeKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ServiceServer__Group__0 +rule__Node__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ServiceServer__Group__0__Impl - rule__ServiceServer__Group__1 + rule__Node__Group__1__Impl + rule__Node__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__0__Impl +rule__Node__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getServiceServerKeyword_0()); } - 'ServiceServer' - { after(grammarAccess.getServiceServerAccess().getServiceServerKeyword_0()); } + { before(grammarAccess.getNodeAccess().getNameAssignment_1()); } + (rule__Node__NameAssignment_1) + { after(grammarAccess.getNodeAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__1 +rule__Node__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ServiceServer__Group__1__Impl - rule__ServiceServer__Group__2 + rule__Node__Group__2__Impl + rule__Node__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__1__Impl +rule__Node__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getServiceServerAccess().getLeftCurlyBracketKeyword_1()); } + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__2 +rule__Node__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ServiceServer__Group__2__Impl - rule__ServiceServer__Group__3 + rule__Node__Group__3__Impl + rule__Node__Group__4 ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__2__Impl +rule__Node__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getNameKeyword_2()); } - 'name' - { after(grammarAccess.getServiceServerAccess().getNameKeyword_2()); } + { before(grammarAccess.getNodeAccess().getAlternatives_3()); } + (rule__Node__Alternatives_3)* + { after(grammarAccess.getNodeAccess().getAlternatives_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__3 +rule__Node__Group__4 @init { int stackSize = keepStackSize(); } : - rule__ServiceServer__Group__3__Impl - rule__ServiceServer__Group__4 + rule__Node__Group__4__Impl ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__3__Impl +rule__Node__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getNameAssignment_3()); } - (rule__ServiceServer__NameAssignment_3) - { after(grammarAccess.getServiceServerAccess().getNameAssignment_3()); } + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__4 + +rule__Node__Group_3_0__0 @init { int stackSize = keepStackSize(); } : - rule__ServiceServer__Group__4__Impl - rule__ServiceServer__Group__5 + rule__Node__Group_3_0__0__Impl + rule__Node__Group_3_0__1 ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__4__Impl +rule__Node__Group_3_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getServiceKeyword_4()); } - 'service' - { after(grammarAccess.getServiceServerAccess().getServiceKeyword_4()); } + { before(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); } + Publishers + { after(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__5 +rule__Node__Group_3_0__1 @init { int stackSize = keepStackSize(); } : - rule__ServiceServer__Group__5__Impl - rule__ServiceServer__Group__6 + rule__Node__Group_3_0__1__Impl + rule__Node__Group_3_0__2 ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__5__Impl +rule__Node__Group_3_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); } - (rule__ServiceServer__ServiceAssignment_5) - { after(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); } + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__6 +rule__Node__Group_3_0__2 @init { int stackSize = keepStackSize(); } : - rule__ServiceServer__Group__6__Impl - rule__ServiceServer__Group__7 + rule__Node__Group_3_0__2__Impl + rule__Node__Group_3_0__3 ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__6__Impl +rule__Node__Group_3_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getGroup_6()); } - (rule__ServiceServer__Group_6__0)? - { after(grammarAccess.getServiceServerAccess().getGroup_6()); } + { before(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); } + (rule__Node__PublisherAssignment_3_0_2)* + { after(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__7 +rule__Node__Group_3_0__3 @init { int stackSize = keepStackSize(); } : - rule__ServiceServer__Group__7__Impl + rule__Node__Group_3_0__3__Impl ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group__7__Impl +rule__Node__Group_3_0__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getServiceServerAccess().getRightCurlyBracketKeyword_7()); } + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); } ) ; finally { @@ -8310,323 +7456,323 @@ finally { } -rule__ServiceServer__Group_6__0 +rule__Node__Group_3_1__0 @init { int stackSize = keepStackSize(); } : - rule__ServiceServer__Group_6__0__Impl - rule__ServiceServer__Group_6__1 + rule__Node__Group_3_1__0__Impl + rule__Node__Group_3_1__1 ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group_6__0__Impl +rule__Node__Group_3_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getNamespaceKeyword_6_0()); } - 'namespace' - { after(grammarAccess.getServiceServerAccess().getNamespaceKeyword_6_0()); } + { before(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); } + Subscribers + { after(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group_6__1 +rule__Node__Group_3_1__1 @init { int stackSize = keepStackSize(); } : - rule__ServiceServer__Group_6__1__Impl + rule__Node__Group_3_1__1__Impl + rule__Node__Group_3_1__2 ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__Group_6__1__Impl +rule__Node__Group_3_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); } - (rule__ServiceServer__NamespaceAssignment_6_1) - { after(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); } + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Publisher__Group__0 +rule__Node__Group_3_1__2 @init { int stackSize = keepStackSize(); } : - rule__Publisher__Group__0__Impl - rule__Publisher__Group__1 + rule__Node__Group_3_1__2__Impl + rule__Node__Group_3_1__3 ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__0__Impl +rule__Node__Group_3_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getPublisherKeyword_0()); } - 'Publisher' - { after(grammarAccess.getPublisherAccess().getPublisherKeyword_0()); } + { before(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); } + (rule__Node__SubscriberAssignment_3_1_2)* + { after(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__1 +rule__Node__Group_3_1__3 @init { int stackSize = keepStackSize(); } : - rule__Publisher__Group__1__Impl - rule__Publisher__Group__2 + rule__Node__Group_3_1__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__1__Impl +rule__Node__Group_3_1__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getPublisherAccess().getLeftCurlyBracketKeyword_1()); } + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__2 + +rule__Node__Group_3_2__0 @init { int stackSize = keepStackSize(); } : - rule__Publisher__Group__2__Impl - rule__Publisher__Group__3 + rule__Node__Group_3_2__0__Impl + rule__Node__Group_3_2__1 ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__2__Impl +rule__Node__Group_3_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getNameKeyword_2()); } - 'name' - { after(grammarAccess.getPublisherAccess().getNameKeyword_2()); } + { before(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); } + Serviceserver + { after(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__3 +rule__Node__Group_3_2__1 @init { int stackSize = keepStackSize(); } : - rule__Publisher__Group__3__Impl - rule__Publisher__Group__4 + rule__Node__Group_3_2__1__Impl + rule__Node__Group_3_2__2 ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__3__Impl +rule__Node__Group_3_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getNameAssignment_3()); } - (rule__Publisher__NameAssignment_3) - { after(grammarAccess.getPublisherAccess().getNameAssignment_3()); } + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__4 +rule__Node__Group_3_2__2 @init { int stackSize = keepStackSize(); } : - rule__Publisher__Group__4__Impl - rule__Publisher__Group__5 + rule__Node__Group_3_2__2__Impl + rule__Node__Group_3_2__3 ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__4__Impl +rule__Node__Group_3_2__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getMessageKeyword_4()); } - 'message' - { after(grammarAccess.getPublisherAccess().getMessageKeyword_4()); } + { before(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); } + (rule__Node__ServiceserverAssignment_3_2_2)* + { after(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__5 +rule__Node__Group_3_2__3 @init { int stackSize = keepStackSize(); } : - rule__Publisher__Group__5__Impl - rule__Publisher__Group__6 + rule__Node__Group_3_2__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__5__Impl +rule__Node__Group_3_2__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getMessageAssignment_5()); } - (rule__Publisher__MessageAssignment_5) - { after(grammarAccess.getPublisherAccess().getMessageAssignment_5()); } + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__6 + +rule__Node__Group_3_3__0 @init { int stackSize = keepStackSize(); } : - rule__Publisher__Group__6__Impl - rule__Publisher__Group__7 + rule__Node__Group_3_3__0__Impl + rule__Node__Group_3_3__1 ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__6__Impl +rule__Node__Group_3_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getGroup_6()); } - (rule__Publisher__Group_6__0)? - { after(grammarAccess.getPublisherAccess().getGroup_6()); } + { before(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); } + Serviceclient + { after(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__7 +rule__Node__Group_3_3__1 @init { int stackSize = keepStackSize(); } : - rule__Publisher__Group__7__Impl + rule__Node__Group_3_3__1__Impl + rule__Node__Group_3_3__2 ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group__7__Impl +rule__Node__Group_3_3__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getPublisherAccess().getRightCurlyBracketKeyword_7()); } + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Publisher__Group_6__0 +rule__Node__Group_3_3__2 @init { int stackSize = keepStackSize(); } : - rule__Publisher__Group_6__0__Impl - rule__Publisher__Group_6__1 + rule__Node__Group_3_3__2__Impl + rule__Node__Group_3_3__3 ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group_6__0__Impl +rule__Node__Group_3_3__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getNamespaceKeyword_6_0()); } - 'namespace' - { after(grammarAccess.getPublisherAccess().getNamespaceKeyword_6_0()); } + { before(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); } + (rule__Node__ServiceclientAssignment_3_3_2)* + { after(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group_6__1 +rule__Node__Group_3_3__3 @init { int stackSize = keepStackSize(); } : - rule__Publisher__Group_6__1__Impl + rule__Node__Group_3_3__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Publisher__Group_6__1__Impl +rule__Node__Group_3_3__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); } - (rule__Publisher__NamespaceAssignment_6_1) - { after(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); } + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); } ) ; finally { @@ -8634,215 +7780,215 @@ finally { } -rule__Subscriber__Group__0 +rule__Node__Group_3_4__0 @init { int stackSize = keepStackSize(); } : - rule__Subscriber__Group__0__Impl - rule__Subscriber__Group__1 + rule__Node__Group_3_4__0__Impl + rule__Node__Group_3_4__1 ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__0__Impl +rule__Node__Group_3_4__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getSubscriberKeyword_0()); } - 'Subscriber' - { after(grammarAccess.getSubscriberAccess().getSubscriberKeyword_0()); } + { before(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); } + Actionserver + { after(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__1 +rule__Node__Group_3_4__1 @init { int stackSize = keepStackSize(); } : - rule__Subscriber__Group__1__Impl - rule__Subscriber__Group__2 + rule__Node__Group_3_4__1__Impl + rule__Node__Group_3_4__2 ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__1__Impl +rule__Node__Group_3_4__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getSubscriberAccess().getLeftCurlyBracketKeyword_1()); } + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__2 +rule__Node__Group_3_4__2 @init { int stackSize = keepStackSize(); } : - rule__Subscriber__Group__2__Impl - rule__Subscriber__Group__3 + rule__Node__Group_3_4__2__Impl + rule__Node__Group_3_4__3 ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__2__Impl +rule__Node__Group_3_4__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getNameKeyword_2()); } - 'name' - { after(grammarAccess.getSubscriberAccess().getNameKeyword_2()); } + { before(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); } + (rule__Node__ActionserverAssignment_3_4_2)* + { after(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__3 +rule__Node__Group_3_4__3 @init { int stackSize = keepStackSize(); } : - rule__Subscriber__Group__3__Impl - rule__Subscriber__Group__4 + rule__Node__Group_3_4__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__3__Impl +rule__Node__Group_3_4__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getNameAssignment_3()); } - (rule__Subscriber__NameAssignment_3) - { after(grammarAccess.getSubscriberAccess().getNameAssignment_3()); } + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__4 + +rule__Node__Group_3_5__0 @init { int stackSize = keepStackSize(); } : - rule__Subscriber__Group__4__Impl - rule__Subscriber__Group__5 + rule__Node__Group_3_5__0__Impl + rule__Node__Group_3_5__1 ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__4__Impl +rule__Node__Group_3_5__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getMessageKeyword_4()); } - 'message' - { after(grammarAccess.getSubscriberAccess().getMessageKeyword_4()); } + { before(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); } + Actionclient + { after(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__5 +rule__Node__Group_3_5__1 @init { int stackSize = keepStackSize(); } : - rule__Subscriber__Group__5__Impl - rule__Subscriber__Group__6 + rule__Node__Group_3_5__1__Impl + rule__Node__Group_3_5__2 ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__5__Impl +rule__Node__Group_3_5__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); } - (rule__Subscriber__MessageAssignment_5) - { after(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); } + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__6 +rule__Node__Group_3_5__2 @init { int stackSize = keepStackSize(); } : - rule__Subscriber__Group__6__Impl - rule__Subscriber__Group__7 + rule__Node__Group_3_5__2__Impl + rule__Node__Group_3_5__3 ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__6__Impl +rule__Node__Group_3_5__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getGroup_6()); } - (rule__Subscriber__Group_6__0)? - { after(grammarAccess.getSubscriberAccess().getGroup_6()); } + { before(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); } + (rule__Node__ActionclientAssignment_3_5_2)* + { after(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__7 +rule__Node__Group_3_5__3 @init { int stackSize = keepStackSize(); } : - rule__Subscriber__Group__7__Impl + rule__Node__Group_3_5__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group__7__Impl +rule__Node__Group_3_5__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getSubscriberAccess().getRightCurlyBracketKeyword_7()); } + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); } ) ; finally { @@ -8850,1079 +7996,1079 @@ finally { } -rule__Subscriber__Group_6__0 +rule__Node__Group_3_6__0 @init { int stackSize = keepStackSize(); } : - rule__Subscriber__Group_6__0__Impl - rule__Subscriber__Group_6__1 + rule__Node__Group_3_6__0__Impl + rule__Node__Group_3_6__1 ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group_6__0__Impl +rule__Node__Group_3_6__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getNamespaceKeyword_6_0()); } - 'namespace' - { after(grammarAccess.getSubscriberAccess().getNamespaceKeyword_6_0()); } + { before(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); } + Parameters + { after(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group_6__1 +rule__Node__Group_3_6__1 @init { int stackSize = keepStackSize(); } : - rule__Subscriber__Group_6__1__Impl + rule__Node__Group_3_6__1__Impl + rule__Node__Group_3_6__2 ; finally { restoreStackSize(stackSize); } -rule__Subscriber__Group_6__1__Impl +rule__Node__Group_3_6__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); } - (rule__Subscriber__NamespaceAssignment_6_1) - { after(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); } + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ServiceClient__Group__0 +rule__Node__Group_3_6__2 @init { int stackSize = keepStackSize(); } : - rule__ServiceClient__Group__0__Impl - rule__ServiceClient__Group__1 + rule__Node__Group_3_6__2__Impl + rule__Node__Group_3_6__3 ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__0__Impl +rule__Node__Group_3_6__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getServiceClientKeyword_0()); } - 'ServiceClient' - { after(grammarAccess.getServiceClientAccess().getServiceClientKeyword_0()); } + { before(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); } + (rule__Node__ParameterAssignment_3_6_2)* + { after(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__1 +rule__Node__Group_3_6__3 @init { int stackSize = keepStackSize(); } : - rule__ServiceClient__Group__1__Impl - rule__ServiceClient__Group__2 + rule__Node__Group_3_6__3__Impl ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__1__Impl +rule__Node__Group_3_6__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getServiceClientAccess().getLeftCurlyBracketKeyword_1()); } + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__2 + +rule__TopicSpec__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ServiceClient__Group__2__Impl - rule__ServiceClient__Group__3 + rule__TopicSpec__Group__0__Impl + rule__TopicSpec__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__2__Impl +rule__TopicSpec__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getNameKeyword_2()); } - 'name' - { after(grammarAccess.getServiceClientAccess().getNameKeyword_2()); } + { before(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); } + () + { after(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__3 +rule__TopicSpec__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ServiceClient__Group__3__Impl - rule__ServiceClient__Group__4 + rule__TopicSpec__Group__1__Impl + rule__TopicSpec__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__3__Impl +rule__TopicSpec__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getNameAssignment_3()); } - (rule__ServiceClient__NameAssignment_3) - { after(grammarAccess.getServiceClientAccess().getNameAssignment_3()); } + { before(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); } + Msg + { after(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__4 +rule__TopicSpec__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ServiceClient__Group__4__Impl - rule__ServiceClient__Group__5 + rule__TopicSpec__Group__2__Impl + rule__TopicSpec__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__4__Impl +rule__TopicSpec__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getServiceKeyword_4()); } - 'service' - { after(grammarAccess.getServiceClientAccess().getServiceKeyword_4()); } + { before(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); } + (rule__TopicSpec__NameAssignment_2) + { after(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__5 +rule__TopicSpec__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ServiceClient__Group__5__Impl - rule__ServiceClient__Group__6 + rule__TopicSpec__Group__3__Impl + rule__TopicSpec__Group__4 ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__5__Impl +rule__TopicSpec__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); } - (rule__ServiceClient__ServiceAssignment_5) - { after(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); } + { before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__6 +rule__TopicSpec__Group__4 @init { int stackSize = keepStackSize(); } : - rule__ServiceClient__Group__6__Impl - rule__ServiceClient__Group__7 + rule__TopicSpec__Group__4__Impl + rule__TopicSpec__Group__5 ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__6__Impl +rule__TopicSpec__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getGroup_6()); } - (rule__ServiceClient__Group_6__0)? - { after(grammarAccess.getServiceClientAccess().getGroup_6()); } + { before(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); } + Message_1 + { after(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__7 +rule__TopicSpec__Group__5 @init { int stackSize = keepStackSize(); } : - rule__ServiceClient__Group__7__Impl + rule__TopicSpec__Group__5__Impl + rule__TopicSpec__Group__6 ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group__7__Impl +rule__TopicSpec__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getServiceClientAccess().getRightCurlyBracketKeyword_7()); } + { before(grammarAccess.getTopicSpecAccess().getGroup_5()); } + (rule__TopicSpec__Group_5__0)? + { after(grammarAccess.getTopicSpecAccess().getGroup_5()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ServiceClient__Group_6__0 +rule__TopicSpec__Group__6 @init { int stackSize = keepStackSize(); } : - rule__ServiceClient__Group_6__0__Impl - rule__ServiceClient__Group_6__1 + rule__TopicSpec__Group__6__Impl ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group_6__0__Impl +rule__TopicSpec__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getNamespaceKeyword_6_0()); } - 'namespace' - { after(grammarAccess.getServiceClientAccess().getNamespaceKeyword_6_0()); } + { before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); } + RULE_END + { after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group_6__1 + +rule__TopicSpec__Group_5__0 @init { int stackSize = keepStackSize(); } : - rule__ServiceClient__Group_6__1__Impl + rule__TopicSpec__Group_5__0__Impl + rule__TopicSpec__Group_5__1 ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__Group_6__1__Impl +rule__TopicSpec__Group_5__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); } - (rule__ServiceClient__NamespaceAssignment_6_1) - { after(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); } + { before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); } + RULE_BEGIN + { after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ActionServer__Group__0 +rule__TopicSpec__Group_5__1 @init { int stackSize = keepStackSize(); } : - rule__ActionServer__Group__0__Impl - rule__ActionServer__Group__1 + rule__TopicSpec__Group_5__1__Impl + rule__TopicSpec__Group_5__2 ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__0__Impl +rule__TopicSpec__Group_5__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getActionServerKeyword_0()); } - 'ActionServer' - { after(grammarAccess.getActionServerAccess().getActionServerKeyword_0()); } + { before(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); } + (rule__TopicSpec__MessageAssignment_5_1) + { after(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__1 +rule__TopicSpec__Group_5__2 @init { int stackSize = keepStackSize(); } : - rule__ActionServer__Group__1__Impl - rule__ActionServer__Group__2 + rule__TopicSpec__Group_5__2__Impl ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__1__Impl +rule__TopicSpec__Group_5__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getActionServerAccess().getLeftCurlyBracketKeyword_1()); } + { before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); } + RULE_END + { after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__2 + +rule__ServiceSpec__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ActionServer__Group__2__Impl - rule__ActionServer__Group__3 + rule__ServiceSpec__Group__0__Impl + rule__ServiceSpec__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__2__Impl +rule__ServiceSpec__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getNameKeyword_2()); } - 'name' - { after(grammarAccess.getActionServerAccess().getNameKeyword_2()); } + { before(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); } + () + { after(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__3 +rule__ServiceSpec__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ActionServer__Group__3__Impl - rule__ActionServer__Group__4 + rule__ServiceSpec__Group__1__Impl + rule__ServiceSpec__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__3__Impl +rule__ServiceSpec__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getNameAssignment_3()); } - (rule__ActionServer__NameAssignment_3) - { after(grammarAccess.getActionServerAccess().getNameAssignment_3()); } + { before(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); } + Srv + { after(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__4 +rule__ServiceSpec__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ActionServer__Group__4__Impl - rule__ActionServer__Group__5 + rule__ServiceSpec__Group__2__Impl + rule__ServiceSpec__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__4__Impl +rule__ServiceSpec__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getActionKeyword_4()); } - 'action' - { after(grammarAccess.getActionServerAccess().getActionKeyword_4()); } + { before(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); } + (rule__ServiceSpec__NameAssignment_2) + { after(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__5 +rule__ServiceSpec__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ActionServer__Group__5__Impl - rule__ActionServer__Group__6 + rule__ServiceSpec__Group__3__Impl + rule__ServiceSpec__Group__4 ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__5__Impl +rule__ServiceSpec__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getActionAssignment_5()); } - (rule__ActionServer__ActionAssignment_5) - { after(grammarAccess.getActionServerAccess().getActionAssignment_5()); } + { before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__6 +rule__ServiceSpec__Group__4 @init { int stackSize = keepStackSize(); } : - rule__ActionServer__Group__6__Impl - rule__ActionServer__Group__7 + rule__ServiceSpec__Group__4__Impl + rule__ServiceSpec__Group__5 ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__6__Impl +rule__ServiceSpec__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getGroup_6()); } - (rule__ActionServer__Group_6__0)? - { after(grammarAccess.getActionServerAccess().getGroup_6()); } + { before(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); } + Request + { after(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__7 +rule__ServiceSpec__Group__5 @init { int stackSize = keepStackSize(); } : - rule__ActionServer__Group__7__Impl + rule__ServiceSpec__Group__5__Impl + rule__ServiceSpec__Group__6 ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group__7__Impl +rule__ServiceSpec__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getActionServerAccess().getRightCurlyBracketKeyword_7()); } + { before(grammarAccess.getServiceSpecAccess().getGroup_5()); } + (rule__ServiceSpec__Group_5__0)? + { after(grammarAccess.getServiceSpecAccess().getGroup_5()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ActionServer__Group_6__0 +rule__ServiceSpec__Group__6 @init { int stackSize = keepStackSize(); } : - rule__ActionServer__Group_6__0__Impl - rule__ActionServer__Group_6__1 + rule__ServiceSpec__Group__6__Impl + rule__ServiceSpec__Group__7 ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group_6__0__Impl +rule__ServiceSpec__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getNamespaceKeyword_6_0()); } - 'namespace' - { after(grammarAccess.getActionServerAccess().getNamespaceKeyword_6_0()); } + { before(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); } + Response + { after(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group_6__1 +rule__ServiceSpec__Group__7 @init { int stackSize = keepStackSize(); } : - rule__ActionServer__Group_6__1__Impl + rule__ServiceSpec__Group__7__Impl + rule__ServiceSpec__Group__8 ; finally { restoreStackSize(stackSize); } -rule__ActionServer__Group_6__1__Impl +rule__ServiceSpec__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); } - (rule__ActionServer__NamespaceAssignment_6_1) - { after(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); } + { before(grammarAccess.getServiceSpecAccess().getGroup_7()); } + (rule__ServiceSpec__Group_7__0)? + { after(grammarAccess.getServiceSpecAccess().getGroup_7()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ActionClient__Group__0 +rule__ServiceSpec__Group__8 @init { int stackSize = keepStackSize(); } : - rule__ActionClient__Group__0__Impl - rule__ActionClient__Group__1 + rule__ServiceSpec__Group__8__Impl ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__0__Impl +rule__ServiceSpec__Group__8__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getActionClientKeyword_0()); } - 'ActionClient' - { after(grammarAccess.getActionClientAccess().getActionClientKeyword_0()); } + { before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); } + RULE_END + { after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__1 + +rule__ServiceSpec__Group_5__0 @init { int stackSize = keepStackSize(); } : - rule__ActionClient__Group__1__Impl - rule__ActionClient__Group__2 + rule__ServiceSpec__Group_5__0__Impl + rule__ServiceSpec__Group_5__1 ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__1__Impl +rule__ServiceSpec__Group_5__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getActionClientAccess().getLeftCurlyBracketKeyword_1()); } + { before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); } + RULE_BEGIN + { after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__2 +rule__ServiceSpec__Group_5__1 @init { int stackSize = keepStackSize(); } : - rule__ActionClient__Group__2__Impl - rule__ActionClient__Group__3 + rule__ServiceSpec__Group_5__1__Impl + rule__ServiceSpec__Group_5__2 ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__2__Impl +rule__ServiceSpec__Group_5__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getNameKeyword_2()); } - 'name' - { after(grammarAccess.getActionClientAccess().getNameKeyword_2()); } + { before(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); } + (rule__ServiceSpec__RequestAssignment_5_1) + { after(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__3 +rule__ServiceSpec__Group_5__2 @init { int stackSize = keepStackSize(); } : - rule__ActionClient__Group__3__Impl - rule__ActionClient__Group__4 + rule__ServiceSpec__Group_5__2__Impl ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__3__Impl +rule__ServiceSpec__Group_5__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getNameAssignment_3()); } - (rule__ActionClient__NameAssignment_3) - { after(grammarAccess.getActionClientAccess().getNameAssignment_3()); } + { before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); } + RULE_END + { after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__4 + +rule__ServiceSpec__Group_7__0 @init { int stackSize = keepStackSize(); } : - rule__ActionClient__Group__4__Impl - rule__ActionClient__Group__5 + rule__ServiceSpec__Group_7__0__Impl + rule__ServiceSpec__Group_7__1 ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__4__Impl +rule__ServiceSpec__Group_7__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getActionKeyword_4()); } - 'action' - { after(grammarAccess.getActionClientAccess().getActionKeyword_4()); } + { before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); } + RULE_BEGIN + { after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__5 +rule__ServiceSpec__Group_7__1 @init { int stackSize = keepStackSize(); } : - rule__ActionClient__Group__5__Impl - rule__ActionClient__Group__6 + rule__ServiceSpec__Group_7__1__Impl + rule__ServiceSpec__Group_7__2 ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__5__Impl +rule__ServiceSpec__Group_7__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getActionAssignment_5()); } - (rule__ActionClient__ActionAssignment_5) - { after(grammarAccess.getActionClientAccess().getActionAssignment_5()); } + { before(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); } + (rule__ServiceSpec__ResponseAssignment_7_1) + { after(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__6 +rule__ServiceSpec__Group_7__2 @init { int stackSize = keepStackSize(); } : - rule__ActionClient__Group__6__Impl - rule__ActionClient__Group__7 + rule__ServiceSpec__Group_7__2__Impl ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__6__Impl +rule__ServiceSpec__Group_7__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getGroup_6()); } - (rule__ActionClient__Group_6__0)? - { after(grammarAccess.getActionClientAccess().getGroup_6()); } + { before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); } + RULE_END + { after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__7 + +rule__ActionSpec__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ActionClient__Group__7__Impl + rule__ActionSpec__Group__0__Impl + rule__ActionSpec__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group__7__Impl +rule__ActionSpec__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getActionClientAccess().getRightCurlyBracketKeyword_7()); } + { before(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); } + () + { after(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ActionClient__Group_6__0 +rule__ActionSpec__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ActionClient__Group_6__0__Impl - rule__ActionClient__Group_6__1 + rule__ActionSpec__Group__1__Impl + rule__ActionSpec__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group_6__0__Impl +rule__ActionSpec__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getNamespaceKeyword_6_0()); } - 'namespace' - { after(grammarAccess.getActionClientAccess().getNamespaceKeyword_6_0()); } + { before(grammarAccess.getActionSpecAccess().getActionKeyword_1()); } + Action_1 + { after(grammarAccess.getActionSpecAccess().getActionKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group_6__1 +rule__ActionSpec__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ActionClient__Group_6__1__Impl + rule__ActionSpec__Group__2__Impl + rule__ActionSpec__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ActionClient__Group_6__1__Impl +rule__ActionSpec__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); } - (rule__ActionClient__NamespaceAssignment_6_1) - { after(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); } + { before(grammarAccess.getActionSpecAccess().getNameAssignment_2()); } + (rule__ActionSpec__NameAssignment_2) + { after(grammarAccess.getActionSpecAccess().getNameAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ExternalDependency__Group__0 +rule__ActionSpec__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ExternalDependency__Group__0__Impl - rule__ExternalDependency__Group__1 + rule__ActionSpec__Group__3__Impl + rule__ActionSpec__Group__4 ; finally { restoreStackSize(stackSize); } -rule__ExternalDependency__Group__0__Impl +rule__ActionSpec__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); } - () - { after(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); } + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExternalDependency__Group__1 +rule__ActionSpec__Group__4 @init { int stackSize = keepStackSize(); } : - rule__ExternalDependency__Group__1__Impl - rule__ExternalDependency__Group__2 + rule__ActionSpec__Group__4__Impl + rule__ActionSpec__Group__5 ; finally { restoreStackSize(stackSize); } -rule__ExternalDependency__Group__1__Impl +rule__ActionSpec__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); } - 'ExternalDependency' - { after(grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); } + { before(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); } + Goal_1 + { after(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExternalDependency__Group__2 +rule__ActionSpec__Group__5 @init { int stackSize = keepStackSize(); } : - rule__ExternalDependency__Group__2__Impl + rule__ActionSpec__Group__5__Impl + rule__ActionSpec__Group__6 ; finally { restoreStackSize(stackSize); } -rule__ExternalDependency__Group__2__Impl +rule__ActionSpec__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); } - (rule__ExternalDependency__NameAssignment_2) - { after(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); } + { before(grammarAccess.getActionSpecAccess().getGroup_5()); } + (rule__ActionSpec__Group_5__0)? + { after(grammarAccess.getActionSpecAccess().getGroup_5()); } ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalNamespace__Group__0 +rule__ActionSpec__Group__6 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group__0__Impl - rule__GlobalNamespace__Group__1 + rule__ActionSpec__Group__6__Impl + rule__ActionSpec__Group__7 ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group__0__Impl +rule__ActionSpec__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); } - () - { after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); } + { before(grammarAccess.getActionSpecAccess().getResultKeyword_6()); } + Result_1 + { after(grammarAccess.getActionSpecAccess().getResultKeyword_6()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group__1 +rule__ActionSpec__Group__7 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group__1__Impl - rule__GlobalNamespace__Group__2 + rule__ActionSpec__Group__7__Impl + rule__ActionSpec__Group__8 ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group__1__Impl +rule__ActionSpec__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); } - 'GlobalNamespace' - { after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); } + { before(grammarAccess.getActionSpecAccess().getGroup_7()); } + (rule__ActionSpec__Group_7__0)? + { after(grammarAccess.getActionSpecAccess().getGroup_7()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group__2 +rule__ActionSpec__Group__8 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group__2__Impl - rule__GlobalNamespace__Group__3 + rule__ActionSpec__Group__8__Impl + rule__ActionSpec__Group__9 ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group__2__Impl +rule__ActionSpec__Group__8__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_2()); } - '{' - { after(grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_2()); } + { before(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); } + Feedback_1 + { after(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group__3 +rule__ActionSpec__Group__9 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group__3__Impl - rule__GlobalNamespace__Group__4 + rule__ActionSpec__Group__9__Impl + rule__ActionSpec__Group__10 ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group__3__Impl +rule__ActionSpec__Group__9__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getGroup_3()); } - (rule__GlobalNamespace__Group_3__0)? - { after(grammarAccess.getGlobalNamespaceAccess().getGroup_3()); } + { before(grammarAccess.getActionSpecAccess().getGroup_9()); } + (rule__ActionSpec__Group_9__0)? + { after(grammarAccess.getActionSpecAccess().getGroup_9()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group__4 +rule__ActionSpec__Group__10 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group__4__Impl + rule__ActionSpec__Group__10__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group__4__Impl +rule__ActionSpec__Group__10__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_4()); } - '}' - { after(grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_4()); } + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); } ) ; finally { @@ -9930,458 +9076,458 @@ finally { } -rule__GlobalNamespace__Group_3__0 +rule__ActionSpec__Group_5__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group_3__0__Impl - rule__GlobalNamespace__Group_3__1 + rule__ActionSpec__Group_5__0__Impl + rule__ActionSpec__Group_5__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3__0__Impl +rule__ActionSpec__Group_5__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getPartsKeyword_3_0()); } - 'parts' - { after(grammarAccess.getGlobalNamespaceAccess().getPartsKeyword_3_0()); } + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3__1 +rule__ActionSpec__Group_5__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group_3__1__Impl - rule__GlobalNamespace__Group_3__2 + rule__ActionSpec__Group_5__1__Impl + rule__ActionSpec__Group_5__2 ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3__1__Impl +rule__ActionSpec__Group_5__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); } - '{' - { after(grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); } + { before(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); } + (rule__ActionSpec__GoalAssignment_5_1) + { after(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3__2 +rule__ActionSpec__Group_5__2 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group_3__2__Impl - rule__GlobalNamespace__Group_3__3 + rule__ActionSpec__Group_5__2__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3__2__Impl +rule__ActionSpec__Group_5__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_3_2()); } - (rule__GlobalNamespace__PartsAssignment_3_2) - { after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_3_2()); } + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3__3 + +rule__ActionSpec__Group_7__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group_3__3__Impl - rule__GlobalNamespace__Group_3__4 + rule__ActionSpec__Group_7__0__Impl + rule__ActionSpec__Group_7__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3__3__Impl +rule__ActionSpec__Group_7__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getGroup_3_3()); } - (rule__GlobalNamespace__Group_3_3__0)* - { after(grammarAccess.getGlobalNamespaceAccess().getGroup_3_3()); } + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3__4 +rule__ActionSpec__Group_7__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group_3__4__Impl + rule__ActionSpec__Group_7__1__Impl + rule__ActionSpec__Group_7__2 ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3__4__Impl +rule__ActionSpec__Group_7__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_3_4()); } - '}' - { after(grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_3_4()); } + { before(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); } + (rule__ActionSpec__ResultAssignment_7_1) + { after(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalNamespace__Group_3_3__0 +rule__ActionSpec__Group_7__2 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group_3_3__0__Impl - rule__GlobalNamespace__Group_3_3__1 + rule__ActionSpec__Group_7__2__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3_3__0__Impl +rule__ActionSpec__Group_7__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_3_3_0()); } - ',' - { after(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_3_3_0()); } + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3_3__1 + +rule__ActionSpec__Group_9__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalNamespace__Group_3_3__1__Impl + rule__ActionSpec__Group_9__0__Impl + rule__ActionSpec__Group_9__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__Group_3_3__1__Impl +rule__ActionSpec__Group_9__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_3_3_1()); } - (rule__GlobalNamespace__PartsAssignment_3_3_1) - { after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_3_3_1()); } + { before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); } + RULE_BEGIN + { after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__RelativeNamespace_Impl__Group__0 +rule__ActionSpec__Group_9__1 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group__0__Impl - rule__RelativeNamespace_Impl__Group__1 + rule__ActionSpec__Group_9__1__Impl + rule__ActionSpec__Group_9__2 ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group__0__Impl +rule__ActionSpec__Group_9__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); } - () - { after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); } + { before(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); } + (rule__ActionSpec__FeedbackAssignment_9_1) + { after(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group__1 +rule__ActionSpec__Group_9__2 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group__1__Impl - rule__RelativeNamespace_Impl__Group__2 + rule__ActionSpec__Group_9__2__Impl ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group__1__Impl +rule__ActionSpec__Group_9__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); } - 'RelativeNamespace' - { after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); } + { before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); } + RULE_END + { after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group__2 + +rule__MessageDefinition__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group__2__Impl - rule__RelativeNamespace_Impl__Group__3 + rule__MessageDefinition__Group__0__Impl + rule__MessageDefinition__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group__2__Impl +rule__MessageDefinition__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_2()); } - '{' - { after(grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_2()); } + { before(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); } + () + { after(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group__3 +rule__MessageDefinition__Group__1 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group__3__Impl - rule__RelativeNamespace_Impl__Group__4 + rule__MessageDefinition__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group__3__Impl +rule__MessageDefinition__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_3()); } - (rule__RelativeNamespace_Impl__Group_3__0)? - { after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_3()); } + { before(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); } + (rule__MessageDefinition__MessagePartAssignment_1)* + { after(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group__4 + +rule__ExternalDependency__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group__4__Impl + rule__ExternalDependency__Group__0__Impl + rule__ExternalDependency__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group__4__Impl +rule__ExternalDependency__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_4()); } - '}' - { after(grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_4()); } + { before(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); } + () + { after(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__RelativeNamespace_Impl__Group_3__0 +rule__ExternalDependency__Group__1 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group_3__0__Impl - rule__RelativeNamespace_Impl__Group_3__1 + rule__ExternalDependency__Group__1__Impl + rule__ExternalDependency__Group__2 ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3__0__Impl +rule__ExternalDependency__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsKeyword_3_0()); } - 'parts' - { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsKeyword_3_0()); } + { before(grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); } + ExternalDependency + { after(grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3__1 +rule__ExternalDependency__Group__2 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group_3__1__Impl - rule__RelativeNamespace_Impl__Group_3__2 + rule__ExternalDependency__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3__1__Impl +rule__ExternalDependency__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_3_1()); } - '{' - { after(grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_3_1()); } + { before(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); } + (rule__ExternalDependency__NameAssignment_2) + { after(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3__2 + +rule__GlobalNamespace__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group_3__2__Impl - rule__RelativeNamespace_Impl__Group_3__3 + rule__GlobalNamespace__Group__0__Impl + rule__GlobalNamespace__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3__2__Impl +rule__GlobalNamespace__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_3_2()); } - (rule__RelativeNamespace_Impl__PartsAssignment_3_2) - { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_3_2()); } + { before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); } + () + { after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3__3 +rule__GlobalNamespace__Group__1 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group_3__3__Impl - rule__RelativeNamespace_Impl__Group_3__4 + rule__GlobalNamespace__Group__1__Impl + rule__GlobalNamespace__Group__2 ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3__3__Impl +rule__GlobalNamespace__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_3_3()); } - (rule__RelativeNamespace_Impl__Group_3_3__0)* - { after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_3_3()); } + { before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); } + GlobalNamespace + { after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3__4 +rule__GlobalNamespace__Group__2 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group_3__4__Impl + rule__GlobalNamespace__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3__4__Impl +rule__GlobalNamespace__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_3_4()); } - '}' - { after(grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_3_4()); } + { before(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); } + (rule__GlobalNamespace__Group_2__0)? + { after(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); } ) ; finally { @@ -10389,593 +9535,593 @@ finally { } -rule__RelativeNamespace_Impl__Group_3_3__0 +rule__GlobalNamespace__Group_2__0 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group_3_3__0__Impl - rule__RelativeNamespace_Impl__Group_3_3__1 + rule__GlobalNamespace__Group_2__0__Impl + rule__GlobalNamespace__Group_2__1 ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3_3__0__Impl +rule__GlobalNamespace__Group_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_3_3_0()); } - ',' - { after(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_3_3_0()); } + { before(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } + LeftSquareBracket + { after(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3_3__1 +rule__GlobalNamespace__Group_2__1 @init { int stackSize = keepStackSize(); } : - rule__RelativeNamespace_Impl__Group_3_3__1__Impl + rule__GlobalNamespace__Group_2__1__Impl + rule__GlobalNamespace__Group_2__2 ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__Group_3_3__1__Impl +rule__GlobalNamespace__Group_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_3_3_1()); } - (rule__RelativeNamespace_Impl__PartsAssignment_3_3_1) - { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_3_3_1()); } + { before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); } + (rule__GlobalNamespace__PartsAssignment_2_1) + { after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__PrivateNamespace__Group__0 +rule__GlobalNamespace__Group_2__2 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group__0__Impl - rule__PrivateNamespace__Group__1 + rule__GlobalNamespace__Group_2__2__Impl + rule__GlobalNamespace__Group_2__3 ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group__0__Impl +rule__GlobalNamespace__Group_2__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); } - () - { after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); } + { before(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); } + (rule__GlobalNamespace__Group_2_2__0)* + { after(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group__1 +rule__GlobalNamespace__Group_2__3 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group__1__Impl - rule__PrivateNamespace__Group__2 + rule__GlobalNamespace__Group_2__3__Impl ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group__1__Impl +rule__GlobalNamespace__Group_2__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); } - 'PrivateNamespace' - { after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); } + { before(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); } + RightSquareBracket + { after(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group__2 + +rule__GlobalNamespace__Group_2_2__0 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group__2__Impl - rule__PrivateNamespace__Group__3 + rule__GlobalNamespace__Group_2_2__0__Impl + rule__GlobalNamespace__Group_2_2__1 ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group__2__Impl +rule__GlobalNamespace__Group_2_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_2()); } - '{' - { after(grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_2()); } + { before(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); } + Comma + { after(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group__3 +rule__GlobalNamespace__Group_2_2__1 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group__3__Impl - rule__PrivateNamespace__Group__4 + rule__GlobalNamespace__Group_2_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group__3__Impl +rule__GlobalNamespace__Group_2_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getGroup_3()); } - (rule__PrivateNamespace__Group_3__0)? - { after(grammarAccess.getPrivateNamespaceAccess().getGroup_3()); } + { before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); } + (rule__GlobalNamespace__PartsAssignment_2_2_1) + { after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group__4 + +rule__RelativeNamespace_Impl__Group__0 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group__4__Impl + rule__RelativeNamespace_Impl__Group__0__Impl + rule__RelativeNamespace_Impl__Group__1 ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group__4__Impl +rule__RelativeNamespace_Impl__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_4()); } - '}' - { after(grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_4()); } + { before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); } + () + { after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__PrivateNamespace__Group_3__0 +rule__RelativeNamespace_Impl__Group__1 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group_3__0__Impl - rule__PrivateNamespace__Group_3__1 + rule__RelativeNamespace_Impl__Group__1__Impl + rule__RelativeNamespace_Impl__Group__2 ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3__0__Impl +rule__RelativeNamespace_Impl__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getPartsKeyword_3_0()); } - 'parts' - { after(grammarAccess.getPrivateNamespaceAccess().getPartsKeyword_3_0()); } + { before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); } + RelativeNamespace + { after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3__1 +rule__RelativeNamespace_Impl__Group__2 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group_3__1__Impl - rule__PrivateNamespace__Group_3__2 + rule__RelativeNamespace_Impl__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3__1__Impl +rule__RelativeNamespace_Impl__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); } - '{' - { after(grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); } + { before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); } + (rule__RelativeNamespace_Impl__Group_2__0)? + { after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3__2 + +rule__RelativeNamespace_Impl__Group_2__0 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group_3__2__Impl - rule__PrivateNamespace__Group_3__3 + rule__RelativeNamespace_Impl__Group_2__0__Impl + rule__RelativeNamespace_Impl__Group_2__1 ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3__2__Impl +rule__RelativeNamespace_Impl__Group_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_3_2()); } - (rule__PrivateNamespace__PartsAssignment_3_2) - { after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_3_2()); } + { before(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); } + LeftSquareBracket + { after(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3__3 +rule__RelativeNamespace_Impl__Group_2__1 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group_3__3__Impl - rule__PrivateNamespace__Group_3__4 + rule__RelativeNamespace_Impl__Group_2__1__Impl + rule__RelativeNamespace_Impl__Group_2__2 ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3__3__Impl +rule__RelativeNamespace_Impl__Group_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getGroup_3_3()); } - (rule__PrivateNamespace__Group_3_3__0)* - { after(grammarAccess.getPrivateNamespaceAccess().getGroup_3_3()); } + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); } + (rule__RelativeNamespace_Impl__PartsAssignment_2_1) + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3__4 +rule__RelativeNamespace_Impl__Group_2__2 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group_3__4__Impl + rule__RelativeNamespace_Impl__Group_2__2__Impl + rule__RelativeNamespace_Impl__Group_2__3 ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3__4__Impl +rule__RelativeNamespace_Impl__Group_2__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_3_4()); } - '}' - { after(grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_3_4()); } + { before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); } + (rule__RelativeNamespace_Impl__Group_2_2__0)* + { after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__PrivateNamespace__Group_3_3__0 +rule__RelativeNamespace_Impl__Group_2__3 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group_3_3__0__Impl - rule__PrivateNamespace__Group_3_3__1 + rule__RelativeNamespace_Impl__Group_2__3__Impl ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3_3__0__Impl +rule__RelativeNamespace_Impl__Group_2__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_3_3_0()); } - ',' - { after(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_3_3_0()); } + { before(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); } + RightSquareBracket + { after(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3_3__1 + +rule__RelativeNamespace_Impl__Group_2_2__0 @init { int stackSize = keepStackSize(); } : - rule__PrivateNamespace__Group_3_3__1__Impl + rule__RelativeNamespace_Impl__Group_2_2__0__Impl + rule__RelativeNamespace_Impl__Group_2_2__1 ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__Group_3_3__1__Impl +rule__RelativeNamespace_Impl__Group_2_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_3_3_1()); } - (rule__PrivateNamespace__PartsAssignment_3_3_1) - { after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_3_3_1()); } + { before(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); } + Comma + { after(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Parameter__Group__0 +rule__RelativeNamespace_Impl__Group_2_2__1 @init { int stackSize = keepStackSize(); } : - rule__Parameter__Group__0__Impl - rule__Parameter__Group__1 + rule__RelativeNamespace_Impl__Group_2_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__0__Impl +rule__RelativeNamespace_Impl__Group_2_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAccess().getParameterKeyword_0()); } - 'Parameter' - { after(grammarAccess.getParameterAccess().getParameterKeyword_0()); } + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); } + (rule__RelativeNamespace_Impl__PartsAssignment_2_2_1) + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__1 + +rule__PrivateNamespace__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Parameter__Group__1__Impl - rule__Parameter__Group__2 + rule__PrivateNamespace__Group__0__Impl + rule__PrivateNamespace__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__1__Impl +rule__PrivateNamespace__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getParameterAccess().getLeftCurlyBracketKeyword_1()); } + { before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); } + () + { after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__2 +rule__PrivateNamespace__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Parameter__Group__2__Impl - rule__Parameter__Group__3 + rule__PrivateNamespace__Group__1__Impl + rule__PrivateNamespace__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__2__Impl +rule__PrivateNamespace__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAccess().getNameKeyword_2()); } - 'name' - { after(grammarAccess.getParameterAccess().getNameKeyword_2()); } + { before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); } + PrivateNamespace + { after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__3 +rule__PrivateNamespace__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Parameter__Group__3__Impl - rule__Parameter__Group__4 + rule__PrivateNamespace__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__3__Impl +rule__PrivateNamespace__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAccess().getNameAssignment_3()); } - (rule__Parameter__NameAssignment_3) - { after(grammarAccess.getParameterAccess().getNameAssignment_3()); } + { before(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); } + (rule__PrivateNamespace__Group_2__0)? + { after(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__4 + +rule__PrivateNamespace__Group_2__0 @init { int stackSize = keepStackSize(); } : - rule__Parameter__Group__4__Impl - rule__Parameter__Group__5 + rule__PrivateNamespace__Group_2__0__Impl + rule__PrivateNamespace__Group_2__1 ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__4__Impl +rule__PrivateNamespace__Group_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAccess().getGroup_4()); } - (rule__Parameter__Group_4__0)? - { after(grammarAccess.getParameterAccess().getGroup_4()); } + { before(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } + LeftSquareBracket + { after(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__5 +rule__PrivateNamespace__Group_2__1 @init { int stackSize = keepStackSize(); } : - rule__Parameter__Group__5__Impl - rule__Parameter__Group__6 + rule__PrivateNamespace__Group_2__1__Impl + rule__PrivateNamespace__Group_2__2 ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__5__Impl +rule__PrivateNamespace__Group_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAccess().getTypeKeyword_5()); } - 'type' - { after(grammarAccess.getParameterAccess().getTypeKeyword_5()); } + { before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); } + (rule__PrivateNamespace__PartsAssignment_2_1) + { after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__6 +rule__PrivateNamespace__Group_2__2 @init { int stackSize = keepStackSize(); } : - rule__Parameter__Group__6__Impl - rule__Parameter__Group__7 + rule__PrivateNamespace__Group_2__2__Impl + rule__PrivateNamespace__Group_2__3 ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__6__Impl +rule__PrivateNamespace__Group_2__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAccess().getTypeAssignment_6()); } - (rule__Parameter__TypeAssignment_6) - { after(grammarAccess.getParameterAccess().getTypeAssignment_6()); } + { before(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); } + (rule__PrivateNamespace__Group_2_2__0)* + { after(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__7 +rule__PrivateNamespace__Group_2__3 @init { int stackSize = keepStackSize(); } : - rule__Parameter__Group__7__Impl + rule__PrivateNamespace__Group_2__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group__7__Impl +rule__PrivateNamespace__Group_2__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_7()); } + { before(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); } + RightSquareBracket + { after(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); } ) ; finally { @@ -10983,53 +10129,53 @@ finally { } -rule__Parameter__Group_4__0 +rule__PrivateNamespace__Group_2_2__0 @init { int stackSize = keepStackSize(); } : - rule__Parameter__Group_4__0__Impl - rule__Parameter__Group_4__1 + rule__PrivateNamespace__Group_2_2__0__Impl + rule__PrivateNamespace__Group_2_2__1 ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group_4__0__Impl +rule__PrivateNamespace__Group_2_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAccess().getNamespaceKeyword_4_0()); } - 'namespace' - { after(grammarAccess.getParameterAccess().getNamespaceKeyword_4_0()); } + { before(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); } + Comma + { after(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group_4__1 +rule__PrivateNamespace__Group_2_2__1 @init { int stackSize = keepStackSize(); } : - rule__Parameter__Group_4__1__Impl + rule__PrivateNamespace__Group_2_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Parameter__Group_4__1__Impl +rule__PrivateNamespace__Group_2_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAccess().getNamespaceAssignment_4_1()); } - (rule__Parameter__NamespaceAssignment_4_1) - { after(grammarAccess.getParameterAccess().getNamespaceAssignment_4_1()); } + { before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); } + (rule__PrivateNamespace__PartsAssignment_2_2_1) + { after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); } ) ; finally { @@ -11083,7 +10229,7 @@ rule__ParameterListType__Group__1__Impl : ( { before(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); } - 'List' + List { after(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); } ) ; @@ -11109,9 +10255,9 @@ rule__ParameterListType__Group__2__Impl } : ( - { before(grammarAccess.getParameterListTypeAccess().getLeftCurlyBracketKeyword_2()); } - '{' - { after(grammarAccess.getParameterListTypeAccess().getLeftCurlyBracketKeyword_2()); } + { before(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); } + LeftSquareBracket + { after(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); } ) ; finally { @@ -11189,9 +10335,9 @@ rule__ParameterListType__Group__5__Impl } : ( - { before(grammarAccess.getParameterListTypeAccess().getRightCurlyBracketKeyword_5()); } - '}' - { after(grammarAccess.getParameterListTypeAccess().getRightCurlyBracketKeyword_5()); } + { before(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); } + RightSquareBracket + { after(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); } ) ; finally { @@ -11218,7 +10364,7 @@ rule__ParameterListType__Group_4__0__Impl : ( { before(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); } - ',' + Comma { after(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); } ) ; @@ -11299,7 +10445,7 @@ rule__ParameterStructType__Group__1__Impl : ( { before(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); } - 'Struct' + Struct { after(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); } ) ; @@ -11325,9 +10471,9 @@ rule__ParameterStructType__Group__2__Impl } : ( - { before(grammarAccess.getParameterStructTypeAccess().getLeftCurlyBracketKeyword_2()); } - '{' - { after(grammarAccess.getParameterStructTypeAccess().getLeftCurlyBracketKeyword_2()); } + { before(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); } + LeftSquareBracket + { after(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); } ) ; finally { @@ -11405,9 +10551,9 @@ rule__ParameterStructType__Group__5__Impl } : ( - { before(grammarAccess.getParameterStructTypeAccess().getRightCurlyBracketKeyword_5()); } - '}' - { after(grammarAccess.getParameterStructTypeAccess().getRightCurlyBracketKeyword_5()); } + { before(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); } + RightSquareBracket + { after(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); } ) ; finally { @@ -11434,7 +10580,7 @@ rule__ParameterStructType__Group_4__0__Impl : ( { before(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); } - ',' + Comma { after(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); } ) ; @@ -11515,7 +10661,7 @@ rule__ParameterIntegerType__Group__1__Impl : ( { before(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); } - 'Integer' + Integer { after(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); } ) ; @@ -11569,7 +10715,7 @@ rule__ParameterIntegerType__Group_2__0__Impl : ( { before(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); } - 'default' + Default { after(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); } ) ; @@ -11650,7 +10796,7 @@ rule__ParameterStringType__Group__1__Impl : ( { before(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); } - 'String' + String { after(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); } ) ; @@ -11704,7 +10850,7 @@ rule__ParameterStringType__Group_2__0__Impl : ( { before(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); } - 'default' + Default { after(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); } ) ; @@ -11785,7 +10931,7 @@ rule__ParameterDoubleType__Group__1__Impl : ( { before(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); } - 'Double' + Double { after(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); } ) ; @@ -11839,7 +10985,7 @@ rule__ParameterDoubleType__Group_2__0__Impl : ( { before(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); } - 'default' + Default { after(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); } ) ; @@ -11920,7 +11066,7 @@ rule__ParameterBooleanType__Group__1__Impl : ( { before(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); } - 'Boolean' + Boolean { after(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); } ) ; @@ -11974,7 +11120,7 @@ rule__ParameterBooleanType__Group_2__0__Impl : ( { before(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); } - 'default' + Default { after(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); } ) ; @@ -12055,7 +11201,7 @@ rule__ParameterBase64Type__Group__1__Impl : ( { before(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); } - 'Base64' + Base64 { after(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); } ) ; @@ -12109,7 +11255,7 @@ rule__ParameterBase64Type__Group_2__0__Impl : ( { before(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); } - 'default' + Default { after(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); } ) ; @@ -12163,7 +11309,7 @@ rule__ParameterArrayType__Group__0__Impl : ( { before(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); } - 'Array' + Array { after(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); } ) ; @@ -12189,9 +11335,9 @@ rule__ParameterArrayType__Group__1__Impl } : ( - { before(grammarAccess.getParameterArrayTypeAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getParameterArrayTypeAccess().getLeftCurlyBracketKeyword_1()); } + { before(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); } + RULE_BEGIN + { after(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); } ) ; finally { @@ -12217,7 +11363,7 @@ rule__ParameterArrayType__Group__2__Impl : ( { before(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); } - 'type' + Type { after(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); } ) ; @@ -12296,9 +11442,9 @@ rule__ParameterArrayType__Group__5__Impl } : ( - { before(grammarAccess.getParameterArrayTypeAccess().getRightCurlyBracketKeyword_5()); } - '}' - { after(grammarAccess.getParameterArrayTypeAccess().getRightCurlyBracketKeyword_5()); } + { before(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); } + RULE_END + { after(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); } ) ; finally { @@ -12325,7 +11471,7 @@ rule__ParameterArrayType__Group_4__0__Impl : ( { before(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); } - 'default' + Default { after(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); } ) ; @@ -12405,9 +11551,9 @@ rule__ParameterList__Group__1__Impl } : ( - { before(grammarAccess.getParameterListAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getParameterListAccess().getLeftCurlyBracketKeyword_1()); } + { before(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); } + LeftSquareBracket + { after(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); } ) ; finally { @@ -12485,9 +11631,9 @@ rule__ParameterList__Group__4__Impl } : ( - { before(grammarAccess.getParameterListAccess().getRightCurlyBracketKeyword_4()); } - '}' - { after(grammarAccess.getParameterListAccess().getRightCurlyBracketKeyword_4()); } + { before(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); } + RightSquareBracket + { after(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); } ) ; finally { @@ -12514,7 +11660,7 @@ rule__ParameterList__Group_3__0__Impl : ( { before(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); } - ',' + Comma { after(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); } ) ; @@ -12595,7 +11741,7 @@ rule__ParameterAny__Group__1__Impl : ( { before(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); } - 'ParameterAny' + ParameterAny { after(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); } ) ; @@ -12609,7 +11755,6 @@ rule__ParameterAny__Group__2 } : rule__ParameterAny__Group__2__Impl - rule__ParameterAny__Group__3 ; finally { restoreStackSize(stackSize); @@ -12621,62 +11766,9 @@ rule__ParameterAny__Group__2__Impl } : ( - { before(grammarAccess.getParameterAnyAccess().getLeftCurlyBracketKeyword_2()); } - '{' - { after(grammarAccess.getParameterAnyAccess().getLeftCurlyBracketKeyword_2()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__ParameterAny__Group__3 - @init { - int stackSize = keepStackSize(); - } -: - rule__ParameterAny__Group__3__Impl - rule__ParameterAny__Group__4 -; -finally { - restoreStackSize(stackSize); -} - -rule__ParameterAny__Group__3__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getParameterAnyAccess().getGroup_3()); } - (rule__ParameterAny__Group_3__0)? - { after(grammarAccess.getParameterAnyAccess().getGroup_3()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__ParameterAny__Group__4 - @init { - int stackSize = keepStackSize(); - } -: - rule__ParameterAny__Group__4__Impl -; -finally { - restoreStackSize(stackSize); -} - -rule__ParameterAny__Group__4__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getParameterAnyAccess().getRightCurlyBracketKeyword_4()); } - '}' - { after(grammarAccess.getParameterAnyAccess().getRightCurlyBracketKeyword_4()); } + { before(grammarAccess.getParameterAnyAccess().getGroup_2()); } + (rule__ParameterAny__Group_2__0)? + { after(grammarAccess.getParameterAnyAccess().getGroup_2()); } ) ; finally { @@ -12684,53 +11776,53 @@ finally { } -rule__ParameterAny__Group_3__0 +rule__ParameterAny__Group_2__0 @init { int stackSize = keepStackSize(); } : - rule__ParameterAny__Group_3__0__Impl - rule__ParameterAny__Group_3__1 + rule__ParameterAny__Group_2__0__Impl + rule__ParameterAny__Group_2__1 ; finally { restoreStackSize(stackSize); } -rule__ParameterAny__Group_3__0__Impl +rule__ParameterAny__Group_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAnyAccess().getValueKeyword_3_0()); } - 'value' - { after(grammarAccess.getParameterAnyAccess().getValueKeyword_3_0()); } + { before(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); } + Value + { after(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ParameterAny__Group_3__1 +rule__ParameterAny__Group_2__1 @init { int stackSize = keepStackSize(); } : - rule__ParameterAny__Group_3__1__Impl + rule__ParameterAny__Group_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ParameterAny__Group_3__1__Impl +rule__ParameterAny__Group_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAnyAccess().getValueAssignment_3_1()); } - (rule__ParameterAny__ValueAssignment_3_1) - { after(grammarAccess.getParameterAnyAccess().getValueAssignment_3_1()); } + { before(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); } + (rule__ParameterAny__ValueAssignment_2_1) + { after(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); } ) ; finally { @@ -12810,9 +11902,9 @@ rule__ParameterStruct__Group_1__0__Impl } : ( - { before(grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_0()); } - '{' - { after(grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_0()); } + { before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); } + LeftSquareBracket + { after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); } ) ; finally { @@ -12890,9 +11982,9 @@ rule__ParameterStruct__Group_1__3__Impl } : ( - { before(grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_3()); } - '}' - { after(grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_3()); } + { before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); } + RightSquareBracket + { after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); } ) ; finally { @@ -12919,7 +12011,7 @@ rule__ParameterStruct__Group_1_2__0__Impl : ( { before(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); } - ',' + Comma { after(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); } ) ; @@ -12945,9 +12037,9 @@ rule__ParameterStruct__Group_1_2__1__Impl } : ( - { before(grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_2_1()); } - '{' - { after(grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_2_1()); } + { before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); } + LeftSquareBracket + { after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); } ) ; finally { @@ -12998,9 +12090,9 @@ rule__ParameterStruct__Group_1_2__3__Impl } : ( - { before(grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_2_3()); } - '}' - { after(grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_2_3()); } + { before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); } + RightSquareBracket + { after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); } ) ; finally { @@ -13027,7 +12119,7 @@ rule__ParameterStructMember__Group__0__Impl : ( { before(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); } - 'ParameterStructMember' + ParameterStructMember { after(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); } ) ; @@ -13080,9 +12172,9 @@ rule__ParameterStructMember__Group__2__Impl } : ( - { before(grammarAccess.getParameterStructMemberAccess().getLeftCurlyBracketKeyword_2()); } - '{' - { after(grammarAccess.getParameterStructMemberAccess().getLeftCurlyBracketKeyword_2()); } + { before(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); } ) ; finally { @@ -13107,9 +12199,9 @@ rule__ParameterStructMember__Group__3__Impl } : ( - { before(grammarAccess.getParameterStructMemberAccess().getValueKeyword_3()); } - 'value' - { after(grammarAccess.getParameterStructMemberAccess().getValueKeyword_3()); } + { before(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); } ) ; finally { @@ -13160,9 +12252,9 @@ rule__ParameterStructMember__Group__5__Impl } : ( - { before(grammarAccess.getParameterStructMemberAccess().getRightCurlyBracketKeyword_5()); } - '}' - { after(grammarAccess.getParameterStructMemberAccess().getRightCurlyBracketKeyword_5()); } + { before(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); } + RULE_END + { after(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); } ) ; finally { @@ -13323,7 +12415,7 @@ rule__Bool__Group__1__Impl : ( { before(grammarAccess.getBoolAccess().getBoolKeyword_1()); } - 'bool' + Bool { after(grammarAccess.getBoolAccess().getBoolKeyword_1()); } ) ; @@ -13377,7 +12469,7 @@ rule__Int8__Group__1__Impl : ( { before(grammarAccess.getInt8Access().getInt8Keyword_1()); } - 'int8' + Int8 { after(grammarAccess.getInt8Access().getInt8Keyword_1()); } ) ; @@ -13431,7 +12523,7 @@ rule__Uint8__Group__1__Impl : ( { before(grammarAccess.getUint8Access().getUint8Keyword_1()); } - 'uint8' + Uint8 { after(grammarAccess.getUint8Access().getUint8Keyword_1()); } ) ; @@ -13485,7 +12577,7 @@ rule__Int16__Group__1__Impl : ( { before(grammarAccess.getInt16Access().getInt16Keyword_1()); } - 'int16' + Int16 { after(grammarAccess.getInt16Access().getInt16Keyword_1()); } ) ; @@ -13539,7 +12631,7 @@ rule__Uint16__Group__1__Impl : ( { before(grammarAccess.getUint16Access().getUint16Keyword_1()); } - 'uint16' + Uint16 { after(grammarAccess.getUint16Access().getUint16Keyword_1()); } ) ; @@ -13593,7 +12685,7 @@ rule__Int32__Group__1__Impl : ( { before(grammarAccess.getInt32Access().getInt32Keyword_1()); } - 'int32' + Int32 { after(grammarAccess.getInt32Access().getInt32Keyword_1()); } ) ; @@ -13647,7 +12739,7 @@ rule__Uint32__Group__1__Impl : ( { before(grammarAccess.getUint32Access().getUint32Keyword_1()); } - 'uint32' + Uint32 { after(grammarAccess.getUint32Access().getUint32Keyword_1()); } ) ; @@ -13701,7 +12793,7 @@ rule__Int64__Group__1__Impl : ( { before(grammarAccess.getInt64Access().getInt64Keyword_1()); } - 'int64' + Int64 { after(grammarAccess.getInt64Access().getInt64Keyword_1()); } ) ; @@ -13755,7 +12847,7 @@ rule__Uint64__Group__1__Impl : ( { before(grammarAccess.getUint64Access().getUint64Keyword_1()); } - 'uint64' + Uint64 { after(grammarAccess.getUint64Access().getUint64Keyword_1()); } ) ; @@ -13809,7 +12901,7 @@ rule__Float32__Group__1__Impl : ( { before(grammarAccess.getFloat32Access().getFloat32Keyword_1()); } - 'float32' + Float32 { after(grammarAccess.getFloat32Access().getFloat32Keyword_1()); } ) ; @@ -13863,7 +12955,7 @@ rule__Float64__Group__1__Impl : ( { before(grammarAccess.getFloat64Access().getFloat64Keyword_1()); } - 'float64' + Float64 { after(grammarAccess.getFloat64Access().getFloat64Keyword_1()); } ) ; @@ -13917,7 +13009,7 @@ rule__String0__Group__1__Impl : ( { before(grammarAccess.getString0Access().getStringKeyword_1()); } - 'string' + String_1 { after(grammarAccess.getString0Access().getStringKeyword_1()); } ) ; @@ -13971,7 +13063,7 @@ rule__Byte__Group__1__Impl : ( { before(grammarAccess.getByteAccess().getByteKeyword_1()); } - 'byte' + Byte { after(grammarAccess.getByteAccess().getByteKeyword_1()); } ) ; @@ -14025,7 +13117,7 @@ rule__Time__Group__1__Impl : ( { before(grammarAccess.getTimeAccess().getTimeKeyword_1()); } - 'time' + Time { after(grammarAccess.getTimeAccess().getTimeKeyword_1()); } ) ; @@ -14079,7 +13171,7 @@ rule__Duration__Group__1__Impl : ( { before(grammarAccess.getDurationAccess().getDurationKeyword_1()); } - 'duration' + Duration { after(grammarAccess.getDurationAccess().getDurationKeyword_1()); } ) ; @@ -14133,7 +13225,7 @@ rule__BoolArray__Group__1__Impl : ( { before(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); } - 'bool[]' + Bool_1 { after(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); } ) ; @@ -14187,7 +13279,7 @@ rule__Int8Array__Group__1__Impl : ( { before(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); } - 'int8[]' + Int8_1 { after(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); } ) ; @@ -14241,7 +13333,7 @@ rule__Uint8Array__Group__1__Impl : ( { before(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); } - 'uint8[]' + Uint8_1 { after(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); } ) ; @@ -14295,7 +13387,7 @@ rule__Int16Array__Group__1__Impl : ( { before(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); } - 'int16[]' + Int16_1 { after(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); } ) ; @@ -14349,7 +13441,7 @@ rule__Uint16Array__Group__1__Impl : ( { before(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); } - 'uint16[]' + Uint16_1 { after(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); } ) ; @@ -14403,7 +13495,7 @@ rule__Int32Array__Group__1__Impl : ( { before(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); } - 'int32[]' + Int32_1 { after(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); } ) ; @@ -14457,7 +13549,7 @@ rule__Uint32Array__Group__1__Impl : ( { before(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); } - 'uint32[]' + Uint32_1 { after(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); } ) ; @@ -14511,7 +13603,7 @@ rule__Int64Array__Group__1__Impl : ( { before(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); } - 'int64[]' + Int64_1 { after(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); } ) ; @@ -14565,7 +13657,7 @@ rule__Uint64Array__Group__1__Impl : ( { before(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); } - 'uint64[]' + Uint64_1 { after(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); } ) ; @@ -14619,7 +13711,7 @@ rule__Float32Array__Group__1__Impl : ( { before(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); } - 'float32[]' + Float32_1 { after(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); } ) ; @@ -14673,7 +13765,7 @@ rule__Float64Array__Group__1__Impl : ( { before(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); } - 'float64[]' + Float64_1 { after(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); } ) ; @@ -14727,7 +13819,7 @@ rule__String0Array__Group__1__Impl : ( { before(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); } - 'string[]' + String_2 { after(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); } ) ; @@ -14781,7 +13873,7 @@ rule__ByteArray__Group__1__Impl : ( { before(grammarAccess.getByteArrayAccess().getByteKeyword_1()); } - 'byte[]' + Byte_1 { after(grammarAccess.getByteArrayAccess().getByteKeyword_1()); } ) ; @@ -14835,7 +13927,7 @@ rule__Header__Group__1__Impl : ( { before(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); } - 'Header' + Header { after(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); } ) ; @@ -14889,7 +13981,7 @@ rule__ArrayTopicSpecRef__Group__1__Impl : ( { before(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); } - '[]' + LeftSquareBracketRightSquareBracket { after(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); } ) ; @@ -14898,1074 +13990,1133 @@ finally { } -rule__PackageSet__PackageAssignment_3_0 +rule__QualityOfService__UnorderedGroup_1 @init { int stackSize = keepStackSize(); + getUnorderedGroupHelper().enter(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); } : - ( - { before(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_0_0()); } - rulePackage - { after(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_0_0()); } - ) + rule__QualityOfService__UnorderedGroup_1__0 + ? ; finally { + getUnorderedGroupHelper().leave(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); restoreStackSize(stackSize); } -rule__PackageSet__PackageAssignment_3_1_1 +rule__QualityOfService__UnorderedGroup_1__Impl @init { int stackSize = keepStackSize(); + boolean selected = false; } : - ( - { before(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_1_1_0()); } - rulePackage - { after(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_1_1_0()); } - ) + ( + ( + {getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0)}?=>( + { + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0); + } + { + selected = true; + } + ( + { before(grammarAccess.getQualityOfServiceAccess().getGroup_1_0()); } + (rule__QualityOfService__Group_1_0__0) + { after(grammarAccess.getQualityOfServiceAccess().getGroup_1_0()); } + ) + ) + )| + ( + {getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1)}?=>( + { + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1); + } + { + selected = true; + } + ( + { before(grammarAccess.getQualityOfServiceAccess().getGroup_1_1()); } + (rule__QualityOfService__Group_1_1__0) + { after(grammarAccess.getQualityOfServiceAccess().getGroup_1_1()); } + ) + ) + )| + ( + {getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2)}?=>( + { + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2); + } + { + selected = true; + } + ( + { before(grammarAccess.getQualityOfServiceAccess().getGroup_1_2()); } + (rule__QualityOfService__Group_1_2__0) + { after(grammarAccess.getQualityOfServiceAccess().getGroup_1_2()); } + ) + ) + )| + ( + {getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3)}?=>( + { + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3); + } + { + selected = true; + } + ( + { before(grammarAccess.getQualityOfServiceAccess().getGroup_1_3()); } + (rule__QualityOfService__Group_1_3__0) + { after(grammarAccess.getQualityOfServiceAccess().getGroup_1_3()); } + ) + ) + )| + ( + {getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4)}?=>( + { + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4); + } + { + selected = true; + } + ( + { before(grammarAccess.getQualityOfServiceAccess().getGroup_1_4()); } + (rule__QualityOfService__Group_1_4__0) + { after(grammarAccess.getQualityOfServiceAccess().getGroup_1_4()); } + ) + ) + ) + ) ; finally { + if (selected) + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); restoreStackSize(stackSize); } -rule__Package_Impl__NameAssignment_2 +rule__QualityOfService__UnorderedGroup_1__0 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getPackage_ImplAccess().getNameEStringParserRuleCall_2_0()); } - ruleEString - { after(grammarAccess.getPackage_ImplAccess().getNameEStringParserRuleCall_2_0()); } - ) + rule__QualityOfService__UnorderedGroup_1__Impl + rule__QualityOfService__UnorderedGroup_1__1? ; finally { restoreStackSize(stackSize); } -rule__Package_Impl__FromGitRepoAssignment_4_1 +rule__QualityOfService__UnorderedGroup_1__1 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } - ruleEString - { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } - ) + rule__QualityOfService__UnorderedGroup_1__Impl + rule__QualityOfService__UnorderedGroup_1__2? ; finally { restoreStackSize(stackSize); } -rule__Package_Impl__SpecAssignment_5_2 +rule__QualityOfService__UnorderedGroup_1__2 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); } - ruleSpecBase - { after(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); } - ) + rule__QualityOfService__UnorderedGroup_1__Impl + rule__QualityOfService__UnorderedGroup_1__3? ; finally { restoreStackSize(stackSize); } -rule__Package_Impl__SpecAssignment_5_3_1 +rule__QualityOfService__UnorderedGroup_1__3 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_3_1_0()); } - ruleSpecBase - { after(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_3_1_0()); } - ) + rule__QualityOfService__UnorderedGroup_1__Impl + rule__QualityOfService__UnorderedGroup_1__4? ; finally { restoreStackSize(stackSize); } -rule__Package_Impl__ArtifactAssignment_6_0 +rule__QualityOfService__UnorderedGroup_1__4 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_0_0()); } - ruleArtifact - { after(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_0_0()); } - ) + rule__QualityOfService__UnorderedGroup_1__Impl ; finally { restoreStackSize(stackSize); } -rule__Package_Impl__ArtifactAssignment_6_1_1 + +rule__AmentPackage__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_1_1_0()); } - ruleArtifact - { after(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_1_1_0()); } + { before(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_1_0()); } + ruleRosNames + { after(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Artifact__NameAssignment_2 +rule__AmentPackage__FromGitRepoAssignment_4_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_2_0()); } - ruleRosNames - { after(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_2_0()); } + { before(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } + ruleEString + { after(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Artifact__NodeAssignment_4 +rule__AmentPackage__ArtifactAssignment_5_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); } - ruleNode - { after(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); } + { before(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); } + ruleArtifact + { after(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__NameAssignment_2 +rule__AmentPackage__DependencyAssignment_6_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_2_0()); } - ruleRosNames - { after(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_2_0()); } + { before(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); } + ruleDependency + { after(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__FromGitRepoAssignment_4_1 +rule__AmentPackage__DependencyAssignment_6_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } - ruleEString - { after(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } + { before(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); } + ruleDependency + { after(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__DependencyAssignment_5_2 +rule__QualityOfService__QoSProfileAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); } - ruleDependency - { after(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); } + { before(grammarAccess.getQualityOfServiceAccess().getQoSProfileAlternatives_1_0_1_0()); } + (rule__QualityOfService__QoSProfileAlternatives_1_0_1_0) + { after(grammarAccess.getQualityOfServiceAccess().getQoSProfileAlternatives_1_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__DependencyAssignment_5_3_1 +rule__QualityOfService__HistoryAssignment_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); } - ruleDependency - { after(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); } + { before(grammarAccess.getQualityOfServiceAccess().getHistoryAlternatives_1_1_1_0()); } + (rule__QualityOfService__HistoryAlternatives_1_1_1_0) + { after(grammarAccess.getQualityOfServiceAccess().getHistoryAlternatives_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__SpecAssignment_6_2 +rule__QualityOfService__DepthAssignment_1_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); } - ruleSpecBase - { after(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); } + { before(grammarAccess.getQualityOfServiceAccess().getDepthInteger0ParserRuleCall_1_2_1_0()); } + ruleInteger0 + { after(grammarAccess.getQualityOfServiceAccess().getDepthInteger0ParserRuleCall_1_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__SpecAssignment_6_3_1 +rule__QualityOfService__ReliabilityAssignment_1_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); } - ruleSpecBase - { after(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); } + { before(grammarAccess.getQualityOfServiceAccess().getReliabilityAlternatives_1_3_1_0()); } + (rule__QualityOfService__ReliabilityAlternatives_1_3_1_0) + { after(grammarAccess.getQualityOfServiceAccess().getReliabilityAlternatives_1_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__ArtifactAssignment_7_0 +rule__QualityOfService__DurabilityAssignment_1_4_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); } - ruleArtifact - { after(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); } + { before(grammarAccess.getQualityOfServiceAccess().getDurabilityAlternatives_1_4_1_0()); } + (rule__QualityOfService__DurabilityAlternatives_1_4_1_0) + { after(grammarAccess.getQualityOfServiceAccess().getDurabilityAlternatives_1_4_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CatkinPackage__ArtifactAssignment_7_1_1 +rule__Publisher__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); } - ruleArtifact - { after(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); } + { before(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__NameAssignment_2 +rule__Publisher__MessageAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_2_0()); } - ruleRosNames - { after(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_2_0()); } + { 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__AmentPackage__FromGitRepoAssignment_4_1 +rule__Publisher__NamespaceAssignment_6_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } - ruleEString - { after(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } + { before(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__DependencyAssignment_5_2 +rule__Publisher__QosAssignment_7_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); } - ruleDependency - { after(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); } + { before(grammarAccess.getPublisherAccess().getQosQualityOfServiceParserRuleCall_7_2_0()); } + ruleQualityOfService + { after(grammarAccess.getPublisherAccess().getQosQualityOfServiceParserRuleCall_7_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__DependencyAssignment_5_3_1 +rule__Subscriber__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); } - ruleDependency - { after(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); } + { before(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__SpecAssignment_6_2 +rule__Subscriber__MessageAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); } - ruleSpecBase - { after(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); } + { 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__AmentPackage__SpecAssignment_6_3_1 +rule__Subscriber__NamespaceAssignment_6_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); } - ruleSpecBase - { after(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); } + { before(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__ArtifactAssignment_7_0 +rule__Subscriber__QosAssignment_7_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); } - ruleArtifact - { after(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); } + { before(grammarAccess.getSubscriberAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } + ruleQualityOfService + { after(grammarAccess.getSubscriberAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AmentPackage__ArtifactAssignment_7_1_1 +rule__ServiceServer__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); } - ruleArtifact - { after(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); } + { before(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__NameAssignment_2 +rule__ServiceServer__ServiceAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); } - ruleEString - { after(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); } + { before(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__RequestAssignment_4_1 +rule__ServiceServer__NamespaceAssignment_6_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_4_1_0()); } - ruleMessageDefinition - { after(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_4_1_0()); } + { before(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceSpec__ResponseAssignment_5_1 +rule__ServiceServer__QosAssignment_7_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_5_1_0()); } - ruleMessageDefinition - { after(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_5_1_0()); } + { before(grammarAccess.getServiceServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } + ruleQualityOfService + { after(grammarAccess.getServiceServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__NameAssignment_2 +rule__ServiceClient__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); } - (rule__TopicSpec__NameAlternatives_2_0) - { after(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); } + { before(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__TopicSpec__MessageAssignment_4_1 +rule__ServiceClient__ServiceAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_4_1_0()); } - ruleMessageDefinition - { after(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_4_1_0()); } + { before(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__NameAssignment_2 +rule__ServiceClient__NamespaceAssignment_6_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); } - ruleEString - { after(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); } + { before(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__GoalAssignment_4_1 +rule__ServiceClient__QosAssignment_7_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_4_1_0()); } - ruleMessageDefinition - { after(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_4_1_0()); } + { before(grammarAccess.getServiceClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } + ruleQualityOfService + { after(grammarAccess.getServiceClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__ResultAssignment_5_1 +rule__ActionServer__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_5_1_0()); } - ruleMessageDefinition - { after(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_5_1_0()); } + { before(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionSpec__FeedbackAssignment_6_1 +rule__ActionServer__ActionAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_6_1_0()); } - ruleMessageDefinition - { after(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_6_1_0()); } + { before(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__MessagePartAssignment_2_0 +rule__ActionServer__NamespaceAssignment_6_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_0_0()); } - ruleMessagePart - { after(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_0_0()); } + { before(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MessageDefinition__MessagePartAssignment_2_1 +rule__ActionServer__QosAssignment_7_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_1_0()); } - ruleMessagePart - { after(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_1_0()); } + { before(grammarAccess.getActionServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } + ruleQualityOfService + { after(grammarAccess.getActionServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__NameAssignment_3 +rule__ActionClient__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_3_0()); } - ruleRosNames - { after(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_3_0()); } + { before(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__ServiceserverAssignment_4_2 +rule__ActionClient__ActionAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_2_0()); } - ruleServiceServer - { after(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_2_0()); } + { before(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__ServiceserverAssignment_4_3_1 +rule__ActionClient__NamespaceAssignment_6_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_3_1_0()); } - ruleServiceServer - { after(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_3_1_0()); } + { before(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__PublisherAssignment_5_2 +rule__ActionClient__QosAssignment_7_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_2_0()); } - rulePublisher - { after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_2_0()); } + { before(grammarAccess.getActionClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } + ruleQualityOfService + { after(grammarAccess.getActionClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__PublisherAssignment_5_3_1 +rule__Parameter__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_3_1_0()); } - rulePublisher - { after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_3_1_0()); } + { before(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__SubscriberAssignment_6_2 +rule__Parameter__TypeAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_2_0()); } - ruleSubscriber - { after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_2_0()); } + { before(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); } + ruleParameterType + { after(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__SubscriberAssignment_6_3_1 +rule__Parameter__NamespaceAssignment_6_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_3_1_0()); } - ruleSubscriber - { after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_3_1_0()); } + { before(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + ruleNamespace + { after(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__ServiceclientAssignment_7_2 +rule__Parameter__QosAssignment_7_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_2_0()); } - ruleServiceClient - { after(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_2_0()); } + { before(grammarAccess.getParameterAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } + ruleQualityOfService + { after(grammarAccess.getParameterAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__ServiceclientAssignment_7_3_1 +rule__Package_Impl__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_3_1_0()); } - ruleServiceClient - { after(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_3_1_0()); } + { before(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); } + ruleRosNames + { after(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__ActionserverAssignment_8_2 +rule__Package_Impl__FromGitRepoAssignment_4_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_2_0()); } - ruleActionServer - { after(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_2_0()); } + { before(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } + ruleEString + { after(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__ActionserverAssignment_8_3_1 +rule__Package_Impl__SpecAssignment_5_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_3_1_0()); } - ruleActionServer - { after(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_3_1_0()); } + { before(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); } + ruleSpecBase + { after(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__ActionclientAssignment_9_2 +rule__Package_Impl__DependencyAssignment_6_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_2_0()); } - ruleActionClient - { after(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_2_0()); } + { before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); } + ruleDependency + { after(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__ActionclientAssignment_9_3_1 +rule__Package_Impl__DependencyAssignment_6_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_3_1_0()); } - ruleActionClient - { after(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_3_1_0()); } + { before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); } + ruleDependency + { after(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__ParameterAssignment_10_2 +rule__Artifact__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_2_0()); } - ruleParameter - { after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_2_0()); } + { before(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); } + ruleRosNames + { after(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Node__ParameterAssignment_10_3_1 +rule__Artifact__NodeAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_3_1_0()); } - ruleParameter - { after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_3_1_0()); } + { before(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); } + ruleNode + { after(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__NameAssignment_3 +rule__Node__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_3_0()); } - ruleEString - { after(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_3_0()); } + { before(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); } + ruleRosNames + { after(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__ServiceAssignment_5 +rule__Node__PublisherAssignment_3_0_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); } - ( - { before(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } - ruleEString - { after(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } - ) - { after(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); } + { before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); } + rulePublisher + { after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceServer__NamespaceAssignment_6_1 +rule__Node__SubscriberAssignment_3_1_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - ruleNamespace - { after(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + { before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); } + ruleSubscriber + { after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Publisher__NameAssignment_3 +rule__Node__ServiceserverAssignment_3_2_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_3_0()); } - ruleEString - { after(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_3_0()); } + { before(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); } + ruleServiceServer + { after(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Publisher__MessageAssignment_5 +rule__Node__ServiceclientAssignment_3_3_2 @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()); } + { before(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); } + ruleServiceClient + { after(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Publisher__NamespaceAssignment_6_1 +rule__Node__ActionserverAssignment_3_4_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - ruleNamespace - { after(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + { before(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); } + ruleActionServer + { after(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Subscriber__NameAssignment_3 +rule__Node__ActionclientAssignment_3_5_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_3_0()); } - ruleEString - { after(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_3_0()); } + { before(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); } + ruleActionClient + { after(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Subscriber__MessageAssignment_5 +rule__Node__ParameterAssignment_3_6_2 @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()); } + { before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); } + ruleParameter + { after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Subscriber__NamespaceAssignment_6_1 +rule__TopicSpec__NameAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - ruleNamespace - { after(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + { before(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); } + (rule__TopicSpec__NameAlternatives_2_0) + { after(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__NameAssignment_3 +rule__TopicSpec__MessageAssignment_5_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_3_0()); } - ruleEString - { after(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_3_0()); } + { before(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__ServiceAssignment_5 +rule__ServiceSpec__NameAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); } - ( - { before(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } - ruleEString - { after(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); } - ) - { after(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); } + { before(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); } + ruleEString + { after(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ServiceClient__NamespaceAssignment_6_1 +rule__ServiceSpec__RequestAssignment_5_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - ruleNamespace - { after(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + { before(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionServer__NameAssignment_3 +rule__ServiceSpec__ResponseAssignment_7_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_3_0()); } - ruleEString - { after(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_3_0()); } + { before(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionServer__ActionAssignment_5 +rule__ActionSpec__NameAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); } - ( - { before(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } - ruleEString - { after(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } - ) - { after(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); } + { before(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); } + ruleEString + { after(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionServer__NamespaceAssignment_6_1 +rule__ActionSpec__GoalAssignment_5_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - ruleNamespace - { after(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + { before(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionClient__NameAssignment_3 +rule__ActionSpec__ResultAssignment_7_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_3_0()); } - ruleEString - { after(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_3_0()); } + { before(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionClient__ActionAssignment_5 +rule__ActionSpec__FeedbackAssignment_9_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); } - ( - { before(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } - ruleEString - { after(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); } - ) - { after(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); } + { before(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); } + ruleMessageDefinition + { after(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ActionClient__NamespaceAssignment_6_1 +rule__MessageDefinition__MessagePartAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - ruleNamespace - { after(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } + { before(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); } + ruleMessagePart + { after(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); } ) ; finally { @@ -16006,135 +15157,90 @@ finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__PartsAssignment_3_2 +rule__GlobalNamespace__PartsAssignment_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); } + { before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } ruleGraphName - { after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); } + { after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalNamespace__PartsAssignment_3_3_1 +rule__GlobalNamespace__PartsAssignment_2_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); } + { before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } ruleGraphName - { after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); } + { after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__PartsAssignment_3_2 +rule__RelativeNamespace_Impl__PartsAssignment_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_2_0()); } + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); } ruleGraphName - { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_2_0()); } + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelativeNamespace_Impl__PartsAssignment_3_3_1 +rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); } + { before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } ruleGraphName - { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); } + { after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__PartsAssignment_3_2 +rule__PrivateNamespace__PartsAssignment_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); } + { before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } ruleGraphName - { after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); } + { after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrivateNamespace__PartsAssignment_3_3_1 +rule__PrivateNamespace__PartsAssignment_2_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); } + { before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } ruleGraphName - { after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); } - ) -; -finally { - restoreStackSize(stackSize); -} - -rule__Parameter__NameAssignment_3 - @init { - int stackSize = keepStackSize(); - } -: - ( - { before(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_3_0()); } - ruleEString - { after(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_3_0()); } - ) -; -finally { - restoreStackSize(stackSize); -} - -rule__Parameter__NamespaceAssignment_4_1 - @init { - int stackSize = keepStackSize(); - } -: - ( - { before(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_4_1_0()); } - ruleNamespace - { after(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_4_1_0()); } - ) -; -finally { - restoreStackSize(stackSize); -} - -rule__Parameter__TypeAssignment_6 - @init { - int stackSize = keepStackSize(); - } -: - ( - { before(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_6_0()); } - ruleParameterType - { after(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_6_0()); } + { after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } ) ; finally { @@ -16336,15 +15442,15 @@ finally { restoreStackSize(stackSize); } -rule__ParameterAny__ValueAssignment_3_1 +rule__ParameterAny__ValueAssignment_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_3_1_0()); } + { before(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); } ruleEString - { after(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_3_1_0()); } + { after(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); } ) ; finally { @@ -16598,45 +15704,3 @@ rule__ArrayTopicSpecRef__TopicSpecAssignment_0 finally { restoreStackSize(stackSize); } - -RULE_ROS_CONVENTION_A : ('/' RULE_ID|RULE_ID '/')*; - -RULE_ROS_CONVENTION_PARAM : ('/' RULE_STRING|RULE_STRING '/'|'~' RULE_STRING)*; - -fragment RULE_DIGIT : '0'..'9'; - -RULE_BINARY : ('0b'|'0B') ('0'|'1')+; - -RULE_BOOLEAN : ('true'|'false'); - -RULE_DOUBLE : RULE_DECINT ('.' RULE_DIGIT*|('.' RULE_DIGIT*)? ('E'|'e') ('-'|'+')? RULE_DECINT); - -RULE_DECINT : ('0'|'1'..'9' RULE_DIGIT*|'-' '0'..'9' RULE_DIGIT*); - -fragment RULE_DAY : ('1'..'9'|'1'..'3' '0'..'9'); - -fragment RULE_MONTH : ('1'..'9'|'1' '0'..'2'); - -fragment RULE_YEAR : '0'..'2' '0'..'9' '0'..'9' '0'..'9'; - -fragment RULE_HOUR : ('0'..'1' '0'..'9'|'2' '0'..'3'); - -fragment RULE_MIN_SEC : '0'..'5' '0'..'9'; - -RULE_DATE_TIME : RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC; - -RULE_MESSAGE_ASIGMENT : (RULE_ID|RULE_STRING) '=' (RULE_ID|RULE_STRING|RULE_INT|'-' RULE_INT); - -RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; - -fragment RULE_INT : ('0'..'9')+; - -RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); - -RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; - -RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; - -RULE_WS : (' '|'\t'|'\r'|'\n')+; - -RULE_ANY_OTHER : .; diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/internal/InternalRos2Parser.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/internal/InternalRos2Parser.java new file mode 100644 index 000000000..9ec0fa19a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/internal/InternalRos2Parser.java @@ -0,0 +1,46625 @@ +package de.fraunhofer.ipa.ros2.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.ros2.services.Ros2GrammarAccess; + + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalRos2Parser extends AbstractInternalContentAssistParser { + public static final String[] tokenNames = new String[] { + "", "", "", "", "ParameterStructMember", "ExternalDependency", "RelativeNamespace", "PrivateNamespace", "GlobalNamespace", "Transient_local", "Serviceclient", "Serviceserver", "Actionclient", "Actionserver", "Dependencies", "Parameter_qos", "ParameterAny", "FromGitRepo", "Reliability", "Services_qos", "Subscribers", "Best_effort", "Default_qos", "Durability", "Parameters", "Publishers", "Artifacts", "Sensor_qos", "GraphName", "Feedback_1", "Float32_1", "Float64_1", "Keep_last", "Response", "Duration", "Feedback", "History", "Keep_all", "Message_1", "Profile", "Reliable", "Request", "String_2", "Uint16_1", "Uint32_1", "Uint64_1", "Volatile", "Boolean", "Integer", "Action_1", "Default", "Float32", "Float64", "Int16_1", "Int32_1", "Int64_1", "Message", "Result_1", "Service", "Uint8_1", "Array", "Base64", "Double", "Header", "String", "Struct", "Action", "Bool_1", "Byte_1", "Depth", "Int8_1", "Result", "Specs", "String_1", "Uint16", "Uint32", "Uint64", "Goal_1", "Int16", "Int32", "Int64", "Node_1", "Type_1", "Uint8", "Value", "Date", "List", "Bool", "Byte", "Goal", "Int8", "Msg", "Name", "Node", "Qos", "Srv", "Time", "Type", "Any", "Ns", "LeftSquareBracketRightSquareBracket", "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_DIGIT", "RULE_BINARY", "RULE_BOOLEAN", "RULE_DECINT", "RULE_DOUBLE", "RULE_DAY", "RULE_MONTH", "RULE_YEAR", "RULE_HOUR", "RULE_MIN_SEC", "RULE_DATE_TIME", "RULE_INT", "RULE_MESSAGE_ASIGMENT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER" + }; + public static final int Float32_1=30; + public static final int Node=93; + public static final int RULE_DATE_TIME=123; + public static final int Uint64_1=45; + public static final int String=64; + public static final int History=36; + public static final int Int16=78; + public static final int Float32=51; + public static final int Goal=89; + public static final int Bool=87; + public static final int Uint16=74; + public static final int Boolean=47; + public static final int ExternalDependency=5; + public static final int Uint8=83; + public static final int Parameters=24; + public static final int RULE_ID=109; + public static final int Actionclient=12; + public static final int RULE_DIGIT=113; + public static final int GlobalNamespace=8; + public static final int Artifacts=26; + public static final int Node_1=81; + public static final int Int16_1=53; + public static final int Header=63; + public static final int RULE_INT=124; + public static final int Byte=88; + public static final int RULE_ML_COMMENT=126; + public static final int LeftSquareBracket=103; + public static final int Specs=72; + public static final int Base64=61; + public static final int Message_1=38; + public static final int Profile=39; + public static final int Depth=69; + public static final int Comma=101; + public static final int RULE_MESSAGE_ASIGMENT=125; + public static final int Goal_1=77; + public static final int LeftSquareBracketRightSquareBracket=100; + public static final int Int32=79; + public static final int Publishers=25; + public static final int Serviceserver=11; + public static final int Parameter_qos=15; + public static final int RightCurlyBracket=105; + public static final int RULE_DECINT=116; + public static final int Reliable=40; + public static final int Uint32=75; + public static final int FromGitRepo=17; + public static final int Msg=91; + public static final int RULE_HOUR=121; + public static final int Int8=90; + public static final int Default=50; + public static final int Actionserver=13; + public static final int Int8_1=70; + public static final int Uint16_1=43; + public static final int Type=97; + public static final int Float64=52; + public static final int Int32_1=54; + public static final int Result_1=57; + public static final int Keep_all=37; + public static final int RULE_BINARY=114; + public static final int String_1=73; + public static final int Subscribers=20; + public static final int String_2=42; + public static final int RULE_BEGIN=106; + public static final int RULE_DAY=118; + public static final int Services_qos=19; + public static final int RULE_BOOLEAN=115; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=120; + public static final int Feedback_1=29; + public static final int Result=71; + public static final int Name=92; + public static final int RULE_MIN_SEC=122; + public static final int Default_qos=22; + public static final int ParameterAny=16; + public static final int List=86; + public static final int Dependencies=14; + public static final int RightSquareBracket=104; + public static final int PrivateNamespace=7; + public static final int GraphName=28; + public static final int Byte_1=68; + public static final int Float64_1=31; + public static final int Durability=23; + public static final int Duration=34; + public static final int Uint32_1=44; + public static final int Action_1=49; + public static final int Double=62; + public static final int Keep_last=32; + public static final int Type_1=82; + public static final int Value=84; + public static final int Transient_local=9; + public static final int Uint64=76; + public static final int Action=66; + public static final int RULE_END=107; + public static final int Message=56; + public static final int Time=96; + public static final int RULE_STRING=111; + public static final int Best_effort=21; + public static final int Bool_1=67; + public static final int Any=98; + public static final int Struct=65; + public static final int RULE_SL_COMMENT=108; + public static final int Uint8_1=59; + public static final int RULE_DOUBLE=117; + public static final int Feedback=35; + public static final int ParameterStructMember=4; + public static final int Srv=95; + public static final int RULE_ROS_CONVENTION_A=110; + public static final int RULE_ROS_CONVENTION_PARAM=112; + public static final int Colon=102; + public static final int EOF=-1; + public static final int Ns=99; + public static final int RULE_WS=127; + public static final int Request=41; + public static final int Int64_1=55; + public static final int Service=58; + public static final int Sensor_qos=27; + public static final int RULE_ANY_OTHER=128; + public static final int Volatile=46; + public static final int Date=85; + public static final int Response=33; + public static final int Integer=48; + public static final int Array=60; + public static final int Serviceclient=10; + public static final int Qos=94; + public static final int Int64=80; + public static final int RULE_MONTH=119; + public static final int Reliability=18; + + // delegates + // delegators + + + public InternalRos2Parser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public InternalRos2Parser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + + public String[] getTokenNames() { return InternalRos2Parser.tokenNames; } + public String getGrammarFileName() { return "InternalRos2Parser.g"; } + + + private Ros2GrammarAccess grammarAccess; + private final Map tokenNameToValue = new HashMap(); + + { + tokenNameToValue.put("Comma", "','"); + tokenNameToValue.put("Colon", "':'"); + tokenNameToValue.put("LeftSquareBracket", "'['"); + tokenNameToValue.put("RightSquareBracket", "']'"); + tokenNameToValue.put("RightCurlyBracket", "'}'"); + tokenNameToValue.put("LeftSquareBracketRightSquareBracket", "'[]'"); + tokenNameToValue.put("Any", "'Any'"); + tokenNameToValue.put("Ns", "'ns:'"); + tokenNameToValue.put("Date", "'Date'"); + tokenNameToValue.put("List", "'List'"); + tokenNameToValue.put("Bool", "'bool'"); + tokenNameToValue.put("Byte", "'byte'"); + tokenNameToValue.put("Goal", "'goal'"); + tokenNameToValue.put("Int8", "'int8'"); + tokenNameToValue.put("Msg", "'msg:'"); + tokenNameToValue.put("Name", "'name'"); + tokenNameToValue.put("Node", "'node'"); + tokenNameToValue.put("Qos", "'qos:'"); + tokenNameToValue.put("Srv", "'srv:'"); + tokenNameToValue.put("Time", "'time'"); + tokenNameToValue.put("Type", "'type'"); + tokenNameToValue.put("Goal_1", "'goal:'"); + tokenNameToValue.put("Int16", "'int16'"); + tokenNameToValue.put("Int32", "'int32'"); + tokenNameToValue.put("Int64", "'int64'"); + tokenNameToValue.put("Node_1", "'node:'"); + tokenNameToValue.put("Type_1", "'type:'"); + tokenNameToValue.put("Uint8", "'uint8'"); + tokenNameToValue.put("Value", "'value'"); + tokenNameToValue.put("Array", "'Array:'"); + tokenNameToValue.put("Base64", "'Base64'"); + tokenNameToValue.put("Double", "'Double'"); + tokenNameToValue.put("Header", "'Header'"); + tokenNameToValue.put("String", "'String'"); + tokenNameToValue.put("Struct", "'Struct'"); + tokenNameToValue.put("Action", "'action'"); + tokenNameToValue.put("Bool_1", "'bool[]'"); + tokenNameToValue.put("Byte_1", "'byte[]'"); + tokenNameToValue.put("Depth", "'depth:'"); + tokenNameToValue.put("Int8_1", "'int8[]'"); + tokenNameToValue.put("Result", "'result'"); + tokenNameToValue.put("Specs", "'specs:'"); + tokenNameToValue.put("String_1", "'string'"); + tokenNameToValue.put("Uint16", "'uint16'"); + tokenNameToValue.put("Uint32", "'uint32'"); + tokenNameToValue.put("Uint64", "'uint64'"); + tokenNameToValue.put("Boolean", "'Boolean'"); + tokenNameToValue.put("Integer", "'Integer'"); + tokenNameToValue.put("Action_1", "'action:'"); + tokenNameToValue.put("Default", "'default'"); + tokenNameToValue.put("Float32", "'float32'"); + tokenNameToValue.put("Float64", "'float64'"); + tokenNameToValue.put("Int16_1", "'int16[]'"); + tokenNameToValue.put("Int32_1", "'int32[]'"); + tokenNameToValue.put("Int64_1", "'int64[]'"); + tokenNameToValue.put("Message", "'message'"); + tokenNameToValue.put("Result_1", "'result:'"); + tokenNameToValue.put("Service", "'service'"); + tokenNameToValue.put("Uint8_1", "'uint8[]'"); + tokenNameToValue.put("Duration", "'duration'"); + tokenNameToValue.put("Feedback", "'feedback'"); + tokenNameToValue.put("History", "'history:'"); + tokenNameToValue.put("Keep_all", "'keep_all'"); + tokenNameToValue.put("Message_1", "'message:'"); + tokenNameToValue.put("Profile", "'profile:'"); + tokenNameToValue.put("Reliable", "'reliable'"); + tokenNameToValue.put("Request", "'request:'"); + tokenNameToValue.put("String_2", "'string[]'"); + tokenNameToValue.put("Uint16_1", "'uint16[]'"); + tokenNameToValue.put("Uint32_1", "'uint32[]'"); + tokenNameToValue.put("Uint64_1", "'uint64[]'"); + tokenNameToValue.put("Volatile", "'volatile'"); + tokenNameToValue.put("GraphName", "'GraphName'"); + tokenNameToValue.put("Feedback_1", "'feedback:'"); + tokenNameToValue.put("Float32_1", "'float32[]'"); + tokenNameToValue.put("Float64_1", "'float64[]'"); + tokenNameToValue.put("Keep_last", "'keep_last'"); + tokenNameToValue.put("Response", "'response:'"); + tokenNameToValue.put("Artifacts", "'artifacts:'"); + tokenNameToValue.put("Sensor_qos", "'sensor_qos'"); + tokenNameToValue.put("Best_effort", "'best_effort'"); + tokenNameToValue.put("Default_qos", "'default_qos'"); + tokenNameToValue.put("Durability", "'durability:'"); + tokenNameToValue.put("Parameters", "'parameters:'"); + tokenNameToValue.put("Publishers", "'publishers:'"); + tokenNameToValue.put("ParameterAny", "'ParameterAny'"); + tokenNameToValue.put("FromGitRepo", "'fromGitRepo:'"); + tokenNameToValue.put("Reliability", "'reliability:'"); + tokenNameToValue.put("Services_qos", "'services_qos'"); + tokenNameToValue.put("Subscribers", "'subscribers:'"); + tokenNameToValue.put("Actionclient", "'actionclient:'"); + tokenNameToValue.put("Actionserver", "'actionserver:'"); + tokenNameToValue.put("Dependencies", "'dependencies:'"); + tokenNameToValue.put("Parameter_qos", "'parameter_qos'"); + tokenNameToValue.put("Serviceclient", "'serviceclient:'"); + tokenNameToValue.put("Serviceserver", "'serviceserver:'"); + tokenNameToValue.put("GlobalNamespace", "'GlobalNamespace'"); + tokenNameToValue.put("Transient_local", "'transient_local'"); + tokenNameToValue.put("PrivateNamespace", "'PrivateNamespace'"); + tokenNameToValue.put("RelativeNamespace", "'RelativeNamespace'"); + tokenNameToValue.put("ExternalDependency", "'ExternalDependency'"); + tokenNameToValue.put("ParameterStructMember", "'ParameterStructMember'"); + } + + public void setGrammarAccess(Ros2GrammarAccess 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 "entryRulePackage" + // InternalRos2Parser.g:157:1: entryRulePackage : rulePackage EOF ; + public final void entryRulePackage() throws RecognitionException { + try { + // InternalRos2Parser.g:158:1: ( rulePackage EOF ) + // InternalRos2Parser.g:159:1: rulePackage EOF + { + before(grammarAccess.getPackageRule()); + pushFollow(FOLLOW_1); + rulePackage(); + + state._fsp--; + + after(grammarAccess.getPackageRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulePackage" + + + // $ANTLR start "rulePackage" + // InternalRos2Parser.g:166:1: rulePackage : ( ruleAmentPackage ) ; + public final void rulePackage() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:170:2: ( ( ruleAmentPackage ) ) + // InternalRos2Parser.g:171:2: ( ruleAmentPackage ) + { + // InternalRos2Parser.g:171:2: ( ruleAmentPackage ) + // InternalRos2Parser.g:172:3: ruleAmentPackage + { + before(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall()); + pushFollow(FOLLOW_2); + ruleAmentPackage(); + + state._fsp--; + + after(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulePackage" + + + // $ANTLR start "entryRuleAmentPackage" + // InternalRos2Parser.g:182:1: entryRuleAmentPackage : ruleAmentPackage EOF ; + public final void entryRuleAmentPackage() throws RecognitionException { + try { + // InternalRos2Parser.g:183:1: ( ruleAmentPackage EOF ) + // InternalRos2Parser.g:184:1: ruleAmentPackage EOF + { + before(grammarAccess.getAmentPackageRule()); + pushFollow(FOLLOW_1); + ruleAmentPackage(); + + state._fsp--; + + after(grammarAccess.getAmentPackageRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleAmentPackage" + + + // $ANTLR start "ruleAmentPackage" + // InternalRos2Parser.g:191:1: ruleAmentPackage : ( ( rule__AmentPackage__Group__0 ) ) ; + public final void ruleAmentPackage() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:195:2: ( ( ( rule__AmentPackage__Group__0 ) ) ) + // InternalRos2Parser.g:196:2: ( ( rule__AmentPackage__Group__0 ) ) + { + // InternalRos2Parser.g:196:2: ( ( rule__AmentPackage__Group__0 ) ) + // InternalRos2Parser.g:197:3: ( rule__AmentPackage__Group__0 ) + { + before(grammarAccess.getAmentPackageAccess().getGroup()); + // InternalRos2Parser.g:198:3: ( rule__AmentPackage__Group__0 ) + // InternalRos2Parser.g:198:4: rule__AmentPackage__Group__0 + { + pushFollow(FOLLOW_2); + rule__AmentPackage__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getAmentPackageAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleAmentPackage" + + + // $ANTLR start "entryRuleQualityOfService" + // InternalRos2Parser.g:207:1: entryRuleQualityOfService : ruleQualityOfService EOF ; + public final void entryRuleQualityOfService() throws RecognitionException { + try { + // InternalRos2Parser.g:208:1: ( ruleQualityOfService EOF ) + // InternalRos2Parser.g:209:1: ruleQualityOfService EOF + { + before(grammarAccess.getQualityOfServiceRule()); + pushFollow(FOLLOW_1); + ruleQualityOfService(); + + state._fsp--; + + after(grammarAccess.getQualityOfServiceRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleQualityOfService" + + + // $ANTLR start "ruleQualityOfService" + // InternalRos2Parser.g:216:1: ruleQualityOfService : ( ( rule__QualityOfService__Group__0 ) ) ; + public final void ruleQualityOfService() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:220:2: ( ( ( rule__QualityOfService__Group__0 ) ) ) + // InternalRos2Parser.g:221:2: ( ( rule__QualityOfService__Group__0 ) ) + { + // InternalRos2Parser.g:221:2: ( ( rule__QualityOfService__Group__0 ) ) + // InternalRos2Parser.g:222:3: ( rule__QualityOfService__Group__0 ) + { + before(grammarAccess.getQualityOfServiceAccess().getGroup()); + // InternalRos2Parser.g:223:3: ( rule__QualityOfService__Group__0 ) + // InternalRos2Parser.g:223:4: rule__QualityOfService__Group__0 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleQualityOfService" + + + // $ANTLR start "entryRulePublisher" + // InternalRos2Parser.g:232:1: entryRulePublisher : rulePublisher EOF ; + public final void entryRulePublisher() throws RecognitionException { + try { + // InternalRos2Parser.g:233:1: ( rulePublisher EOF ) + // InternalRos2Parser.g:234: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" + // InternalRos2Parser.g:241:1: rulePublisher : ( ( rule__Publisher__Group__0 ) ) ; + public final void rulePublisher() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:245:2: ( ( ( rule__Publisher__Group__0 ) ) ) + // InternalRos2Parser.g:246:2: ( ( rule__Publisher__Group__0 ) ) + { + // InternalRos2Parser.g:246:2: ( ( rule__Publisher__Group__0 ) ) + // InternalRos2Parser.g:247:3: ( rule__Publisher__Group__0 ) + { + before(grammarAccess.getPublisherAccess().getGroup()); + // InternalRos2Parser.g:248:3: ( rule__Publisher__Group__0 ) + // InternalRos2Parser.g:248: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" + // InternalRos2Parser.g:257:1: entryRuleSubscriber : ruleSubscriber EOF ; + public final void entryRuleSubscriber() throws RecognitionException { + try { + // InternalRos2Parser.g:258:1: ( ruleSubscriber EOF ) + // InternalRos2Parser.g:259: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" + // InternalRos2Parser.g:266:1: ruleSubscriber : ( ( rule__Subscriber__Group__0 ) ) ; + public final void ruleSubscriber() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:270:2: ( ( ( rule__Subscriber__Group__0 ) ) ) + // InternalRos2Parser.g:271:2: ( ( rule__Subscriber__Group__0 ) ) + { + // InternalRos2Parser.g:271:2: ( ( rule__Subscriber__Group__0 ) ) + // InternalRos2Parser.g:272:3: ( rule__Subscriber__Group__0 ) + { + before(grammarAccess.getSubscriberAccess().getGroup()); + // InternalRos2Parser.g:273:3: ( rule__Subscriber__Group__0 ) + // InternalRos2Parser.g:273: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 "entryRuleServiceServer" + // InternalRos2Parser.g:282:1: entryRuleServiceServer : ruleServiceServer EOF ; + public final void entryRuleServiceServer() throws RecognitionException { + try { + // InternalRos2Parser.g:283:1: ( ruleServiceServer EOF ) + // InternalRos2Parser.g:284:1: ruleServiceServer EOF + { + before(grammarAccess.getServiceServerRule()); + pushFollow(FOLLOW_1); + ruleServiceServer(); + + state._fsp--; + + after(grammarAccess.getServiceServerRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleServiceServer" + + + // $ANTLR start "ruleServiceServer" + // InternalRos2Parser.g:291:1: ruleServiceServer : ( ( rule__ServiceServer__Group__0 ) ) ; + public final void ruleServiceServer() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:295:2: ( ( ( rule__ServiceServer__Group__0 ) ) ) + // InternalRos2Parser.g:296:2: ( ( rule__ServiceServer__Group__0 ) ) + { + // InternalRos2Parser.g:296:2: ( ( rule__ServiceServer__Group__0 ) ) + // InternalRos2Parser.g:297:3: ( rule__ServiceServer__Group__0 ) + { + before(grammarAccess.getServiceServerAccess().getGroup()); + // InternalRos2Parser.g:298:3: ( rule__ServiceServer__Group__0 ) + // InternalRos2Parser.g:298:4: rule__ServiceServer__Group__0 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceServerAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleServiceServer" + + + // $ANTLR start "entryRuleServiceClient" + // InternalRos2Parser.g:307:1: entryRuleServiceClient : ruleServiceClient EOF ; + public final void entryRuleServiceClient() throws RecognitionException { + try { + // InternalRos2Parser.g:308:1: ( ruleServiceClient EOF ) + // InternalRos2Parser.g:309:1: ruleServiceClient EOF + { + before(grammarAccess.getServiceClientRule()); + pushFollow(FOLLOW_1); + ruleServiceClient(); + + state._fsp--; + + after(grammarAccess.getServiceClientRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleServiceClient" + + + // $ANTLR start "ruleServiceClient" + // InternalRos2Parser.g:316:1: ruleServiceClient : ( ( rule__ServiceClient__Group__0 ) ) ; + public final void ruleServiceClient() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:320:2: ( ( ( rule__ServiceClient__Group__0 ) ) ) + // InternalRos2Parser.g:321:2: ( ( rule__ServiceClient__Group__0 ) ) + { + // InternalRos2Parser.g:321:2: ( ( rule__ServiceClient__Group__0 ) ) + // InternalRos2Parser.g:322:3: ( rule__ServiceClient__Group__0 ) + { + before(grammarAccess.getServiceClientAccess().getGroup()); + // InternalRos2Parser.g:323:3: ( rule__ServiceClient__Group__0 ) + // InternalRos2Parser.g:323:4: rule__ServiceClient__Group__0 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceClientAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleServiceClient" + + + // $ANTLR start "entryRuleActionServer" + // InternalRos2Parser.g:332:1: entryRuleActionServer : ruleActionServer EOF ; + public final void entryRuleActionServer() throws RecognitionException { + try { + // InternalRos2Parser.g:333:1: ( ruleActionServer EOF ) + // InternalRos2Parser.g:334:1: ruleActionServer EOF + { + before(grammarAccess.getActionServerRule()); + pushFollow(FOLLOW_1); + ruleActionServer(); + + state._fsp--; + + after(grammarAccess.getActionServerRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleActionServer" + + + // $ANTLR start "ruleActionServer" + // InternalRos2Parser.g:341:1: ruleActionServer : ( ( rule__ActionServer__Group__0 ) ) ; + public final void ruleActionServer() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:345:2: ( ( ( rule__ActionServer__Group__0 ) ) ) + // InternalRos2Parser.g:346:2: ( ( rule__ActionServer__Group__0 ) ) + { + // InternalRos2Parser.g:346:2: ( ( rule__ActionServer__Group__0 ) ) + // InternalRos2Parser.g:347:3: ( rule__ActionServer__Group__0 ) + { + before(grammarAccess.getActionServerAccess().getGroup()); + // InternalRos2Parser.g:348:3: ( rule__ActionServer__Group__0 ) + // InternalRos2Parser.g:348:4: rule__ActionServer__Group__0 + { + pushFollow(FOLLOW_2); + rule__ActionServer__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getActionServerAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleActionServer" + + + // $ANTLR start "entryRuleActionClient" + // InternalRos2Parser.g:357:1: entryRuleActionClient : ruleActionClient EOF ; + public final void entryRuleActionClient() throws RecognitionException { + try { + // InternalRos2Parser.g:358:1: ( ruleActionClient EOF ) + // InternalRos2Parser.g:359:1: ruleActionClient EOF + { + before(grammarAccess.getActionClientRule()); + pushFollow(FOLLOW_1); + ruleActionClient(); + + state._fsp--; + + after(grammarAccess.getActionClientRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleActionClient" + + + // $ANTLR start "ruleActionClient" + // InternalRos2Parser.g:366:1: ruleActionClient : ( ( rule__ActionClient__Group__0 ) ) ; + public final void ruleActionClient() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:370:2: ( ( ( rule__ActionClient__Group__0 ) ) ) + // InternalRos2Parser.g:371:2: ( ( rule__ActionClient__Group__0 ) ) + { + // InternalRos2Parser.g:371:2: ( ( rule__ActionClient__Group__0 ) ) + // InternalRos2Parser.g:372:3: ( rule__ActionClient__Group__0 ) + { + before(grammarAccess.getActionClientAccess().getGroup()); + // InternalRos2Parser.g:373:3: ( rule__ActionClient__Group__0 ) + // InternalRos2Parser.g:373:4: rule__ActionClient__Group__0 + { + pushFollow(FOLLOW_2); + rule__ActionClient__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getActionClientAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleActionClient" + + + // $ANTLR start "entryRuleParameter" + // InternalRos2Parser.g:382:1: entryRuleParameter : ruleParameter EOF ; + public final void entryRuleParameter() throws RecognitionException { + try { + // InternalRos2Parser.g:383:1: ( ruleParameter EOF ) + // InternalRos2Parser.g:384: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" + // InternalRos2Parser.g:391:1: ruleParameter : ( ( rule__Parameter__Group__0 ) ) ; + public final void ruleParameter() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:395:2: ( ( ( rule__Parameter__Group__0 ) ) ) + // InternalRos2Parser.g:396:2: ( ( rule__Parameter__Group__0 ) ) + { + // InternalRos2Parser.g:396:2: ( ( rule__Parameter__Group__0 ) ) + // InternalRos2Parser.g:397:3: ( rule__Parameter__Group__0 ) + { + before(grammarAccess.getParameterAccess().getGroup()); + // InternalRos2Parser.g:398:3: ( rule__Parameter__Group__0 ) + // InternalRos2Parser.g:398: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 "entryRuleEString" + // InternalRos2Parser.g:407:1: entryRuleEString : ruleEString EOF ; + public final void entryRuleEString() throws RecognitionException { + try { + // InternalRos2Parser.g:408:1: ( ruleEString EOF ) + // InternalRos2Parser.g:409: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" + // InternalRos2Parser.g:416:1: ruleEString : ( ( rule__EString__Alternatives ) ) ; + public final void ruleEString() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:420:2: ( ( ( rule__EString__Alternatives ) ) ) + // InternalRos2Parser.g:421:2: ( ( rule__EString__Alternatives ) ) + { + // InternalRos2Parser.g:421:2: ( ( rule__EString__Alternatives ) ) + // InternalRos2Parser.g:422:3: ( rule__EString__Alternatives ) + { + before(grammarAccess.getEStringAccess().getAlternatives()); + // InternalRos2Parser.g:423:3: ( rule__EString__Alternatives ) + // InternalRos2Parser.g:423: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 "entryRuleRosNames" + // InternalRos2Parser.g:432:1: entryRuleRosNames : ruleRosNames EOF ; + public final void entryRuleRosNames() throws RecognitionException { + try { + // InternalRos2Parser.g:433:1: ( ruleRosNames EOF ) + // InternalRos2Parser.g:434: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" + // InternalRos2Parser.g:441:1: ruleRosNames : ( ( rule__RosNames__Alternatives ) ) ; + public final void ruleRosNames() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:445:2: ( ( ( rule__RosNames__Alternatives ) ) ) + // InternalRos2Parser.g:446:2: ( ( rule__RosNames__Alternatives ) ) + { + // InternalRos2Parser.g:446:2: ( ( rule__RosNames__Alternatives ) ) + // InternalRos2Parser.g:447:3: ( rule__RosNames__Alternatives ) + { + before(grammarAccess.getRosNamesAccess().getAlternatives()); + // InternalRos2Parser.g:448:3: ( rule__RosNames__Alternatives ) + // InternalRos2Parser.g:448: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 "entryRulePackage_Impl" + // InternalRos2Parser.g:457:1: entryRulePackage_Impl : rulePackage_Impl EOF ; + public final void entryRulePackage_Impl() throws RecognitionException { + try { + // InternalRos2Parser.g:458:1: ( rulePackage_Impl EOF ) + // InternalRos2Parser.g:459:1: rulePackage_Impl EOF + { + before(grammarAccess.getPackage_ImplRule()); + pushFollow(FOLLOW_1); + rulePackage_Impl(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulePackage_Impl" + + + // $ANTLR start "rulePackage_Impl" + // InternalRos2Parser.g:466:1: rulePackage_Impl : ( ( rule__Package_Impl__Group__0 ) ) ; + public final void rulePackage_Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:470:2: ( ( ( rule__Package_Impl__Group__0 ) ) ) + // InternalRos2Parser.g:471:2: ( ( rule__Package_Impl__Group__0 ) ) + { + // InternalRos2Parser.g:471:2: ( ( rule__Package_Impl__Group__0 ) ) + // InternalRos2Parser.g:472:3: ( rule__Package_Impl__Group__0 ) + { + before(grammarAccess.getPackage_ImplAccess().getGroup()); + // InternalRos2Parser.g:473:3: ( rule__Package_Impl__Group__0 ) + // InternalRos2Parser.g:473:4: rule__Package_Impl__Group__0 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulePackage_Impl" + + + // $ANTLR start "entryRuleArtifact" + // InternalRos2Parser.g:482:1: entryRuleArtifact : ruleArtifact EOF ; + public final void entryRuleArtifact() throws RecognitionException { + try { + // InternalRos2Parser.g:483:1: ( ruleArtifact EOF ) + // InternalRos2Parser.g:484: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" + // InternalRos2Parser.g:491:1: ruleArtifact : ( ( rule__Artifact__Group__0 ) ) ; + public final void ruleArtifact() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:495:2: ( ( ( rule__Artifact__Group__0 ) ) ) + // InternalRos2Parser.g:496:2: ( ( rule__Artifact__Group__0 ) ) + { + // InternalRos2Parser.g:496:2: ( ( rule__Artifact__Group__0 ) ) + // InternalRos2Parser.g:497:3: ( rule__Artifact__Group__0 ) + { + before(grammarAccess.getArtifactAccess().getGroup()); + // InternalRos2Parser.g:498:3: ( rule__Artifact__Group__0 ) + // InternalRos2Parser.g:498: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" + // InternalRos2Parser.g:507:1: entryRuleNode : ruleNode EOF ; + public final void entryRuleNode() throws RecognitionException { + try { + // InternalRos2Parser.g:508:1: ( ruleNode EOF ) + // InternalRos2Parser.g:509: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" + // InternalRos2Parser.g:516:1: ruleNode : ( ( rule__Node__Group__0 ) ) ; + public final void ruleNode() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:520:2: ( ( ( rule__Node__Group__0 ) ) ) + // InternalRos2Parser.g:521:2: ( ( rule__Node__Group__0 ) ) + { + // InternalRos2Parser.g:521:2: ( ( rule__Node__Group__0 ) ) + // InternalRos2Parser.g:522:3: ( rule__Node__Group__0 ) + { + before(grammarAccess.getNodeAccess().getGroup()); + // InternalRos2Parser.g:523:3: ( rule__Node__Group__0 ) + // InternalRos2Parser.g:523: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 "entryRuleSpecBase" + // InternalRos2Parser.g:532:1: entryRuleSpecBase : ruleSpecBase EOF ; + public final void entryRuleSpecBase() throws RecognitionException { + try { + // InternalRos2Parser.g:533:1: ( ruleSpecBase EOF ) + // InternalRos2Parser.g:534:1: ruleSpecBase EOF + { + before(grammarAccess.getSpecBaseRule()); + pushFollow(FOLLOW_1); + ruleSpecBase(); + + state._fsp--; + + after(grammarAccess.getSpecBaseRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleSpecBase" + + + // $ANTLR start "ruleSpecBase" + // InternalRos2Parser.g:541:1: ruleSpecBase : ( ( rule__SpecBase__Alternatives ) ) ; + public final void ruleSpecBase() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:545:2: ( ( ( rule__SpecBase__Alternatives ) ) ) + // InternalRos2Parser.g:546:2: ( ( rule__SpecBase__Alternatives ) ) + { + // InternalRos2Parser.g:546:2: ( ( rule__SpecBase__Alternatives ) ) + // InternalRos2Parser.g:547:3: ( rule__SpecBase__Alternatives ) + { + before(grammarAccess.getSpecBaseAccess().getAlternatives()); + // InternalRos2Parser.g:548:3: ( rule__SpecBase__Alternatives ) + // InternalRos2Parser.g:548:4: rule__SpecBase__Alternatives + { + pushFollow(FOLLOW_2); + rule__SpecBase__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getSpecBaseAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleSpecBase" + + + // $ANTLR start "entryRuleTopicSpec" + // InternalRos2Parser.g:557:1: entryRuleTopicSpec : ruleTopicSpec EOF ; + public final void entryRuleTopicSpec() throws RecognitionException { + try { + // InternalRos2Parser.g:558:1: ( ruleTopicSpec EOF ) + // InternalRos2Parser.g:559:1: ruleTopicSpec EOF + { + before(grammarAccess.getTopicSpecRule()); + pushFollow(FOLLOW_1); + ruleTopicSpec(); + + state._fsp--; + + after(grammarAccess.getTopicSpecRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleTopicSpec" + + + // $ANTLR start "ruleTopicSpec" + // InternalRos2Parser.g:566:1: ruleTopicSpec : ( ( rule__TopicSpec__Group__0 ) ) ; + public final void ruleTopicSpec() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:570:2: ( ( ( rule__TopicSpec__Group__0 ) ) ) + // InternalRos2Parser.g:571:2: ( ( rule__TopicSpec__Group__0 ) ) + { + // InternalRos2Parser.g:571:2: ( ( rule__TopicSpec__Group__0 ) ) + // InternalRos2Parser.g:572:3: ( rule__TopicSpec__Group__0 ) + { + before(grammarAccess.getTopicSpecAccess().getGroup()); + // InternalRos2Parser.g:573:3: ( rule__TopicSpec__Group__0 ) + // InternalRos2Parser.g:573:4: rule__TopicSpec__Group__0 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getTopicSpecAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleTopicSpec" + + + // $ANTLR start "entryRuleServiceSpec" + // InternalRos2Parser.g:582:1: entryRuleServiceSpec : ruleServiceSpec EOF ; + public final void entryRuleServiceSpec() throws RecognitionException { + try { + // InternalRos2Parser.g:583:1: ( ruleServiceSpec EOF ) + // InternalRos2Parser.g:584:1: ruleServiceSpec EOF + { + before(grammarAccess.getServiceSpecRule()); + pushFollow(FOLLOW_1); + ruleServiceSpec(); + + state._fsp--; + + after(grammarAccess.getServiceSpecRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleServiceSpec" + + + // $ANTLR start "ruleServiceSpec" + // InternalRos2Parser.g:591:1: ruleServiceSpec : ( ( rule__ServiceSpec__Group__0 ) ) ; + public final void ruleServiceSpec() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:595:2: ( ( ( rule__ServiceSpec__Group__0 ) ) ) + // InternalRos2Parser.g:596:2: ( ( rule__ServiceSpec__Group__0 ) ) + { + // InternalRos2Parser.g:596:2: ( ( rule__ServiceSpec__Group__0 ) ) + // InternalRos2Parser.g:597:3: ( rule__ServiceSpec__Group__0 ) + { + before(grammarAccess.getServiceSpecAccess().getGroup()); + // InternalRos2Parser.g:598:3: ( rule__ServiceSpec__Group__0 ) + // InternalRos2Parser.g:598:4: rule__ServiceSpec__Group__0 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceSpecAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleServiceSpec" + + + // $ANTLR start "entryRuleActionSpec" + // InternalRos2Parser.g:607:1: entryRuleActionSpec : ruleActionSpec EOF ; + public final void entryRuleActionSpec() throws RecognitionException { + try { + // InternalRos2Parser.g:608:1: ( ruleActionSpec EOF ) + // InternalRos2Parser.g:609:1: ruleActionSpec EOF + { + before(grammarAccess.getActionSpecRule()); + pushFollow(FOLLOW_1); + ruleActionSpec(); + + state._fsp--; + + after(grammarAccess.getActionSpecRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleActionSpec" + + + // $ANTLR start "ruleActionSpec" + // InternalRos2Parser.g:616:1: ruleActionSpec : ( ( rule__ActionSpec__Group__0 ) ) ; + public final void ruleActionSpec() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:620:2: ( ( ( rule__ActionSpec__Group__0 ) ) ) + // InternalRos2Parser.g:621:2: ( ( rule__ActionSpec__Group__0 ) ) + { + // InternalRos2Parser.g:621:2: ( ( rule__ActionSpec__Group__0 ) ) + // InternalRos2Parser.g:622:3: ( rule__ActionSpec__Group__0 ) + { + before(grammarAccess.getActionSpecAccess().getGroup()); + // InternalRos2Parser.g:623:3: ( rule__ActionSpec__Group__0 ) + // InternalRos2Parser.g:623:4: rule__ActionSpec__Group__0 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getActionSpecAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleActionSpec" + + + // $ANTLR start "entryRuleMessageDefinition" + // InternalRos2Parser.g:632:1: entryRuleMessageDefinition : ruleMessageDefinition EOF ; + public final void entryRuleMessageDefinition() throws RecognitionException { + try { + // InternalRos2Parser.g:633:1: ( ruleMessageDefinition EOF ) + // InternalRos2Parser.g:634:1: ruleMessageDefinition EOF + { + before(grammarAccess.getMessageDefinitionRule()); + pushFollow(FOLLOW_1); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getMessageDefinitionRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleMessageDefinition" + + + // $ANTLR start "ruleMessageDefinition" + // InternalRos2Parser.g:641:1: ruleMessageDefinition : ( ( rule__MessageDefinition__Group__0 ) ) ; + public final void ruleMessageDefinition() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:645:2: ( ( ( rule__MessageDefinition__Group__0 ) ) ) + // InternalRos2Parser.g:646:2: ( ( rule__MessageDefinition__Group__0 ) ) + { + // InternalRos2Parser.g:646:2: ( ( rule__MessageDefinition__Group__0 ) ) + // InternalRos2Parser.g:647:3: ( rule__MessageDefinition__Group__0 ) + { + before(grammarAccess.getMessageDefinitionAccess().getGroup()); + // InternalRos2Parser.g:648:3: ( rule__MessageDefinition__Group__0 ) + // InternalRos2Parser.g:648:4: rule__MessageDefinition__Group__0 + { + pushFollow(FOLLOW_2); + rule__MessageDefinition__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getMessageDefinitionAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleMessageDefinition" + + + // $ANTLR start "entryRuleDependency" + // InternalRos2Parser.g:657:1: entryRuleDependency : ruleDependency EOF ; + public final void entryRuleDependency() throws RecognitionException { + try { + // InternalRos2Parser.g:658:1: ( ruleDependency EOF ) + // InternalRos2Parser.g:659: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" + // InternalRos2Parser.g:666:1: ruleDependency : ( ( rule__Dependency__Alternatives ) ) ; + public final void ruleDependency() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:670:2: ( ( ( rule__Dependency__Alternatives ) ) ) + // InternalRos2Parser.g:671:2: ( ( rule__Dependency__Alternatives ) ) + { + // InternalRos2Parser.g:671:2: ( ( rule__Dependency__Alternatives ) ) + // InternalRos2Parser.g:672:3: ( rule__Dependency__Alternatives ) + { + before(grammarAccess.getDependencyAccess().getAlternatives()); + // InternalRos2Parser.g:673:3: ( rule__Dependency__Alternatives ) + // InternalRos2Parser.g:673: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" + // InternalRos2Parser.g:682:1: entryRulePackageDependency : rulePackageDependency EOF ; + public final void entryRulePackageDependency() throws RecognitionException { + try { + // InternalRos2Parser.g:683:1: ( rulePackageDependency EOF ) + // InternalRos2Parser.g:684: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" + // InternalRos2Parser.g:691:1: rulePackageDependency : ( ( rule__PackageDependency__PackageAssignment ) ) ; + public final void rulePackageDependency() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:695:2: ( ( ( rule__PackageDependency__PackageAssignment ) ) ) + // InternalRos2Parser.g:696:2: ( ( rule__PackageDependency__PackageAssignment ) ) + { + // InternalRos2Parser.g:696:2: ( ( rule__PackageDependency__PackageAssignment ) ) + // InternalRos2Parser.g:697:3: ( rule__PackageDependency__PackageAssignment ) + { + before(grammarAccess.getPackageDependencyAccess().getPackageAssignment()); + // InternalRos2Parser.g:698:3: ( rule__PackageDependency__PackageAssignment ) + // InternalRos2Parser.g:698: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" + // InternalRos2Parser.g:707:1: entryRuleExternalDependency : ruleExternalDependency EOF ; + public final void entryRuleExternalDependency() throws RecognitionException { + try { + // InternalRos2Parser.g:708:1: ( ruleExternalDependency EOF ) + // InternalRos2Parser.g:709: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" + // InternalRos2Parser.g:716:1: ruleExternalDependency : ( ( rule__ExternalDependency__Group__0 ) ) ; + public final void ruleExternalDependency() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:720:2: ( ( ( rule__ExternalDependency__Group__0 ) ) ) + // InternalRos2Parser.g:721:2: ( ( rule__ExternalDependency__Group__0 ) ) + { + // InternalRos2Parser.g:721:2: ( ( rule__ExternalDependency__Group__0 ) ) + // InternalRos2Parser.g:722:3: ( rule__ExternalDependency__Group__0 ) + { + before(grammarAccess.getExternalDependencyAccess().getGroup()); + // InternalRos2Parser.g:723:3: ( rule__ExternalDependency__Group__0 ) + // InternalRos2Parser.g:723: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 "entryRuleNamespace" + // InternalRos2Parser.g:732:1: entryRuleNamespace : ruleNamespace EOF ; + public final void entryRuleNamespace() throws RecognitionException { + try { + // InternalRos2Parser.g:733:1: ( ruleNamespace EOF ) + // InternalRos2Parser.g:734:1: ruleNamespace EOF + { + before(grammarAccess.getNamespaceRule()); + pushFollow(FOLLOW_1); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getNamespaceRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleNamespace" + + + // $ANTLR start "ruleNamespace" + // InternalRos2Parser.g:741:1: ruleNamespace : ( ( rule__Namespace__Alternatives ) ) ; + public final void ruleNamespace() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:745:2: ( ( ( rule__Namespace__Alternatives ) ) ) + // InternalRos2Parser.g:746:2: ( ( rule__Namespace__Alternatives ) ) + { + // InternalRos2Parser.g:746:2: ( ( rule__Namespace__Alternatives ) ) + // InternalRos2Parser.g:747:3: ( rule__Namespace__Alternatives ) + { + before(grammarAccess.getNamespaceAccess().getAlternatives()); + // InternalRos2Parser.g:748:3: ( rule__Namespace__Alternatives ) + // InternalRos2Parser.g:748:4: rule__Namespace__Alternatives + { + pushFollow(FOLLOW_2); + rule__Namespace__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getNamespaceAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleNamespace" + + + // $ANTLR start "entryRuleGraphName" + // InternalRos2Parser.g:757:1: entryRuleGraphName : ruleGraphName EOF ; + public final void entryRuleGraphName() throws RecognitionException { + try { + // InternalRos2Parser.g:758:1: ( ruleGraphName EOF ) + // InternalRos2Parser.g:759:1: ruleGraphName EOF + { + before(grammarAccess.getGraphNameRule()); + pushFollow(FOLLOW_1); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getGraphNameRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleGraphName" + + + // $ANTLR start "ruleGraphName" + // InternalRos2Parser.g:766:1: ruleGraphName : ( GraphName ) ; + public final void ruleGraphName() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:770:2: ( ( GraphName ) ) + // InternalRos2Parser.g:771:2: ( GraphName ) + { + // InternalRos2Parser.g:771:2: ( GraphName ) + // InternalRos2Parser.g:772:3: GraphName + { + before(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + match(input,GraphName,FOLLOW_2); + after(grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleGraphName" + + + // $ANTLR start "entryRuleGlobalNamespace" + // InternalRos2Parser.g:782:1: entryRuleGlobalNamespace : ruleGlobalNamespace EOF ; + public final void entryRuleGlobalNamespace() throws RecognitionException { + try { + // InternalRos2Parser.g:783:1: ( ruleGlobalNamespace EOF ) + // InternalRos2Parser.g:784:1: ruleGlobalNamespace EOF + { + before(grammarAccess.getGlobalNamespaceRule()); + pushFollow(FOLLOW_1); + ruleGlobalNamespace(); + + state._fsp--; + + after(grammarAccess.getGlobalNamespaceRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleGlobalNamespace" + + + // $ANTLR start "ruleGlobalNamespace" + // InternalRos2Parser.g:791:1: ruleGlobalNamespace : ( ( rule__GlobalNamespace__Group__0 ) ) ; + public final void ruleGlobalNamespace() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:795:2: ( ( ( rule__GlobalNamespace__Group__0 ) ) ) + // InternalRos2Parser.g:796:2: ( ( rule__GlobalNamespace__Group__0 ) ) + { + // InternalRos2Parser.g:796:2: ( ( rule__GlobalNamespace__Group__0 ) ) + // InternalRos2Parser.g:797:3: ( rule__GlobalNamespace__Group__0 ) + { + before(grammarAccess.getGlobalNamespaceAccess().getGroup()); + // InternalRos2Parser.g:798:3: ( rule__GlobalNamespace__Group__0 ) + // InternalRos2Parser.g:798:4: rule__GlobalNamespace__Group__0 + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getGlobalNamespaceAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleGlobalNamespace" + + + // $ANTLR start "entryRuleRelativeNamespace_Impl" + // InternalRos2Parser.g:807:1: entryRuleRelativeNamespace_Impl : ruleRelativeNamespace_Impl EOF ; + public final void entryRuleRelativeNamespace_Impl() throws RecognitionException { + try { + // InternalRos2Parser.g:808:1: ( ruleRelativeNamespace_Impl EOF ) + // InternalRos2Parser.g:809:1: ruleRelativeNamespace_Impl EOF + { + before(grammarAccess.getRelativeNamespace_ImplRule()); + pushFollow(FOLLOW_1); + ruleRelativeNamespace_Impl(); + + state._fsp--; + + after(grammarAccess.getRelativeNamespace_ImplRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleRelativeNamespace_Impl" + + + // $ANTLR start "ruleRelativeNamespace_Impl" + // InternalRos2Parser.g:816:1: ruleRelativeNamespace_Impl : ( ( rule__RelativeNamespace_Impl__Group__0 ) ) ; + public final void ruleRelativeNamespace_Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:820:2: ( ( ( rule__RelativeNamespace_Impl__Group__0 ) ) ) + // InternalRos2Parser.g:821:2: ( ( rule__RelativeNamespace_Impl__Group__0 ) ) + { + // InternalRos2Parser.g:821:2: ( ( rule__RelativeNamespace_Impl__Group__0 ) ) + // InternalRos2Parser.g:822:3: ( rule__RelativeNamespace_Impl__Group__0 ) + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup()); + // InternalRos2Parser.g:823:3: ( rule__RelativeNamespace_Impl__Group__0 ) + // InternalRos2Parser.g:823:4: rule__RelativeNamespace_Impl__Group__0 + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleRelativeNamespace_Impl" + + + // $ANTLR start "entryRulePrivateNamespace" + // InternalRos2Parser.g:832:1: entryRulePrivateNamespace : rulePrivateNamespace EOF ; + public final void entryRulePrivateNamespace() throws RecognitionException { + try { + // InternalRos2Parser.g:833:1: ( rulePrivateNamespace EOF ) + // InternalRos2Parser.g:834:1: rulePrivateNamespace EOF + { + before(grammarAccess.getPrivateNamespaceRule()); + pushFollow(FOLLOW_1); + rulePrivateNamespace(); + + state._fsp--; + + after(grammarAccess.getPrivateNamespaceRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulePrivateNamespace" + + + // $ANTLR start "rulePrivateNamespace" + // InternalRos2Parser.g:841:1: rulePrivateNamespace : ( ( rule__PrivateNamespace__Group__0 ) ) ; + public final void rulePrivateNamespace() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:845:2: ( ( ( rule__PrivateNamespace__Group__0 ) ) ) + // InternalRos2Parser.g:846:2: ( ( rule__PrivateNamespace__Group__0 ) ) + { + // InternalRos2Parser.g:846:2: ( ( rule__PrivateNamespace__Group__0 ) ) + // InternalRos2Parser.g:847:3: ( rule__PrivateNamespace__Group__0 ) + { + before(grammarAccess.getPrivateNamespaceAccess().getGroup()); + // InternalRos2Parser.g:848:3: ( rule__PrivateNamespace__Group__0 ) + // InternalRos2Parser.g:848:4: rule__PrivateNamespace__Group__0 + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getPrivateNamespaceAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulePrivateNamespace" + + + // $ANTLR start "entryRuleParameterType" + // InternalRos2Parser.g:857:1: entryRuleParameterType : ruleParameterType EOF ; + public final void entryRuleParameterType() throws RecognitionException { + try { + // InternalRos2Parser.g:858:1: ( ruleParameterType EOF ) + // InternalRos2Parser.g:859:1: ruleParameterType EOF + { + before(grammarAccess.getParameterTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterType" + + + // $ANTLR start "ruleParameterType" + // InternalRos2Parser.g:866:1: ruleParameterType : ( ( rule__ParameterType__Alternatives ) ) ; + public final void ruleParameterType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:870:2: ( ( ( rule__ParameterType__Alternatives ) ) ) + // InternalRos2Parser.g:871:2: ( ( rule__ParameterType__Alternatives ) ) + { + // InternalRos2Parser.g:871:2: ( ( rule__ParameterType__Alternatives ) ) + // InternalRos2Parser.g:872:3: ( rule__ParameterType__Alternatives ) + { + before(grammarAccess.getParameterTypeAccess().getAlternatives()); + // InternalRos2Parser.g:873:3: ( rule__ParameterType__Alternatives ) + // InternalRos2Parser.g:873:4: rule__ParameterType__Alternatives + { + pushFollow(FOLLOW_2); + rule__ParameterType__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterTypeAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterType" + + + // $ANTLR start "entryRuleParameterValue" + // InternalRos2Parser.g:882:1: entryRuleParameterValue : ruleParameterValue EOF ; + public final void entryRuleParameterValue() throws RecognitionException { + try { + // InternalRos2Parser.g:883:1: ( ruleParameterValue EOF ) + // InternalRos2Parser.g:884:1: ruleParameterValue EOF + { + before(grammarAccess.getParameterValueRule()); + pushFollow(FOLLOW_1); + ruleParameterValue(); + + state._fsp--; + + after(grammarAccess.getParameterValueRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterValue" + + + // $ANTLR start "ruleParameterValue" + // InternalRos2Parser.g:891:1: ruleParameterValue : ( ( rule__ParameterValue__Alternatives ) ) ; + public final void ruleParameterValue() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:895:2: ( ( ( rule__ParameterValue__Alternatives ) ) ) + // InternalRos2Parser.g:896:2: ( ( rule__ParameterValue__Alternatives ) ) + { + // InternalRos2Parser.g:896:2: ( ( rule__ParameterValue__Alternatives ) ) + // InternalRos2Parser.g:897:3: ( rule__ParameterValue__Alternatives ) + { + before(grammarAccess.getParameterValueAccess().getAlternatives()); + // InternalRos2Parser.g:898:3: ( rule__ParameterValue__Alternatives ) + // InternalRos2Parser.g:898:4: rule__ParameterValue__Alternatives + { + pushFollow(FOLLOW_2); + rule__ParameterValue__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterValueAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterValue" + + + // $ANTLR start "entryRuleParameterListType" + // InternalRos2Parser.g:907:1: entryRuleParameterListType : ruleParameterListType EOF ; + public final void entryRuleParameterListType() throws RecognitionException { + try { + // InternalRos2Parser.g:908:1: ( ruleParameterListType EOF ) + // InternalRos2Parser.g:909:1: ruleParameterListType EOF + { + before(grammarAccess.getParameterListTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterListType(); + + state._fsp--; + + after(grammarAccess.getParameterListTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterListType" + + + // $ANTLR start "ruleParameterListType" + // InternalRos2Parser.g:916:1: ruleParameterListType : ( ( rule__ParameterListType__Group__0 ) ) ; + public final void ruleParameterListType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:920:2: ( ( ( rule__ParameterListType__Group__0 ) ) ) + // InternalRos2Parser.g:921:2: ( ( rule__ParameterListType__Group__0 ) ) + { + // InternalRos2Parser.g:921:2: ( ( rule__ParameterListType__Group__0 ) ) + // InternalRos2Parser.g:922:3: ( rule__ParameterListType__Group__0 ) + { + before(grammarAccess.getParameterListTypeAccess().getGroup()); + // InternalRos2Parser.g:923:3: ( rule__ParameterListType__Group__0 ) + // InternalRos2Parser.g:923:4: rule__ParameterListType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterListType" + + + // $ANTLR start "entryRuleParameterStructType" + // InternalRos2Parser.g:932:1: entryRuleParameterStructType : ruleParameterStructType EOF ; + public final void entryRuleParameterStructType() throws RecognitionException { + try { + // InternalRos2Parser.g:933:1: ( ruleParameterStructType EOF ) + // InternalRos2Parser.g:934:1: ruleParameterStructType EOF + { + before(grammarAccess.getParameterStructTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterStructType(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterStructType" + + + // $ANTLR start "ruleParameterStructType" + // InternalRos2Parser.g:941:1: ruleParameterStructType : ( ( rule__ParameterStructType__Group__0 ) ) ; + public final void ruleParameterStructType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:945:2: ( ( ( rule__ParameterStructType__Group__0 ) ) ) + // InternalRos2Parser.g:946:2: ( ( rule__ParameterStructType__Group__0 ) ) + { + // InternalRos2Parser.g:946:2: ( ( rule__ParameterStructType__Group__0 ) ) + // InternalRos2Parser.g:947:3: ( rule__ParameterStructType__Group__0 ) + { + before(grammarAccess.getParameterStructTypeAccess().getGroup()); + // InternalRos2Parser.g:948:3: ( rule__ParameterStructType__Group__0 ) + // InternalRos2Parser.g:948:4: rule__ParameterStructType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterStructType" + + + // $ANTLR start "entryRuleParameterIntegerType" + // InternalRos2Parser.g:957:1: entryRuleParameterIntegerType : ruleParameterIntegerType EOF ; + public final void entryRuleParameterIntegerType() throws RecognitionException { + try { + // InternalRos2Parser.g:958:1: ( ruleParameterIntegerType EOF ) + // InternalRos2Parser.g:959:1: ruleParameterIntegerType EOF + { + before(grammarAccess.getParameterIntegerTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterIntegerType(); + + state._fsp--; + + after(grammarAccess.getParameterIntegerTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterIntegerType" + + + // $ANTLR start "ruleParameterIntegerType" + // InternalRos2Parser.g:966:1: ruleParameterIntegerType : ( ( rule__ParameterIntegerType__Group__0 ) ) ; + public final void ruleParameterIntegerType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:970:2: ( ( ( rule__ParameterIntegerType__Group__0 ) ) ) + // InternalRos2Parser.g:971:2: ( ( rule__ParameterIntegerType__Group__0 ) ) + { + // InternalRos2Parser.g:971:2: ( ( rule__ParameterIntegerType__Group__0 ) ) + // InternalRos2Parser.g:972:3: ( rule__ParameterIntegerType__Group__0 ) + { + before(grammarAccess.getParameterIntegerTypeAccess().getGroup()); + // InternalRos2Parser.g:973:3: ( rule__ParameterIntegerType__Group__0 ) + // InternalRos2Parser.g:973:4: rule__ParameterIntegerType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterIntegerTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterIntegerType" + + + // $ANTLR start "entryRuleParameterStringType" + // InternalRos2Parser.g:982:1: entryRuleParameterStringType : ruleParameterStringType EOF ; + public final void entryRuleParameterStringType() throws RecognitionException { + try { + // InternalRos2Parser.g:983:1: ( ruleParameterStringType EOF ) + // InternalRos2Parser.g:984:1: ruleParameterStringType EOF + { + before(grammarAccess.getParameterStringTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterStringType(); + + state._fsp--; + + after(grammarAccess.getParameterStringTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterStringType" + + + // $ANTLR start "ruleParameterStringType" + // InternalRos2Parser.g:991:1: ruleParameterStringType : ( ( rule__ParameterStringType__Group__0 ) ) ; + public final void ruleParameterStringType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:995:2: ( ( ( rule__ParameterStringType__Group__0 ) ) ) + // InternalRos2Parser.g:996:2: ( ( rule__ParameterStringType__Group__0 ) ) + { + // InternalRos2Parser.g:996:2: ( ( rule__ParameterStringType__Group__0 ) ) + // InternalRos2Parser.g:997:3: ( rule__ParameterStringType__Group__0 ) + { + before(grammarAccess.getParameterStringTypeAccess().getGroup()); + // InternalRos2Parser.g:998:3: ( rule__ParameterStringType__Group__0 ) + // InternalRos2Parser.g:998:4: rule__ParameterStringType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStringTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterStringType" + + + // $ANTLR start "entryRuleParameterDoubleType" + // InternalRos2Parser.g:1007:1: entryRuleParameterDoubleType : ruleParameterDoubleType EOF ; + public final void entryRuleParameterDoubleType() throws RecognitionException { + try { + // InternalRos2Parser.g:1008:1: ( ruleParameterDoubleType EOF ) + // InternalRos2Parser.g:1009:1: ruleParameterDoubleType EOF + { + before(grammarAccess.getParameterDoubleTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterDoubleType(); + + state._fsp--; + + after(grammarAccess.getParameterDoubleTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterDoubleType" + + + // $ANTLR start "ruleParameterDoubleType" + // InternalRos2Parser.g:1016:1: ruleParameterDoubleType : ( ( rule__ParameterDoubleType__Group__0 ) ) ; + public final void ruleParameterDoubleType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1020:2: ( ( ( rule__ParameterDoubleType__Group__0 ) ) ) + // InternalRos2Parser.g:1021:2: ( ( rule__ParameterDoubleType__Group__0 ) ) + { + // InternalRos2Parser.g:1021:2: ( ( rule__ParameterDoubleType__Group__0 ) ) + // InternalRos2Parser.g:1022:3: ( rule__ParameterDoubleType__Group__0 ) + { + before(grammarAccess.getParameterDoubleTypeAccess().getGroup()); + // InternalRos2Parser.g:1023:3: ( rule__ParameterDoubleType__Group__0 ) + // InternalRos2Parser.g:1023:4: rule__ParameterDoubleType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterDoubleTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterDoubleType" + + + // $ANTLR start "entryRuleParameterBooleanType" + // InternalRos2Parser.g:1032:1: entryRuleParameterBooleanType : ruleParameterBooleanType EOF ; + public final void entryRuleParameterBooleanType() throws RecognitionException { + try { + // InternalRos2Parser.g:1033:1: ( ruleParameterBooleanType EOF ) + // InternalRos2Parser.g:1034:1: ruleParameterBooleanType EOF + { + before(grammarAccess.getParameterBooleanTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterBooleanType(); + + state._fsp--; + + after(grammarAccess.getParameterBooleanTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterBooleanType" + + + // $ANTLR start "ruleParameterBooleanType" + // InternalRos2Parser.g:1041:1: ruleParameterBooleanType : ( ( rule__ParameterBooleanType__Group__0 ) ) ; + public final void ruleParameterBooleanType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1045:2: ( ( ( rule__ParameterBooleanType__Group__0 ) ) ) + // InternalRos2Parser.g:1046:2: ( ( rule__ParameterBooleanType__Group__0 ) ) + { + // InternalRos2Parser.g:1046:2: ( ( rule__ParameterBooleanType__Group__0 ) ) + // InternalRos2Parser.g:1047:3: ( rule__ParameterBooleanType__Group__0 ) + { + before(grammarAccess.getParameterBooleanTypeAccess().getGroup()); + // InternalRos2Parser.g:1048:3: ( rule__ParameterBooleanType__Group__0 ) + // InternalRos2Parser.g:1048:4: rule__ParameterBooleanType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBooleanTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterBooleanType" + + + // $ANTLR start "entryRuleParameterBase64Type" + // InternalRos2Parser.g:1057:1: entryRuleParameterBase64Type : ruleParameterBase64Type EOF ; + public final void entryRuleParameterBase64Type() throws RecognitionException { + try { + // InternalRos2Parser.g:1058:1: ( ruleParameterBase64Type EOF ) + // InternalRos2Parser.g:1059:1: ruleParameterBase64Type EOF + { + before(grammarAccess.getParameterBase64TypeRule()); + pushFollow(FOLLOW_1); + ruleParameterBase64Type(); + + state._fsp--; + + after(grammarAccess.getParameterBase64TypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterBase64Type" + + + // $ANTLR start "ruleParameterBase64Type" + // InternalRos2Parser.g:1066:1: ruleParameterBase64Type : ( ( rule__ParameterBase64Type__Group__0 ) ) ; + public final void ruleParameterBase64Type() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1070:2: ( ( ( rule__ParameterBase64Type__Group__0 ) ) ) + // InternalRos2Parser.g:1071:2: ( ( rule__ParameterBase64Type__Group__0 ) ) + { + // InternalRos2Parser.g:1071:2: ( ( rule__ParameterBase64Type__Group__0 ) ) + // InternalRos2Parser.g:1072:3: ( rule__ParameterBase64Type__Group__0 ) + { + before(grammarAccess.getParameterBase64TypeAccess().getGroup()); + // InternalRos2Parser.g:1073:3: ( rule__ParameterBase64Type__Group__0 ) + // InternalRos2Parser.g:1073:4: rule__ParameterBase64Type__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBase64TypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterBase64Type" + + + // $ANTLR start "entryRuleParameterArrayType" + // InternalRos2Parser.g:1082:1: entryRuleParameterArrayType : ruleParameterArrayType EOF ; + public final void entryRuleParameterArrayType() throws RecognitionException { + try { + // InternalRos2Parser.g:1083:1: ( ruleParameterArrayType EOF ) + // InternalRos2Parser.g:1084:1: ruleParameterArrayType EOF + { + before(grammarAccess.getParameterArrayTypeRule()); + pushFollow(FOLLOW_1); + ruleParameterArrayType(); + + state._fsp--; + + after(grammarAccess.getParameterArrayTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterArrayType" + + + // $ANTLR start "ruleParameterArrayType" + // InternalRos2Parser.g:1091:1: ruleParameterArrayType : ( ( rule__ParameterArrayType__Group__0 ) ) ; + public final void ruleParameterArrayType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1095:2: ( ( ( rule__ParameterArrayType__Group__0 ) ) ) + // InternalRos2Parser.g:1096:2: ( ( rule__ParameterArrayType__Group__0 ) ) + { + // InternalRos2Parser.g:1096:2: ( ( rule__ParameterArrayType__Group__0 ) ) + // InternalRos2Parser.g:1097:3: ( rule__ParameterArrayType__Group__0 ) + { + before(grammarAccess.getParameterArrayTypeAccess().getGroup()); + // InternalRos2Parser.g:1098:3: ( rule__ParameterArrayType__Group__0 ) + // InternalRos2Parser.g:1098:4: rule__ParameterArrayType__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterArrayTypeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterArrayType" + + + // $ANTLR start "entryRuleParameterList" + // InternalRos2Parser.g:1107:1: entryRuleParameterList : ruleParameterList EOF ; + public final void entryRuleParameterList() throws RecognitionException { + try { + // InternalRos2Parser.g:1108:1: ( ruleParameterList EOF ) + // InternalRos2Parser.g:1109:1: ruleParameterList EOF + { + before(grammarAccess.getParameterListRule()); + pushFollow(FOLLOW_1); + ruleParameterList(); + + state._fsp--; + + after(grammarAccess.getParameterListRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterList" + + + // $ANTLR start "ruleParameterList" + // InternalRos2Parser.g:1116:1: ruleParameterList : ( ( rule__ParameterList__Group__0 ) ) ; + public final void ruleParameterList() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1120:2: ( ( ( rule__ParameterList__Group__0 ) ) ) + // InternalRos2Parser.g:1121:2: ( ( rule__ParameterList__Group__0 ) ) + { + // InternalRos2Parser.g:1121:2: ( ( rule__ParameterList__Group__0 ) ) + // InternalRos2Parser.g:1122:3: ( rule__ParameterList__Group__0 ) + { + before(grammarAccess.getParameterListAccess().getGroup()); + // InternalRos2Parser.g:1123:3: ( rule__ParameterList__Group__0 ) + // InternalRos2Parser.g:1123:4: rule__ParameterList__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterList__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterList" + + + // $ANTLR start "entryRuleParameterAny" + // InternalRos2Parser.g:1132:1: entryRuleParameterAny : ruleParameterAny EOF ; + public final void entryRuleParameterAny() throws RecognitionException { + try { + // InternalRos2Parser.g:1133:1: ( ruleParameterAny EOF ) + // InternalRos2Parser.g:1134:1: ruleParameterAny EOF + { + before(grammarAccess.getParameterAnyRule()); + pushFollow(FOLLOW_1); + ruleParameterAny(); + + state._fsp--; + + after(grammarAccess.getParameterAnyRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterAny" + + + // $ANTLR start "ruleParameterAny" + // InternalRos2Parser.g:1141:1: ruleParameterAny : ( ( rule__ParameterAny__Group__0 ) ) ; + public final void ruleParameterAny() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1145:2: ( ( ( rule__ParameterAny__Group__0 ) ) ) + // InternalRos2Parser.g:1146:2: ( ( rule__ParameterAny__Group__0 ) ) + { + // InternalRos2Parser.g:1146:2: ( ( rule__ParameterAny__Group__0 ) ) + // InternalRos2Parser.g:1147:3: ( rule__ParameterAny__Group__0 ) + { + before(grammarAccess.getParameterAnyAccess().getGroup()); + // InternalRos2Parser.g:1148:3: ( rule__ParameterAny__Group__0 ) + // InternalRos2Parser.g:1148:4: rule__ParameterAny__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterAny__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAnyAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterAny" + + + // $ANTLR start "entryRuleParameterString" + // InternalRos2Parser.g:1157:1: entryRuleParameterString : ruleParameterString EOF ; + public final void entryRuleParameterString() throws RecognitionException { + try { + // InternalRos2Parser.g:1158:1: ( ruleParameterString EOF ) + // InternalRos2Parser.g:1159:1: ruleParameterString EOF + { + before(grammarAccess.getParameterStringRule()); + pushFollow(FOLLOW_1); + ruleParameterString(); + + state._fsp--; + + after(grammarAccess.getParameterStringRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterString" + + + // $ANTLR start "ruleParameterString" + // InternalRos2Parser.g:1166:1: ruleParameterString : ( ( rule__ParameterString__ValueAssignment ) ) ; + public final void ruleParameterString() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1170:2: ( ( ( rule__ParameterString__ValueAssignment ) ) ) + // InternalRos2Parser.g:1171:2: ( ( rule__ParameterString__ValueAssignment ) ) + { + // InternalRos2Parser.g:1171:2: ( ( rule__ParameterString__ValueAssignment ) ) + // InternalRos2Parser.g:1172:3: ( rule__ParameterString__ValueAssignment ) + { + before(grammarAccess.getParameterStringAccess().getValueAssignment()); + // InternalRos2Parser.g:1173:3: ( rule__ParameterString__ValueAssignment ) + // InternalRos2Parser.g:1173:4: rule__ParameterString__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterString__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStringAccess().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterString" + + + // $ANTLR start "entryRuleParameterBase64" + // InternalRos2Parser.g:1182:1: entryRuleParameterBase64 : ruleParameterBase64 EOF ; + public final void entryRuleParameterBase64() throws RecognitionException { + try { + // InternalRos2Parser.g:1183:1: ( ruleParameterBase64 EOF ) + // InternalRos2Parser.g:1184:1: ruleParameterBase64 EOF + { + before(grammarAccess.getParameterBase64Rule()); + pushFollow(FOLLOW_1); + ruleParameterBase64(); + + state._fsp--; + + after(grammarAccess.getParameterBase64Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterBase64" + + + // $ANTLR start "ruleParameterBase64" + // InternalRos2Parser.g:1191:1: ruleParameterBase64 : ( ( rule__ParameterBase64__ValueAssignment ) ) ; + public final void ruleParameterBase64() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1195:2: ( ( ( rule__ParameterBase64__ValueAssignment ) ) ) + // InternalRos2Parser.g:1196:2: ( ( rule__ParameterBase64__ValueAssignment ) ) + { + // InternalRos2Parser.g:1196:2: ( ( rule__ParameterBase64__ValueAssignment ) ) + // InternalRos2Parser.g:1197:3: ( rule__ParameterBase64__ValueAssignment ) + { + before(grammarAccess.getParameterBase64Access().getValueAssignment()); + // InternalRos2Parser.g:1198:3: ( rule__ParameterBase64__ValueAssignment ) + // InternalRos2Parser.g:1198:4: rule__ParameterBase64__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterBase64__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBase64Access().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterBase64" + + + // $ANTLR start "entryRuleParameterInteger" + // InternalRos2Parser.g:1207:1: entryRuleParameterInteger : ruleParameterInteger EOF ; + public final void entryRuleParameterInteger() throws RecognitionException { + try { + // InternalRos2Parser.g:1208:1: ( ruleParameterInteger EOF ) + // InternalRos2Parser.g:1209:1: ruleParameterInteger EOF + { + before(grammarAccess.getParameterIntegerRule()); + pushFollow(FOLLOW_1); + ruleParameterInteger(); + + state._fsp--; + + after(grammarAccess.getParameterIntegerRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterInteger" + + + // $ANTLR start "ruleParameterInteger" + // InternalRos2Parser.g:1216:1: ruleParameterInteger : ( ( rule__ParameterInteger__ValueAssignment ) ) ; + public final void ruleParameterInteger() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1220:2: ( ( ( rule__ParameterInteger__ValueAssignment ) ) ) + // InternalRos2Parser.g:1221:2: ( ( rule__ParameterInteger__ValueAssignment ) ) + { + // InternalRos2Parser.g:1221:2: ( ( rule__ParameterInteger__ValueAssignment ) ) + // InternalRos2Parser.g:1222:3: ( rule__ParameterInteger__ValueAssignment ) + { + before(grammarAccess.getParameterIntegerAccess().getValueAssignment()); + // InternalRos2Parser.g:1223:3: ( rule__ParameterInteger__ValueAssignment ) + // InternalRos2Parser.g:1223:4: rule__ParameterInteger__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterInteger__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterIntegerAccess().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterInteger" + + + // $ANTLR start "entryRuleParameterDouble" + // InternalRos2Parser.g:1232:1: entryRuleParameterDouble : ruleParameterDouble EOF ; + public final void entryRuleParameterDouble() throws RecognitionException { + try { + // InternalRos2Parser.g:1233:1: ( ruleParameterDouble EOF ) + // InternalRos2Parser.g:1234:1: ruleParameterDouble EOF + { + before(grammarAccess.getParameterDoubleRule()); + pushFollow(FOLLOW_1); + ruleParameterDouble(); + + state._fsp--; + + after(grammarAccess.getParameterDoubleRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterDouble" + + + // $ANTLR start "ruleParameterDouble" + // InternalRos2Parser.g:1241:1: ruleParameterDouble : ( ( rule__ParameterDouble__ValueAssignment ) ) ; + public final void ruleParameterDouble() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1245:2: ( ( ( rule__ParameterDouble__ValueAssignment ) ) ) + // InternalRos2Parser.g:1246:2: ( ( rule__ParameterDouble__ValueAssignment ) ) + { + // InternalRos2Parser.g:1246:2: ( ( rule__ParameterDouble__ValueAssignment ) ) + // InternalRos2Parser.g:1247:3: ( rule__ParameterDouble__ValueAssignment ) + { + before(grammarAccess.getParameterDoubleAccess().getValueAssignment()); + // InternalRos2Parser.g:1248:3: ( rule__ParameterDouble__ValueAssignment ) + // InternalRos2Parser.g:1248:4: rule__ParameterDouble__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterDouble__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterDoubleAccess().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterDouble" + + + // $ANTLR start "entryRuleParameterBoolean" + // InternalRos2Parser.g:1257:1: entryRuleParameterBoolean : ruleParameterBoolean EOF ; + public final void entryRuleParameterBoolean() throws RecognitionException { + try { + // InternalRos2Parser.g:1258:1: ( ruleParameterBoolean EOF ) + // InternalRos2Parser.g:1259:1: ruleParameterBoolean EOF + { + before(grammarAccess.getParameterBooleanRule()); + pushFollow(FOLLOW_1); + ruleParameterBoolean(); + + state._fsp--; + + after(grammarAccess.getParameterBooleanRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterBoolean" + + + // $ANTLR start "ruleParameterBoolean" + // InternalRos2Parser.g:1266:1: ruleParameterBoolean : ( ( rule__ParameterBoolean__ValueAssignment ) ) ; + public final void ruleParameterBoolean() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1270:2: ( ( ( rule__ParameterBoolean__ValueAssignment ) ) ) + // InternalRos2Parser.g:1271:2: ( ( rule__ParameterBoolean__ValueAssignment ) ) + { + // InternalRos2Parser.g:1271:2: ( ( rule__ParameterBoolean__ValueAssignment ) ) + // InternalRos2Parser.g:1272:3: ( rule__ParameterBoolean__ValueAssignment ) + { + before(grammarAccess.getParameterBooleanAccess().getValueAssignment()); + // InternalRos2Parser.g:1273:3: ( rule__ParameterBoolean__ValueAssignment ) + // InternalRos2Parser.g:1273:4: rule__ParameterBoolean__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterBoolean__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBooleanAccess().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterBoolean" + + + // $ANTLR start "entryRuleParameterStruct" + // InternalRos2Parser.g:1282:1: entryRuleParameterStruct : ruleParameterStruct EOF ; + public final void entryRuleParameterStruct() throws RecognitionException { + try { + // InternalRos2Parser.g:1283:1: ( ruleParameterStruct EOF ) + // InternalRos2Parser.g:1284:1: ruleParameterStruct EOF + { + before(grammarAccess.getParameterStructRule()); + pushFollow(FOLLOW_1); + ruleParameterStruct(); + + state._fsp--; + + after(grammarAccess.getParameterStructRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterStruct" + + + // $ANTLR start "ruleParameterStruct" + // InternalRos2Parser.g:1291:1: ruleParameterStruct : ( ( rule__ParameterStruct__Group__0 ) ) ; + public final void ruleParameterStruct() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1295:2: ( ( ( rule__ParameterStruct__Group__0 ) ) ) + // InternalRos2Parser.g:1296:2: ( ( rule__ParameterStruct__Group__0 ) ) + { + // InternalRos2Parser.g:1296:2: ( ( rule__ParameterStruct__Group__0 ) ) + // InternalRos2Parser.g:1297:3: ( rule__ParameterStruct__Group__0 ) + { + before(grammarAccess.getParameterStructAccess().getGroup()); + // InternalRos2Parser.g:1298:3: ( rule__ParameterStruct__Group__0 ) + // InternalRos2Parser.g:1298:4: rule__ParameterStruct__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterStruct" + + + // $ANTLR start "entryRuleParameterDate" + // InternalRos2Parser.g:1307:1: entryRuleParameterDate : ruleParameterDate EOF ; + public final void entryRuleParameterDate() throws RecognitionException { + try { + // InternalRos2Parser.g:1308:1: ( ruleParameterDate EOF ) + // InternalRos2Parser.g:1309:1: ruleParameterDate EOF + { + before(grammarAccess.getParameterDateRule()); + pushFollow(FOLLOW_1); + ruleParameterDate(); + + state._fsp--; + + after(grammarAccess.getParameterDateRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterDate" + + + // $ANTLR start "ruleParameterDate" + // InternalRos2Parser.g:1316:1: ruleParameterDate : ( ( rule__ParameterDate__ValueAssignment ) ) ; + public final void ruleParameterDate() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1320:2: ( ( ( rule__ParameterDate__ValueAssignment ) ) ) + // InternalRos2Parser.g:1321:2: ( ( rule__ParameterDate__ValueAssignment ) ) + { + // InternalRos2Parser.g:1321:2: ( ( rule__ParameterDate__ValueAssignment ) ) + // InternalRos2Parser.g:1322:3: ( rule__ParameterDate__ValueAssignment ) + { + before(grammarAccess.getParameterDateAccess().getValueAssignment()); + // InternalRos2Parser.g:1323:3: ( rule__ParameterDate__ValueAssignment ) + // InternalRos2Parser.g:1323:4: rule__ParameterDate__ValueAssignment + { + pushFollow(FOLLOW_2); + rule__ParameterDate__ValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterDateAccess().getValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterDate" + + + // $ANTLR start "entryRuleParameterStructMember" + // InternalRos2Parser.g:1332:1: entryRuleParameterStructMember : ruleParameterStructMember EOF ; + public final void entryRuleParameterStructMember() throws RecognitionException { + try { + // InternalRos2Parser.g:1333:1: ( ruleParameterStructMember EOF ) + // InternalRos2Parser.g:1334:1: ruleParameterStructMember EOF + { + before(grammarAccess.getParameterStructMemberRule()); + pushFollow(FOLLOW_1); + ruleParameterStructMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructMemberRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterStructMember" + + + // $ANTLR start "ruleParameterStructMember" + // InternalRos2Parser.g:1341:1: ruleParameterStructMember : ( ( rule__ParameterStructMember__Group__0 ) ) ; + public final void ruleParameterStructMember() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1345:2: ( ( ( rule__ParameterStructMember__Group__0 ) ) ) + // InternalRos2Parser.g:1346:2: ( ( rule__ParameterStructMember__Group__0 ) ) + { + // InternalRos2Parser.g:1346:2: ( ( rule__ParameterStructMember__Group__0 ) ) + // InternalRos2Parser.g:1347:3: ( rule__ParameterStructMember__Group__0 ) + { + before(grammarAccess.getParameterStructMemberAccess().getGroup()); + // InternalRos2Parser.g:1348:3: ( rule__ParameterStructMember__Group__0 ) + // InternalRos2Parser.g:1348:4: rule__ParameterStructMember__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructMemberAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterStructMember" + + + // $ANTLR start "entryRuleParameterStructTypeMember" + // InternalRos2Parser.g:1357:1: entryRuleParameterStructTypeMember : ruleParameterStructTypeMember EOF ; + public final void entryRuleParameterStructTypeMember() throws RecognitionException { + try { + // InternalRos2Parser.g:1358:1: ( ruleParameterStructTypeMember EOF ) + // InternalRos2Parser.g:1359:1: ruleParameterStructTypeMember EOF + { + before(grammarAccess.getParameterStructTypeMemberRule()); + pushFollow(FOLLOW_1); + ruleParameterStructTypeMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeMemberRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameterStructTypeMember" + + + // $ANTLR start "ruleParameterStructTypeMember" + // InternalRos2Parser.g:1366:1: ruleParameterStructTypeMember : ( ( rule__ParameterStructTypeMember__Group__0 ) ) ; + public final void ruleParameterStructTypeMember() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1370:2: ( ( ( rule__ParameterStructTypeMember__Group__0 ) ) ) + // InternalRos2Parser.g:1371:2: ( ( rule__ParameterStructTypeMember__Group__0 ) ) + { + // InternalRos2Parser.g:1371:2: ( ( rule__ParameterStructTypeMember__Group__0 ) ) + // InternalRos2Parser.g:1372:3: ( rule__ParameterStructTypeMember__Group__0 ) + { + before(grammarAccess.getParameterStructTypeMemberAccess().getGroup()); + // InternalRos2Parser.g:1373:3: ( rule__ParameterStructTypeMember__Group__0 ) + // InternalRos2Parser.g:1373:4: rule__ParameterStructTypeMember__Group__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeMemberAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameterStructTypeMember" + + + // $ANTLR start "entryRuleBase64Binary" + // InternalRos2Parser.g:1382:1: entryRuleBase64Binary : ruleBase64Binary EOF ; + public final void entryRuleBase64Binary() throws RecognitionException { + try { + // InternalRos2Parser.g:1383:1: ( ruleBase64Binary EOF ) + // InternalRos2Parser.g:1384:1: ruleBase64Binary EOF + { + before(grammarAccess.getBase64BinaryRule()); + pushFollow(FOLLOW_1); + ruleBase64Binary(); + + state._fsp--; + + after(grammarAccess.getBase64BinaryRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleBase64Binary" + + + // $ANTLR start "ruleBase64Binary" + // InternalRos2Parser.g:1391:1: ruleBase64Binary : ( RULE_BINARY ) ; + public final void ruleBase64Binary() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1395:2: ( ( RULE_BINARY ) ) + // InternalRos2Parser.g:1396:2: ( RULE_BINARY ) + { + // InternalRos2Parser.g:1396:2: ( RULE_BINARY ) + // InternalRos2Parser.g:1397:3: RULE_BINARY + { + before(grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); + match(input,RULE_BINARY,FOLLOW_2); + after(grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleBase64Binary" + + + // $ANTLR start "entryRuleboolean0" + // InternalRos2Parser.g:1407:1: entryRuleboolean0 : ruleboolean0 EOF ; + public final void entryRuleboolean0() throws RecognitionException { + try { + // InternalRos2Parser.g:1408:1: ( ruleboolean0 EOF ) + // InternalRos2Parser.g:1409:1: ruleboolean0 EOF + { + before(grammarAccess.getBoolean0Rule()); + pushFollow(FOLLOW_1); + ruleboolean0(); + + state._fsp--; + + after(grammarAccess.getBoolean0Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleboolean0" + + + // $ANTLR start "ruleboolean0" + // InternalRos2Parser.g:1416:1: ruleboolean0 : ( RULE_BOOLEAN ) ; + public final void ruleboolean0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1420:2: ( ( RULE_BOOLEAN ) ) + // InternalRos2Parser.g:1421:2: ( RULE_BOOLEAN ) + { + // InternalRos2Parser.g:1421:2: ( RULE_BOOLEAN ) + // InternalRos2Parser.g:1422:3: RULE_BOOLEAN + { + before(grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); + match(input,RULE_BOOLEAN,FOLLOW_2); + after(grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleboolean0" + + + // $ANTLR start "entryRuleDouble0" + // InternalRos2Parser.g:1432:1: entryRuleDouble0 : ruleDouble0 EOF ; + public final void entryRuleDouble0() throws RecognitionException { + try { + // InternalRos2Parser.g:1433:1: ( ruleDouble0 EOF ) + // InternalRos2Parser.g:1434:1: ruleDouble0 EOF + { + before(grammarAccess.getDouble0Rule()); + pushFollow(FOLLOW_1); + ruleDouble0(); + + state._fsp--; + + after(grammarAccess.getDouble0Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleDouble0" + + + // $ANTLR start "ruleDouble0" + // InternalRos2Parser.g:1441:1: ruleDouble0 : ( RULE_DOUBLE ) ; + public final void ruleDouble0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1445:2: ( ( RULE_DOUBLE ) ) + // InternalRos2Parser.g:1446:2: ( RULE_DOUBLE ) + { + // InternalRos2Parser.g:1446:2: ( RULE_DOUBLE ) + // InternalRos2Parser.g:1447:3: RULE_DOUBLE + { + before(grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); + match(input,RULE_DOUBLE,FOLLOW_2); + after(grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleDouble0" + + + // $ANTLR start "entryRuleInteger0" + // InternalRos2Parser.g:1457:1: entryRuleInteger0 : ruleInteger0 EOF ; + public final void entryRuleInteger0() throws RecognitionException { + try { + // InternalRos2Parser.g:1458:1: ( ruleInteger0 EOF ) + // InternalRos2Parser.g:1459:1: ruleInteger0 EOF + { + before(grammarAccess.getInteger0Rule()); + pushFollow(FOLLOW_1); + ruleInteger0(); + + state._fsp--; + + after(grammarAccess.getInteger0Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleInteger0" + + + // $ANTLR start "ruleInteger0" + // InternalRos2Parser.g:1466:1: ruleInteger0 : ( RULE_DECINT ) ; + public final void ruleInteger0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1470:2: ( ( RULE_DECINT ) ) + // InternalRos2Parser.g:1471:2: ( RULE_DECINT ) + { + // InternalRos2Parser.g:1471:2: ( RULE_DECINT ) + // InternalRos2Parser.g:1472:3: RULE_DECINT + { + before(grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); + match(input,RULE_DECINT,FOLLOW_2); + after(grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleInteger0" + + + // $ANTLR start "entryRuleDateTime0" + // InternalRos2Parser.g:1482:1: entryRuleDateTime0 : ruleDateTime0 EOF ; + public final void entryRuleDateTime0() throws RecognitionException { + try { + // InternalRos2Parser.g:1483:1: ( ruleDateTime0 EOF ) + // InternalRos2Parser.g:1484:1: ruleDateTime0 EOF + { + before(grammarAccess.getDateTime0Rule()); + pushFollow(FOLLOW_1); + ruleDateTime0(); + + state._fsp--; + + after(grammarAccess.getDateTime0Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleDateTime0" + + + // $ANTLR start "ruleDateTime0" + // InternalRos2Parser.g:1491:1: ruleDateTime0 : ( RULE_DATE_TIME ) ; + public final void ruleDateTime0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1495:2: ( ( RULE_DATE_TIME ) ) + // InternalRos2Parser.g:1496:2: ( RULE_DATE_TIME ) + { + // InternalRos2Parser.g:1496:2: ( RULE_DATE_TIME ) + // InternalRos2Parser.g:1497:3: RULE_DATE_TIME + { + before(grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); + match(input,RULE_DATE_TIME,FOLLOW_2); + after(grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleDateTime0" + + + // $ANTLR start "entryRuleMessagePart" + // InternalRos2Parser.g:1507:1: entryRuleMessagePart : ruleMessagePart EOF ; + public final void entryRuleMessagePart() throws RecognitionException { + try { + // InternalRos2Parser.g:1508:1: ( ruleMessagePart EOF ) + // InternalRos2Parser.g:1509:1: ruleMessagePart EOF + { + before(grammarAccess.getMessagePartRule()); + pushFollow(FOLLOW_1); + ruleMessagePart(); + + state._fsp--; + + after(grammarAccess.getMessagePartRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleMessagePart" + + + // $ANTLR start "ruleMessagePart" + // InternalRos2Parser.g:1516:1: ruleMessagePart : ( ( rule__MessagePart__Group__0 ) ) ; + public final void ruleMessagePart() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1520:2: ( ( ( rule__MessagePart__Group__0 ) ) ) + // InternalRos2Parser.g:1521:2: ( ( rule__MessagePart__Group__0 ) ) + { + // InternalRos2Parser.g:1521:2: ( ( rule__MessagePart__Group__0 ) ) + // InternalRos2Parser.g:1522:3: ( rule__MessagePart__Group__0 ) + { + before(grammarAccess.getMessagePartAccess().getGroup()); + // InternalRos2Parser.g:1523:3: ( rule__MessagePart__Group__0 ) + // InternalRos2Parser.g:1523:4: rule__MessagePart__Group__0 + { + pushFollow(FOLLOW_2); + rule__MessagePart__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getMessagePartAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleMessagePart" + + + // $ANTLR start "entryRuleAbstractType" + // InternalRos2Parser.g:1532:1: entryRuleAbstractType : ruleAbstractType EOF ; + public final void entryRuleAbstractType() throws RecognitionException { + try { + // InternalRos2Parser.g:1533:1: ( ruleAbstractType EOF ) + // InternalRos2Parser.g:1534:1: ruleAbstractType EOF + { + before(grammarAccess.getAbstractTypeRule()); + pushFollow(FOLLOW_1); + ruleAbstractType(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleAbstractType" + + + // $ANTLR start "ruleAbstractType" + // InternalRos2Parser.g:1541:1: ruleAbstractType : ( ( rule__AbstractType__Alternatives ) ) ; + public final void ruleAbstractType() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1545:2: ( ( ( rule__AbstractType__Alternatives ) ) ) + // InternalRos2Parser.g:1546:2: ( ( rule__AbstractType__Alternatives ) ) + { + // InternalRos2Parser.g:1546:2: ( ( rule__AbstractType__Alternatives ) ) + // InternalRos2Parser.g:1547:3: ( rule__AbstractType__Alternatives ) + { + before(grammarAccess.getAbstractTypeAccess().getAlternatives()); + // InternalRos2Parser.g:1548:3: ( rule__AbstractType__Alternatives ) + // InternalRos2Parser.g:1548:4: rule__AbstractType__Alternatives + { + pushFollow(FOLLOW_2); + rule__AbstractType__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getAbstractTypeAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleAbstractType" + + + // $ANTLR start "entryRulebool" + // InternalRos2Parser.g:1557:1: entryRulebool : rulebool EOF ; + public final void entryRulebool() throws RecognitionException { + try { + // InternalRos2Parser.g:1558:1: ( rulebool EOF ) + // InternalRos2Parser.g:1559:1: rulebool EOF + { + before(grammarAccess.getBoolRule()); + pushFollow(FOLLOW_1); + rulebool(); + + state._fsp--; + + after(grammarAccess.getBoolRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulebool" + + + // $ANTLR start "rulebool" + // InternalRos2Parser.g:1566:1: rulebool : ( ( rule__Bool__Group__0 ) ) ; + public final void rulebool() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1570:2: ( ( ( rule__Bool__Group__0 ) ) ) + // InternalRos2Parser.g:1571:2: ( ( rule__Bool__Group__0 ) ) + { + // InternalRos2Parser.g:1571:2: ( ( rule__Bool__Group__0 ) ) + // InternalRos2Parser.g:1572:3: ( rule__Bool__Group__0 ) + { + before(grammarAccess.getBoolAccess().getGroup()); + // InternalRos2Parser.g:1573:3: ( rule__Bool__Group__0 ) + // InternalRos2Parser.g:1573:4: rule__Bool__Group__0 + { + pushFollow(FOLLOW_2); + rule__Bool__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getBoolAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulebool" + + + // $ANTLR start "entryRuleint8" + // InternalRos2Parser.g:1582:1: entryRuleint8 : ruleint8 EOF ; + public final void entryRuleint8() throws RecognitionException { + try { + // InternalRos2Parser.g:1583:1: ( ruleint8 EOF ) + // InternalRos2Parser.g:1584:1: ruleint8 EOF + { + before(grammarAccess.getInt8Rule()); + pushFollow(FOLLOW_1); + ruleint8(); + + state._fsp--; + + after(grammarAccess.getInt8Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint8" + + + // $ANTLR start "ruleint8" + // InternalRos2Parser.g:1591:1: ruleint8 : ( ( rule__Int8__Group__0 ) ) ; + public final void ruleint8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1595:2: ( ( ( rule__Int8__Group__0 ) ) ) + // InternalRos2Parser.g:1596:2: ( ( rule__Int8__Group__0 ) ) + { + // InternalRos2Parser.g:1596:2: ( ( rule__Int8__Group__0 ) ) + // InternalRos2Parser.g:1597:3: ( rule__Int8__Group__0 ) + { + before(grammarAccess.getInt8Access().getGroup()); + // InternalRos2Parser.g:1598:3: ( rule__Int8__Group__0 ) + // InternalRos2Parser.g:1598:4: rule__Int8__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int8__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt8Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint8" + + + // $ANTLR start "entryRuleuint8" + // InternalRos2Parser.g:1607:1: entryRuleuint8 : ruleuint8 EOF ; + public final void entryRuleuint8() throws RecognitionException { + try { + // InternalRos2Parser.g:1608:1: ( ruleuint8 EOF ) + // InternalRos2Parser.g:1609:1: ruleuint8 EOF + { + before(grammarAccess.getUint8Rule()); + pushFollow(FOLLOW_1); + ruleuint8(); + + state._fsp--; + + after(grammarAccess.getUint8Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint8" + + + // $ANTLR start "ruleuint8" + // InternalRos2Parser.g:1616:1: ruleuint8 : ( ( rule__Uint8__Group__0 ) ) ; + public final void ruleuint8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1620:2: ( ( ( rule__Uint8__Group__0 ) ) ) + // InternalRos2Parser.g:1621:2: ( ( rule__Uint8__Group__0 ) ) + { + // InternalRos2Parser.g:1621:2: ( ( rule__Uint8__Group__0 ) ) + // InternalRos2Parser.g:1622:3: ( rule__Uint8__Group__0 ) + { + before(grammarAccess.getUint8Access().getGroup()); + // InternalRos2Parser.g:1623:3: ( rule__Uint8__Group__0 ) + // InternalRos2Parser.g:1623:4: rule__Uint8__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint8__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint8Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint8" + + + // $ANTLR start "entryRuleint16" + // InternalRos2Parser.g:1632:1: entryRuleint16 : ruleint16 EOF ; + public final void entryRuleint16() throws RecognitionException { + try { + // InternalRos2Parser.g:1633:1: ( ruleint16 EOF ) + // InternalRos2Parser.g:1634:1: ruleint16 EOF + { + before(grammarAccess.getInt16Rule()); + pushFollow(FOLLOW_1); + ruleint16(); + + state._fsp--; + + after(grammarAccess.getInt16Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint16" + + + // $ANTLR start "ruleint16" + // InternalRos2Parser.g:1641:1: ruleint16 : ( ( rule__Int16__Group__0 ) ) ; + public final void ruleint16() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1645:2: ( ( ( rule__Int16__Group__0 ) ) ) + // InternalRos2Parser.g:1646:2: ( ( rule__Int16__Group__0 ) ) + { + // InternalRos2Parser.g:1646:2: ( ( rule__Int16__Group__0 ) ) + // InternalRos2Parser.g:1647:3: ( rule__Int16__Group__0 ) + { + before(grammarAccess.getInt16Access().getGroup()); + // InternalRos2Parser.g:1648:3: ( rule__Int16__Group__0 ) + // InternalRos2Parser.g:1648:4: rule__Int16__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int16__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt16Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint16" + + + // $ANTLR start "entryRuleuint16" + // InternalRos2Parser.g:1657:1: entryRuleuint16 : ruleuint16 EOF ; + public final void entryRuleuint16() throws RecognitionException { + try { + // InternalRos2Parser.g:1658:1: ( ruleuint16 EOF ) + // InternalRos2Parser.g:1659:1: ruleuint16 EOF + { + before(grammarAccess.getUint16Rule()); + pushFollow(FOLLOW_1); + ruleuint16(); + + state._fsp--; + + after(grammarAccess.getUint16Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint16" + + + // $ANTLR start "ruleuint16" + // InternalRos2Parser.g:1666:1: ruleuint16 : ( ( rule__Uint16__Group__0 ) ) ; + public final void ruleuint16() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1670:2: ( ( ( rule__Uint16__Group__0 ) ) ) + // InternalRos2Parser.g:1671:2: ( ( rule__Uint16__Group__0 ) ) + { + // InternalRos2Parser.g:1671:2: ( ( rule__Uint16__Group__0 ) ) + // InternalRos2Parser.g:1672:3: ( rule__Uint16__Group__0 ) + { + before(grammarAccess.getUint16Access().getGroup()); + // InternalRos2Parser.g:1673:3: ( rule__Uint16__Group__0 ) + // InternalRos2Parser.g:1673:4: rule__Uint16__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint16__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint16Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint16" + + + // $ANTLR start "entryRuleint32" + // InternalRos2Parser.g:1682:1: entryRuleint32 : ruleint32 EOF ; + public final void entryRuleint32() throws RecognitionException { + try { + // InternalRos2Parser.g:1683:1: ( ruleint32 EOF ) + // InternalRos2Parser.g:1684:1: ruleint32 EOF + { + before(grammarAccess.getInt32Rule()); + pushFollow(FOLLOW_1); + ruleint32(); + + state._fsp--; + + after(grammarAccess.getInt32Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint32" + + + // $ANTLR start "ruleint32" + // InternalRos2Parser.g:1691:1: ruleint32 : ( ( rule__Int32__Group__0 ) ) ; + public final void ruleint32() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1695:2: ( ( ( rule__Int32__Group__0 ) ) ) + // InternalRos2Parser.g:1696:2: ( ( rule__Int32__Group__0 ) ) + { + // InternalRos2Parser.g:1696:2: ( ( rule__Int32__Group__0 ) ) + // InternalRos2Parser.g:1697:3: ( rule__Int32__Group__0 ) + { + before(grammarAccess.getInt32Access().getGroup()); + // InternalRos2Parser.g:1698:3: ( rule__Int32__Group__0 ) + // InternalRos2Parser.g:1698:4: rule__Int32__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int32__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt32Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint32" + + + // $ANTLR start "entryRuleuint32" + // InternalRos2Parser.g:1707:1: entryRuleuint32 : ruleuint32 EOF ; + public final void entryRuleuint32() throws RecognitionException { + try { + // InternalRos2Parser.g:1708:1: ( ruleuint32 EOF ) + // InternalRos2Parser.g:1709:1: ruleuint32 EOF + { + before(grammarAccess.getUint32Rule()); + pushFollow(FOLLOW_1); + ruleuint32(); + + state._fsp--; + + after(grammarAccess.getUint32Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint32" + + + // $ANTLR start "ruleuint32" + // InternalRos2Parser.g:1716:1: ruleuint32 : ( ( rule__Uint32__Group__0 ) ) ; + public final void ruleuint32() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1720:2: ( ( ( rule__Uint32__Group__0 ) ) ) + // InternalRos2Parser.g:1721:2: ( ( rule__Uint32__Group__0 ) ) + { + // InternalRos2Parser.g:1721:2: ( ( rule__Uint32__Group__0 ) ) + // InternalRos2Parser.g:1722:3: ( rule__Uint32__Group__0 ) + { + before(grammarAccess.getUint32Access().getGroup()); + // InternalRos2Parser.g:1723:3: ( rule__Uint32__Group__0 ) + // InternalRos2Parser.g:1723:4: rule__Uint32__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint32__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint32Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint32" + + + // $ANTLR start "entryRuleint64" + // InternalRos2Parser.g:1732:1: entryRuleint64 : ruleint64 EOF ; + public final void entryRuleint64() throws RecognitionException { + try { + // InternalRos2Parser.g:1733:1: ( ruleint64 EOF ) + // InternalRos2Parser.g:1734:1: ruleint64 EOF + { + before(grammarAccess.getInt64Rule()); + pushFollow(FOLLOW_1); + ruleint64(); + + state._fsp--; + + after(grammarAccess.getInt64Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint64" + + + // $ANTLR start "ruleint64" + // InternalRos2Parser.g:1741:1: ruleint64 : ( ( rule__Int64__Group__0 ) ) ; + public final void ruleint64() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1745:2: ( ( ( rule__Int64__Group__0 ) ) ) + // InternalRos2Parser.g:1746:2: ( ( rule__Int64__Group__0 ) ) + { + // InternalRos2Parser.g:1746:2: ( ( rule__Int64__Group__0 ) ) + // InternalRos2Parser.g:1747:3: ( rule__Int64__Group__0 ) + { + before(grammarAccess.getInt64Access().getGroup()); + // InternalRos2Parser.g:1748:3: ( rule__Int64__Group__0 ) + // InternalRos2Parser.g:1748:4: rule__Int64__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int64__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt64Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint64" + + + // $ANTLR start "entryRuleuint64" + // InternalRos2Parser.g:1757:1: entryRuleuint64 : ruleuint64 EOF ; + public final void entryRuleuint64() throws RecognitionException { + try { + // InternalRos2Parser.g:1758:1: ( ruleuint64 EOF ) + // InternalRos2Parser.g:1759:1: ruleuint64 EOF + { + before(grammarAccess.getUint64Rule()); + pushFollow(FOLLOW_1); + ruleuint64(); + + state._fsp--; + + after(grammarAccess.getUint64Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint64" + + + // $ANTLR start "ruleuint64" + // InternalRos2Parser.g:1766:1: ruleuint64 : ( ( rule__Uint64__Group__0 ) ) ; + public final void ruleuint64() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1770:2: ( ( ( rule__Uint64__Group__0 ) ) ) + // InternalRos2Parser.g:1771:2: ( ( rule__Uint64__Group__0 ) ) + { + // InternalRos2Parser.g:1771:2: ( ( rule__Uint64__Group__0 ) ) + // InternalRos2Parser.g:1772:3: ( rule__Uint64__Group__0 ) + { + before(grammarAccess.getUint64Access().getGroup()); + // InternalRos2Parser.g:1773:3: ( rule__Uint64__Group__0 ) + // InternalRos2Parser.g:1773:4: rule__Uint64__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint64__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint64Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint64" + + + // $ANTLR start "entryRulefloat32" + // InternalRos2Parser.g:1782:1: entryRulefloat32 : rulefloat32 EOF ; + public final void entryRulefloat32() throws RecognitionException { + try { + // InternalRos2Parser.g:1783:1: ( rulefloat32 EOF ) + // InternalRos2Parser.g:1784:1: rulefloat32 EOF + { + before(grammarAccess.getFloat32Rule()); + pushFollow(FOLLOW_1); + rulefloat32(); + + state._fsp--; + + after(grammarAccess.getFloat32Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulefloat32" + + + // $ANTLR start "rulefloat32" + // InternalRos2Parser.g:1791:1: rulefloat32 : ( ( rule__Float32__Group__0 ) ) ; + public final void rulefloat32() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1795:2: ( ( ( rule__Float32__Group__0 ) ) ) + // InternalRos2Parser.g:1796:2: ( ( rule__Float32__Group__0 ) ) + { + // InternalRos2Parser.g:1796:2: ( ( rule__Float32__Group__0 ) ) + // InternalRos2Parser.g:1797:3: ( rule__Float32__Group__0 ) + { + before(grammarAccess.getFloat32Access().getGroup()); + // InternalRos2Parser.g:1798:3: ( rule__Float32__Group__0 ) + // InternalRos2Parser.g:1798:4: rule__Float32__Group__0 + { + pushFollow(FOLLOW_2); + rule__Float32__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getFloat32Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulefloat32" + + + // $ANTLR start "entryRulefloat64" + // InternalRos2Parser.g:1807:1: entryRulefloat64 : rulefloat64 EOF ; + public final void entryRulefloat64() throws RecognitionException { + try { + // InternalRos2Parser.g:1808:1: ( rulefloat64 EOF ) + // InternalRos2Parser.g:1809:1: rulefloat64 EOF + { + before(grammarAccess.getFloat64Rule()); + pushFollow(FOLLOW_1); + rulefloat64(); + + state._fsp--; + + after(grammarAccess.getFloat64Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulefloat64" + + + // $ANTLR start "rulefloat64" + // InternalRos2Parser.g:1816:1: rulefloat64 : ( ( rule__Float64__Group__0 ) ) ; + public final void rulefloat64() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1820:2: ( ( ( rule__Float64__Group__0 ) ) ) + // InternalRos2Parser.g:1821:2: ( ( rule__Float64__Group__0 ) ) + { + // InternalRos2Parser.g:1821:2: ( ( rule__Float64__Group__0 ) ) + // InternalRos2Parser.g:1822:3: ( rule__Float64__Group__0 ) + { + before(grammarAccess.getFloat64Access().getGroup()); + // InternalRos2Parser.g:1823:3: ( rule__Float64__Group__0 ) + // InternalRos2Parser.g:1823:4: rule__Float64__Group__0 + { + pushFollow(FOLLOW_2); + rule__Float64__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getFloat64Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulefloat64" + + + // $ANTLR start "entryRulestring0" + // InternalRos2Parser.g:1832:1: entryRulestring0 : rulestring0 EOF ; + public final void entryRulestring0() throws RecognitionException { + try { + // InternalRos2Parser.g:1833:1: ( rulestring0 EOF ) + // InternalRos2Parser.g:1834:1: rulestring0 EOF + { + before(grammarAccess.getString0Rule()); + pushFollow(FOLLOW_1); + rulestring0(); + + state._fsp--; + + after(grammarAccess.getString0Rule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulestring0" + + + // $ANTLR start "rulestring0" + // InternalRos2Parser.g:1841:1: rulestring0 : ( ( rule__String0__Group__0 ) ) ; + public final void rulestring0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1845:2: ( ( ( rule__String0__Group__0 ) ) ) + // InternalRos2Parser.g:1846:2: ( ( rule__String0__Group__0 ) ) + { + // InternalRos2Parser.g:1846:2: ( ( rule__String0__Group__0 ) ) + // InternalRos2Parser.g:1847:3: ( rule__String0__Group__0 ) + { + before(grammarAccess.getString0Access().getGroup()); + // InternalRos2Parser.g:1848:3: ( rule__String0__Group__0 ) + // InternalRos2Parser.g:1848:4: rule__String0__Group__0 + { + pushFollow(FOLLOW_2); + rule__String0__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getString0Access().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulestring0" + + + // $ANTLR start "entryRulebyte" + // InternalRos2Parser.g:1857:1: entryRulebyte : rulebyte EOF ; + public final void entryRulebyte() throws RecognitionException { + try { + // InternalRos2Parser.g:1858:1: ( rulebyte EOF ) + // InternalRos2Parser.g:1859:1: rulebyte EOF + { + before(grammarAccess.getByteRule()); + pushFollow(FOLLOW_1); + rulebyte(); + + state._fsp--; + + after(grammarAccess.getByteRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulebyte" + + + // $ANTLR start "rulebyte" + // InternalRos2Parser.g:1866:1: rulebyte : ( ( rule__Byte__Group__0 ) ) ; + public final void rulebyte() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1870:2: ( ( ( rule__Byte__Group__0 ) ) ) + // InternalRos2Parser.g:1871:2: ( ( rule__Byte__Group__0 ) ) + { + // InternalRos2Parser.g:1871:2: ( ( rule__Byte__Group__0 ) ) + // InternalRos2Parser.g:1872:3: ( rule__Byte__Group__0 ) + { + before(grammarAccess.getByteAccess().getGroup()); + // InternalRos2Parser.g:1873:3: ( rule__Byte__Group__0 ) + // InternalRos2Parser.g:1873:4: rule__Byte__Group__0 + { + pushFollow(FOLLOW_2); + rule__Byte__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getByteAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulebyte" + + + // $ANTLR start "entryRuletime" + // InternalRos2Parser.g:1882:1: entryRuletime : ruletime EOF ; + public final void entryRuletime() throws RecognitionException { + try { + // InternalRos2Parser.g:1883:1: ( ruletime EOF ) + // InternalRos2Parser.g:1884:1: ruletime EOF + { + before(grammarAccess.getTimeRule()); + pushFollow(FOLLOW_1); + ruletime(); + + state._fsp--; + + after(grammarAccess.getTimeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuletime" + + + // $ANTLR start "ruletime" + // InternalRos2Parser.g:1891:1: ruletime : ( ( rule__Time__Group__0 ) ) ; + public final void ruletime() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1895:2: ( ( ( rule__Time__Group__0 ) ) ) + // InternalRos2Parser.g:1896:2: ( ( rule__Time__Group__0 ) ) + { + // InternalRos2Parser.g:1896:2: ( ( rule__Time__Group__0 ) ) + // InternalRos2Parser.g:1897:3: ( rule__Time__Group__0 ) + { + before(grammarAccess.getTimeAccess().getGroup()); + // InternalRos2Parser.g:1898:3: ( rule__Time__Group__0 ) + // InternalRos2Parser.g:1898:4: rule__Time__Group__0 + { + pushFollow(FOLLOW_2); + rule__Time__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getTimeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruletime" + + + // $ANTLR start "entryRuleduration" + // InternalRos2Parser.g:1907:1: entryRuleduration : ruleduration EOF ; + public final void entryRuleduration() throws RecognitionException { + try { + // InternalRos2Parser.g:1908:1: ( ruleduration EOF ) + // InternalRos2Parser.g:1909:1: ruleduration EOF + { + before(grammarAccess.getDurationRule()); + pushFollow(FOLLOW_1); + ruleduration(); + + state._fsp--; + + after(grammarAccess.getDurationRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleduration" + + + // $ANTLR start "ruleduration" + // InternalRos2Parser.g:1916:1: ruleduration : ( ( rule__Duration__Group__0 ) ) ; + public final void ruleduration() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1920:2: ( ( ( rule__Duration__Group__0 ) ) ) + // InternalRos2Parser.g:1921:2: ( ( rule__Duration__Group__0 ) ) + { + // InternalRos2Parser.g:1921:2: ( ( rule__Duration__Group__0 ) ) + // InternalRos2Parser.g:1922:3: ( rule__Duration__Group__0 ) + { + before(grammarAccess.getDurationAccess().getGroup()); + // InternalRos2Parser.g:1923:3: ( rule__Duration__Group__0 ) + // InternalRos2Parser.g:1923:4: rule__Duration__Group__0 + { + pushFollow(FOLLOW_2); + rule__Duration__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getDurationAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleduration" + + + // $ANTLR start "entryRuleboolArray" + // InternalRos2Parser.g:1932:1: entryRuleboolArray : ruleboolArray EOF ; + public final void entryRuleboolArray() throws RecognitionException { + try { + // InternalRos2Parser.g:1933:1: ( ruleboolArray EOF ) + // InternalRos2Parser.g:1934:1: ruleboolArray EOF + { + before(grammarAccess.getBoolArrayRule()); + pushFollow(FOLLOW_1); + ruleboolArray(); + + state._fsp--; + + after(grammarAccess.getBoolArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleboolArray" + + + // $ANTLR start "ruleboolArray" + // InternalRos2Parser.g:1941:1: ruleboolArray : ( ( rule__BoolArray__Group__0 ) ) ; + public final void ruleboolArray() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1945:2: ( ( ( rule__BoolArray__Group__0 ) ) ) + // InternalRos2Parser.g:1946:2: ( ( rule__BoolArray__Group__0 ) ) + { + // InternalRos2Parser.g:1946:2: ( ( rule__BoolArray__Group__0 ) ) + // InternalRos2Parser.g:1947:3: ( rule__BoolArray__Group__0 ) + { + before(grammarAccess.getBoolArrayAccess().getGroup()); + // InternalRos2Parser.g:1948:3: ( rule__BoolArray__Group__0 ) + // InternalRos2Parser.g:1948:4: rule__BoolArray__Group__0 + { + pushFollow(FOLLOW_2); + rule__BoolArray__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getBoolArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleboolArray" + + + // $ANTLR start "entryRuleint8Array" + // InternalRos2Parser.g:1957:1: entryRuleint8Array : ruleint8Array EOF ; + public final void entryRuleint8Array() throws RecognitionException { + try { + // InternalRos2Parser.g:1958:1: ( ruleint8Array EOF ) + // InternalRos2Parser.g:1959:1: ruleint8Array EOF + { + before(grammarAccess.getInt8ArrayRule()); + pushFollow(FOLLOW_1); + ruleint8Array(); + + state._fsp--; + + after(grammarAccess.getInt8ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint8Array" + + + // $ANTLR start "ruleint8Array" + // InternalRos2Parser.g:1966:1: ruleint8Array : ( ( rule__Int8Array__Group__0 ) ) ; + public final void ruleint8Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1970:2: ( ( ( rule__Int8Array__Group__0 ) ) ) + // InternalRos2Parser.g:1971:2: ( ( rule__Int8Array__Group__0 ) ) + { + // InternalRos2Parser.g:1971:2: ( ( rule__Int8Array__Group__0 ) ) + // InternalRos2Parser.g:1972:3: ( rule__Int8Array__Group__0 ) + { + before(grammarAccess.getInt8ArrayAccess().getGroup()); + // InternalRos2Parser.g:1973:3: ( rule__Int8Array__Group__0 ) + // InternalRos2Parser.g:1973:4: rule__Int8Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int8Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt8ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint8Array" + + + // $ANTLR start "entryRuleuint8Array" + // InternalRos2Parser.g:1982:1: entryRuleuint8Array : ruleuint8Array EOF ; + public final void entryRuleuint8Array() throws RecognitionException { + try { + // InternalRos2Parser.g:1983:1: ( ruleuint8Array EOF ) + // InternalRos2Parser.g:1984:1: ruleuint8Array EOF + { + before(grammarAccess.getUint8ArrayRule()); + pushFollow(FOLLOW_1); + ruleuint8Array(); + + state._fsp--; + + after(grammarAccess.getUint8ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint8Array" + + + // $ANTLR start "ruleuint8Array" + // InternalRos2Parser.g:1991:1: ruleuint8Array : ( ( rule__Uint8Array__Group__0 ) ) ; + public final void ruleuint8Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:1995:2: ( ( ( rule__Uint8Array__Group__0 ) ) ) + // InternalRos2Parser.g:1996:2: ( ( rule__Uint8Array__Group__0 ) ) + { + // InternalRos2Parser.g:1996:2: ( ( rule__Uint8Array__Group__0 ) ) + // InternalRos2Parser.g:1997:3: ( rule__Uint8Array__Group__0 ) + { + before(grammarAccess.getUint8ArrayAccess().getGroup()); + // InternalRos2Parser.g:1998:3: ( rule__Uint8Array__Group__0 ) + // InternalRos2Parser.g:1998:4: rule__Uint8Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint8Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint8ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint8Array" + + + // $ANTLR start "entryRuleint16Array" + // InternalRos2Parser.g:2007:1: entryRuleint16Array : ruleint16Array EOF ; + public final void entryRuleint16Array() throws RecognitionException { + try { + // InternalRos2Parser.g:2008:1: ( ruleint16Array EOF ) + // InternalRos2Parser.g:2009:1: ruleint16Array EOF + { + before(grammarAccess.getInt16ArrayRule()); + pushFollow(FOLLOW_1); + ruleint16Array(); + + state._fsp--; + + after(grammarAccess.getInt16ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint16Array" + + + // $ANTLR start "ruleint16Array" + // InternalRos2Parser.g:2016:1: ruleint16Array : ( ( rule__Int16Array__Group__0 ) ) ; + public final void ruleint16Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2020:2: ( ( ( rule__Int16Array__Group__0 ) ) ) + // InternalRos2Parser.g:2021:2: ( ( rule__Int16Array__Group__0 ) ) + { + // InternalRos2Parser.g:2021:2: ( ( rule__Int16Array__Group__0 ) ) + // InternalRos2Parser.g:2022:3: ( rule__Int16Array__Group__0 ) + { + before(grammarAccess.getInt16ArrayAccess().getGroup()); + // InternalRos2Parser.g:2023:3: ( rule__Int16Array__Group__0 ) + // InternalRos2Parser.g:2023:4: rule__Int16Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int16Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt16ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint16Array" + + + // $ANTLR start "entryRuleuint16Array" + // InternalRos2Parser.g:2032:1: entryRuleuint16Array : ruleuint16Array EOF ; + public final void entryRuleuint16Array() throws RecognitionException { + try { + // InternalRos2Parser.g:2033:1: ( ruleuint16Array EOF ) + // InternalRos2Parser.g:2034:1: ruleuint16Array EOF + { + before(grammarAccess.getUint16ArrayRule()); + pushFollow(FOLLOW_1); + ruleuint16Array(); + + state._fsp--; + + after(grammarAccess.getUint16ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint16Array" + + + // $ANTLR start "ruleuint16Array" + // InternalRos2Parser.g:2041:1: ruleuint16Array : ( ( rule__Uint16Array__Group__0 ) ) ; + public final void ruleuint16Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2045:2: ( ( ( rule__Uint16Array__Group__0 ) ) ) + // InternalRos2Parser.g:2046:2: ( ( rule__Uint16Array__Group__0 ) ) + { + // InternalRos2Parser.g:2046:2: ( ( rule__Uint16Array__Group__0 ) ) + // InternalRos2Parser.g:2047:3: ( rule__Uint16Array__Group__0 ) + { + before(grammarAccess.getUint16ArrayAccess().getGroup()); + // InternalRos2Parser.g:2048:3: ( rule__Uint16Array__Group__0 ) + // InternalRos2Parser.g:2048:4: rule__Uint16Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint16Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint16ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint16Array" + + + // $ANTLR start "entryRuleint32Array" + // InternalRos2Parser.g:2057:1: entryRuleint32Array : ruleint32Array EOF ; + public final void entryRuleint32Array() throws RecognitionException { + try { + // InternalRos2Parser.g:2058:1: ( ruleint32Array EOF ) + // InternalRos2Parser.g:2059:1: ruleint32Array EOF + { + before(grammarAccess.getInt32ArrayRule()); + pushFollow(FOLLOW_1); + ruleint32Array(); + + state._fsp--; + + after(grammarAccess.getInt32ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint32Array" + + + // $ANTLR start "ruleint32Array" + // InternalRos2Parser.g:2066:1: ruleint32Array : ( ( rule__Int32Array__Group__0 ) ) ; + public final void ruleint32Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2070:2: ( ( ( rule__Int32Array__Group__0 ) ) ) + // InternalRos2Parser.g:2071:2: ( ( rule__Int32Array__Group__0 ) ) + { + // InternalRos2Parser.g:2071:2: ( ( rule__Int32Array__Group__0 ) ) + // InternalRos2Parser.g:2072:3: ( rule__Int32Array__Group__0 ) + { + before(grammarAccess.getInt32ArrayAccess().getGroup()); + // InternalRos2Parser.g:2073:3: ( rule__Int32Array__Group__0 ) + // InternalRos2Parser.g:2073:4: rule__Int32Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int32Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt32ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint32Array" + + + // $ANTLR start "entryRuleuint32Array" + // InternalRos2Parser.g:2082:1: entryRuleuint32Array : ruleuint32Array EOF ; + public final void entryRuleuint32Array() throws RecognitionException { + try { + // InternalRos2Parser.g:2083:1: ( ruleuint32Array EOF ) + // InternalRos2Parser.g:2084:1: ruleuint32Array EOF + { + before(grammarAccess.getUint32ArrayRule()); + pushFollow(FOLLOW_1); + ruleuint32Array(); + + state._fsp--; + + after(grammarAccess.getUint32ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint32Array" + + + // $ANTLR start "ruleuint32Array" + // InternalRos2Parser.g:2091:1: ruleuint32Array : ( ( rule__Uint32Array__Group__0 ) ) ; + public final void ruleuint32Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2095:2: ( ( ( rule__Uint32Array__Group__0 ) ) ) + // InternalRos2Parser.g:2096:2: ( ( rule__Uint32Array__Group__0 ) ) + { + // InternalRos2Parser.g:2096:2: ( ( rule__Uint32Array__Group__0 ) ) + // InternalRos2Parser.g:2097:3: ( rule__Uint32Array__Group__0 ) + { + before(grammarAccess.getUint32ArrayAccess().getGroup()); + // InternalRos2Parser.g:2098:3: ( rule__Uint32Array__Group__0 ) + // InternalRos2Parser.g:2098:4: rule__Uint32Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint32Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint32ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint32Array" + + + // $ANTLR start "entryRuleint64Array" + // InternalRos2Parser.g:2107:1: entryRuleint64Array : ruleint64Array EOF ; + public final void entryRuleint64Array() throws RecognitionException { + try { + // InternalRos2Parser.g:2108:1: ( ruleint64Array EOF ) + // InternalRos2Parser.g:2109:1: ruleint64Array EOF + { + before(grammarAccess.getInt64ArrayRule()); + pushFollow(FOLLOW_1); + ruleint64Array(); + + state._fsp--; + + after(grammarAccess.getInt64ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleint64Array" + + + // $ANTLR start "ruleint64Array" + // InternalRos2Parser.g:2116:1: ruleint64Array : ( ( rule__Int64Array__Group__0 ) ) ; + public final void ruleint64Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2120:2: ( ( ( rule__Int64Array__Group__0 ) ) ) + // InternalRos2Parser.g:2121:2: ( ( rule__Int64Array__Group__0 ) ) + { + // InternalRos2Parser.g:2121:2: ( ( rule__Int64Array__Group__0 ) ) + // InternalRos2Parser.g:2122:3: ( rule__Int64Array__Group__0 ) + { + before(grammarAccess.getInt64ArrayAccess().getGroup()); + // InternalRos2Parser.g:2123:3: ( rule__Int64Array__Group__0 ) + // InternalRos2Parser.g:2123:4: rule__Int64Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Int64Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getInt64ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleint64Array" + + + // $ANTLR start "entryRuleuint64Array" + // InternalRos2Parser.g:2132:1: entryRuleuint64Array : ruleuint64Array EOF ; + public final void entryRuleuint64Array() throws RecognitionException { + try { + // InternalRos2Parser.g:2133:1: ( ruleuint64Array EOF ) + // InternalRos2Parser.g:2134:1: ruleuint64Array EOF + { + before(grammarAccess.getUint64ArrayRule()); + pushFollow(FOLLOW_1); + ruleuint64Array(); + + state._fsp--; + + after(grammarAccess.getUint64ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleuint64Array" + + + // $ANTLR start "ruleuint64Array" + // InternalRos2Parser.g:2141:1: ruleuint64Array : ( ( rule__Uint64Array__Group__0 ) ) ; + public final void ruleuint64Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2145:2: ( ( ( rule__Uint64Array__Group__0 ) ) ) + // InternalRos2Parser.g:2146:2: ( ( rule__Uint64Array__Group__0 ) ) + { + // InternalRos2Parser.g:2146:2: ( ( rule__Uint64Array__Group__0 ) ) + // InternalRos2Parser.g:2147:3: ( rule__Uint64Array__Group__0 ) + { + before(grammarAccess.getUint64ArrayAccess().getGroup()); + // InternalRos2Parser.g:2148:3: ( rule__Uint64Array__Group__0 ) + // InternalRos2Parser.g:2148:4: rule__Uint64Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Uint64Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getUint64ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleuint64Array" + + + // $ANTLR start "entryRulefloat32Array" + // InternalRos2Parser.g:2157:1: entryRulefloat32Array : rulefloat32Array EOF ; + public final void entryRulefloat32Array() throws RecognitionException { + try { + // InternalRos2Parser.g:2158:1: ( rulefloat32Array EOF ) + // InternalRos2Parser.g:2159:1: rulefloat32Array EOF + { + before(grammarAccess.getFloat32ArrayRule()); + pushFollow(FOLLOW_1); + rulefloat32Array(); + + state._fsp--; + + after(grammarAccess.getFloat32ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulefloat32Array" + + + // $ANTLR start "rulefloat32Array" + // InternalRos2Parser.g:2166:1: rulefloat32Array : ( ( rule__Float32Array__Group__0 ) ) ; + public final void rulefloat32Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2170:2: ( ( ( rule__Float32Array__Group__0 ) ) ) + // InternalRos2Parser.g:2171:2: ( ( rule__Float32Array__Group__0 ) ) + { + // InternalRos2Parser.g:2171:2: ( ( rule__Float32Array__Group__0 ) ) + // InternalRos2Parser.g:2172:3: ( rule__Float32Array__Group__0 ) + { + before(grammarAccess.getFloat32ArrayAccess().getGroup()); + // InternalRos2Parser.g:2173:3: ( rule__Float32Array__Group__0 ) + // InternalRos2Parser.g:2173:4: rule__Float32Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Float32Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getFloat32ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulefloat32Array" + + + // $ANTLR start "entryRulefloat64Array" + // InternalRos2Parser.g:2182:1: entryRulefloat64Array : rulefloat64Array EOF ; + public final void entryRulefloat64Array() throws RecognitionException { + try { + // InternalRos2Parser.g:2183:1: ( rulefloat64Array EOF ) + // InternalRos2Parser.g:2184:1: rulefloat64Array EOF + { + before(grammarAccess.getFloat64ArrayRule()); + pushFollow(FOLLOW_1); + rulefloat64Array(); + + state._fsp--; + + after(grammarAccess.getFloat64ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulefloat64Array" + + + // $ANTLR start "rulefloat64Array" + // InternalRos2Parser.g:2191:1: rulefloat64Array : ( ( rule__Float64Array__Group__0 ) ) ; + public final void rulefloat64Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2195:2: ( ( ( rule__Float64Array__Group__0 ) ) ) + // InternalRos2Parser.g:2196:2: ( ( rule__Float64Array__Group__0 ) ) + { + // InternalRos2Parser.g:2196:2: ( ( rule__Float64Array__Group__0 ) ) + // InternalRos2Parser.g:2197:3: ( rule__Float64Array__Group__0 ) + { + before(grammarAccess.getFloat64ArrayAccess().getGroup()); + // InternalRos2Parser.g:2198:3: ( rule__Float64Array__Group__0 ) + // InternalRos2Parser.g:2198:4: rule__Float64Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__Float64Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getFloat64ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulefloat64Array" + + + // $ANTLR start "entryRulestring0Array" + // InternalRos2Parser.g:2207:1: entryRulestring0Array : rulestring0Array EOF ; + public final void entryRulestring0Array() throws RecognitionException { + try { + // InternalRos2Parser.g:2208:1: ( rulestring0Array EOF ) + // InternalRos2Parser.g:2209:1: rulestring0Array EOF + { + before(grammarAccess.getString0ArrayRule()); + pushFollow(FOLLOW_1); + rulestring0Array(); + + state._fsp--; + + after(grammarAccess.getString0ArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulestring0Array" + + + // $ANTLR start "rulestring0Array" + // InternalRos2Parser.g:2216:1: rulestring0Array : ( ( rule__String0Array__Group__0 ) ) ; + public final void rulestring0Array() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2220:2: ( ( ( rule__String0Array__Group__0 ) ) ) + // InternalRos2Parser.g:2221:2: ( ( rule__String0Array__Group__0 ) ) + { + // InternalRos2Parser.g:2221:2: ( ( rule__String0Array__Group__0 ) ) + // InternalRos2Parser.g:2222:3: ( rule__String0Array__Group__0 ) + { + before(grammarAccess.getString0ArrayAccess().getGroup()); + // InternalRos2Parser.g:2223:3: ( rule__String0Array__Group__0 ) + // InternalRos2Parser.g:2223:4: rule__String0Array__Group__0 + { + pushFollow(FOLLOW_2); + rule__String0Array__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getString0ArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulestring0Array" + + + // $ANTLR start "entryRulebyteArray" + // InternalRos2Parser.g:2232:1: entryRulebyteArray : rulebyteArray EOF ; + public final void entryRulebyteArray() throws RecognitionException { + try { + // InternalRos2Parser.g:2233:1: ( rulebyteArray EOF ) + // InternalRos2Parser.g:2234:1: rulebyteArray EOF + { + before(grammarAccess.getByteArrayRule()); + pushFollow(FOLLOW_1); + rulebyteArray(); + + state._fsp--; + + after(grammarAccess.getByteArrayRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulebyteArray" + + + // $ANTLR start "rulebyteArray" + // InternalRos2Parser.g:2241:1: rulebyteArray : ( ( rule__ByteArray__Group__0 ) ) ; + public final void rulebyteArray() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2245:2: ( ( ( rule__ByteArray__Group__0 ) ) ) + // InternalRos2Parser.g:2246:2: ( ( rule__ByteArray__Group__0 ) ) + { + // InternalRos2Parser.g:2246:2: ( ( rule__ByteArray__Group__0 ) ) + // InternalRos2Parser.g:2247:3: ( rule__ByteArray__Group__0 ) + { + before(grammarAccess.getByteArrayAccess().getGroup()); + // InternalRos2Parser.g:2248:3: ( rule__ByteArray__Group__0 ) + // InternalRos2Parser.g:2248:4: rule__ByteArray__Group__0 + { + pushFollow(FOLLOW_2); + rule__ByteArray__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getByteArrayAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulebyteArray" + + + // $ANTLR start "entryRuleHeader" + // InternalRos2Parser.g:2257:1: entryRuleHeader : ruleHeader EOF ; + public final void entryRuleHeader() throws RecognitionException { + try { + // InternalRos2Parser.g:2258:1: ( ruleHeader EOF ) + // InternalRos2Parser.g:2259:1: ruleHeader EOF + { + before(grammarAccess.getHeaderRule()); + pushFollow(FOLLOW_1); + ruleHeader(); + + state._fsp--; + + after(grammarAccess.getHeaderRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleHeader" + + + // $ANTLR start "ruleHeader" + // InternalRos2Parser.g:2266:1: ruleHeader : ( ( rule__Header__Group__0 ) ) ; + public final void ruleHeader() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2270:2: ( ( ( rule__Header__Group__0 ) ) ) + // InternalRos2Parser.g:2271:2: ( ( rule__Header__Group__0 ) ) + { + // InternalRos2Parser.g:2271:2: ( ( rule__Header__Group__0 ) ) + // InternalRos2Parser.g:2272:3: ( rule__Header__Group__0 ) + { + before(grammarAccess.getHeaderAccess().getGroup()); + // InternalRos2Parser.g:2273:3: ( rule__Header__Group__0 ) + // InternalRos2Parser.g:2273:4: rule__Header__Group__0 + { + pushFollow(FOLLOW_2); + rule__Header__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getHeaderAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleHeader" + + + // $ANTLR start "entryRuleTopicSpecRef" + // InternalRos2Parser.g:2282:1: entryRuleTopicSpecRef : ruleTopicSpecRef EOF ; + public final void entryRuleTopicSpecRef() throws RecognitionException { + try { + // InternalRos2Parser.g:2283:1: ( ruleTopicSpecRef EOF ) + // InternalRos2Parser.g:2284:1: ruleTopicSpecRef EOF + { + before(grammarAccess.getTopicSpecRefRule()); + pushFollow(FOLLOW_1); + ruleTopicSpecRef(); + + state._fsp--; + + after(grammarAccess.getTopicSpecRefRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleTopicSpecRef" + + + // $ANTLR start "ruleTopicSpecRef" + // InternalRos2Parser.g:2291:1: ruleTopicSpecRef : ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) ; + public final void ruleTopicSpecRef() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2295:2: ( ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) ) + // InternalRos2Parser.g:2296:2: ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) + { + // InternalRos2Parser.g:2296:2: ( ( rule__TopicSpecRef__TopicSpecAssignment ) ) + // InternalRos2Parser.g:2297:3: ( rule__TopicSpecRef__TopicSpecAssignment ) + { + before(grammarAccess.getTopicSpecRefAccess().getTopicSpecAssignment()); + // InternalRos2Parser.g:2298:3: ( rule__TopicSpecRef__TopicSpecAssignment ) + // InternalRos2Parser.g:2298:4: rule__TopicSpecRef__TopicSpecAssignment + { + pushFollow(FOLLOW_2); + rule__TopicSpecRef__TopicSpecAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getTopicSpecRefAccess().getTopicSpecAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleTopicSpecRef" + + + // $ANTLR start "entryRuleArrayTopicSpecRef" + // InternalRos2Parser.g:2307:1: entryRuleArrayTopicSpecRef : ruleArrayTopicSpecRef EOF ; + public final void entryRuleArrayTopicSpecRef() throws RecognitionException { + try { + // InternalRos2Parser.g:2308:1: ( ruleArrayTopicSpecRef EOF ) + // InternalRos2Parser.g:2309:1: ruleArrayTopicSpecRef EOF + { + before(grammarAccess.getArrayTopicSpecRefRule()); + pushFollow(FOLLOW_1); + ruleArrayTopicSpecRef(); + + state._fsp--; + + after(grammarAccess.getArrayTopicSpecRefRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleArrayTopicSpecRef" + + + // $ANTLR start "ruleArrayTopicSpecRef" + // InternalRos2Parser.g:2316:1: ruleArrayTopicSpecRef : ( ( rule__ArrayTopicSpecRef__Group__0 ) ) ; + public final void ruleArrayTopicSpecRef() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2320:2: ( ( ( rule__ArrayTopicSpecRef__Group__0 ) ) ) + // InternalRos2Parser.g:2321:2: ( ( rule__ArrayTopicSpecRef__Group__0 ) ) + { + // InternalRos2Parser.g:2321:2: ( ( rule__ArrayTopicSpecRef__Group__0 ) ) + // InternalRos2Parser.g:2322:3: ( rule__ArrayTopicSpecRef__Group__0 ) + { + before(grammarAccess.getArrayTopicSpecRefAccess().getGroup()); + // InternalRos2Parser.g:2323:3: ( rule__ArrayTopicSpecRef__Group__0 ) + // InternalRos2Parser.g:2323:4: rule__ArrayTopicSpecRef__Group__0 + { + pushFollow(FOLLOW_2); + rule__ArrayTopicSpecRef__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getArrayTopicSpecRefAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleArrayTopicSpecRef" + + + // $ANTLR start "entryRuleKEYWORD" + // InternalRos2Parser.g:2332:1: entryRuleKEYWORD : ruleKEYWORD EOF ; + public final void entryRuleKEYWORD() throws RecognitionException { + try { + // InternalRos2Parser.g:2333:1: ( ruleKEYWORD EOF ) + // InternalRos2Parser.g:2334:1: ruleKEYWORD EOF + { + before(grammarAccess.getKEYWORDRule()); + pushFollow(FOLLOW_1); + ruleKEYWORD(); + + state._fsp--; + + after(grammarAccess.getKEYWORDRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleKEYWORD" + + + // $ANTLR start "ruleKEYWORD" + // InternalRos2Parser.g:2341:1: ruleKEYWORD : ( ( rule__KEYWORD__Alternatives ) ) ; + public final void ruleKEYWORD() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2345:2: ( ( ( rule__KEYWORD__Alternatives ) ) ) + // InternalRos2Parser.g:2346:2: ( ( rule__KEYWORD__Alternatives ) ) + { + // InternalRos2Parser.g:2346:2: ( ( rule__KEYWORD__Alternatives ) ) + // InternalRos2Parser.g:2347:3: ( rule__KEYWORD__Alternatives ) + { + before(grammarAccess.getKEYWORDAccess().getAlternatives()); + // InternalRos2Parser.g:2348:3: ( rule__KEYWORD__Alternatives ) + // InternalRos2Parser.g:2348:4: rule__KEYWORD__Alternatives + { + pushFollow(FOLLOW_2); + rule__KEYWORD__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getKEYWORDAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleKEYWORD" + + + // $ANTLR start "rule__QualityOfService__QoSProfileAlternatives_1_0_1_0" + // InternalRos2Parser.g:2356:1: rule__QualityOfService__QoSProfileAlternatives_1_0_1_0 : ( ( Default_qos ) | ( Services_qos ) | ( Sensor_qos ) | ( Parameter_qos ) ); + public final void rule__QualityOfService__QoSProfileAlternatives_1_0_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2360:1: ( ( Default_qos ) | ( Services_qos ) | ( Sensor_qos ) | ( Parameter_qos ) ) + int alt1=4; + switch ( input.LA(1) ) { + case Default_qos: + { + alt1=1; + } + break; + case Services_qos: + { + alt1=2; + } + break; + case Sensor_qos: + { + alt1=3; + } + break; + case Parameter_qos: + { + alt1=4; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 1, 0, input); + + throw nvae; + } + + switch (alt1) { + case 1 : + // InternalRos2Parser.g:2361:2: ( Default_qos ) + { + // InternalRos2Parser.g:2361:2: ( Default_qos ) + // InternalRos2Parser.g:2362:3: Default_qos + { + before(grammarAccess.getQualityOfServiceAccess().getQoSProfileDefault_qosKeyword_1_0_1_0_0()); + match(input,Default_qos,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getQoSProfileDefault_qosKeyword_1_0_1_0_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2367:2: ( Services_qos ) + { + // InternalRos2Parser.g:2367:2: ( Services_qos ) + // InternalRos2Parser.g:2368:3: Services_qos + { + before(grammarAccess.getQualityOfServiceAccess().getQoSProfileServices_qosKeyword_1_0_1_0_1()); + match(input,Services_qos,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getQoSProfileServices_qosKeyword_1_0_1_0_1()); + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:2373:2: ( Sensor_qos ) + { + // InternalRos2Parser.g:2373:2: ( Sensor_qos ) + // InternalRos2Parser.g:2374:3: Sensor_qos + { + before(grammarAccess.getQualityOfServiceAccess().getQoSProfileSensor_qosKeyword_1_0_1_0_2()); + match(input,Sensor_qos,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getQoSProfileSensor_qosKeyword_1_0_1_0_2()); + + } + + + } + break; + case 4 : + // InternalRos2Parser.g:2379:2: ( Parameter_qos ) + { + // InternalRos2Parser.g:2379:2: ( Parameter_qos ) + // InternalRos2Parser.g:2380:3: Parameter_qos + { + before(grammarAccess.getQualityOfServiceAccess().getQoSProfileParameter_qosKeyword_1_0_1_0_3()); + match(input,Parameter_qos,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getQoSProfileParameter_qosKeyword_1_0_1_0_3()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__QoSProfileAlternatives_1_0_1_0" + + + // $ANTLR start "rule__QualityOfService__HistoryAlternatives_1_1_1_0" + // InternalRos2Parser.g:2389:1: rule__QualityOfService__HistoryAlternatives_1_1_1_0 : ( ( Keep_last ) | ( Keep_all ) ); + public final void rule__QualityOfService__HistoryAlternatives_1_1_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2393:1: ( ( Keep_last ) | ( Keep_all ) ) + int alt2=2; + int LA2_0 = input.LA(1); + + if ( LA2_0 == Keep_last ) { + alt2=1; + } + else if ( LA2_0 == Keep_all ) { + alt2=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 2, 0, input); + + throw nvae; + } + switch (alt2) { + case 1 : + // InternalRos2Parser.g:2394:2: ( Keep_last ) + { + // InternalRos2Parser.g:2394:2: ( Keep_last ) + // InternalRos2Parser.g:2395:3: Keep_last + { + before(grammarAccess.getQualityOfServiceAccess().getHistoryKeep_lastKeyword_1_1_1_0_0()); + match(input,Keep_last,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getHistoryKeep_lastKeyword_1_1_1_0_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2400:2: ( Keep_all ) + { + // InternalRos2Parser.g:2400:2: ( Keep_all ) + // InternalRos2Parser.g:2401:3: Keep_all + { + before(grammarAccess.getQualityOfServiceAccess().getHistoryKeep_allKeyword_1_1_1_0_1()); + match(input,Keep_all,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getHistoryKeep_allKeyword_1_1_1_0_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__HistoryAlternatives_1_1_1_0" + + + // $ANTLR start "rule__QualityOfService__ReliabilityAlternatives_1_3_1_0" + // InternalRos2Parser.g:2410:1: rule__QualityOfService__ReliabilityAlternatives_1_3_1_0 : ( ( Best_effort ) | ( Reliable ) ); + public final void rule__QualityOfService__ReliabilityAlternatives_1_3_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2414:1: ( ( Best_effort ) | ( Reliable ) ) + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0==Best_effort) ) { + alt3=1; + } + else if ( (LA3_0==Reliable) ) { + alt3=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + switch (alt3) { + case 1 : + // InternalRos2Parser.g:2415:2: ( Best_effort ) + { + // InternalRos2Parser.g:2415:2: ( Best_effort ) + // InternalRos2Parser.g:2416:3: Best_effort + { + before(grammarAccess.getQualityOfServiceAccess().getReliabilityBest_effortKeyword_1_3_1_0_0()); + match(input,Best_effort,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getReliabilityBest_effortKeyword_1_3_1_0_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2421:2: ( Reliable ) + { + // InternalRos2Parser.g:2421:2: ( Reliable ) + // InternalRos2Parser.g:2422:3: Reliable + { + before(grammarAccess.getQualityOfServiceAccess().getReliabilityReliableKeyword_1_3_1_0_1()); + match(input,Reliable,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getReliabilityReliableKeyword_1_3_1_0_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__ReliabilityAlternatives_1_3_1_0" + + + // $ANTLR start "rule__QualityOfService__DurabilityAlternatives_1_4_1_0" + // InternalRos2Parser.g:2431:1: rule__QualityOfService__DurabilityAlternatives_1_4_1_0 : ( ( Transient_local ) | ( Volatile ) ); + public final void rule__QualityOfService__DurabilityAlternatives_1_4_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2435:1: ( ( Transient_local ) | ( Volatile ) ) + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0==Transient_local) ) { + alt4=1; + } + else if ( (LA4_0==Volatile) ) { + alt4=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + switch (alt4) { + case 1 : + // InternalRos2Parser.g:2436:2: ( Transient_local ) + { + // InternalRos2Parser.g:2436:2: ( Transient_local ) + // InternalRos2Parser.g:2437:3: Transient_local + { + before(grammarAccess.getQualityOfServiceAccess().getDurabilityTransient_localKeyword_1_4_1_0_0()); + match(input,Transient_local,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getDurabilityTransient_localKeyword_1_4_1_0_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2442:2: ( Volatile ) + { + // InternalRos2Parser.g:2442:2: ( Volatile ) + // InternalRos2Parser.g:2443:3: Volatile + { + before(grammarAccess.getQualityOfServiceAccess().getDurabilityVolatileKeyword_1_4_1_0_1()); + match(input,Volatile,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getDurabilityVolatileKeyword_1_4_1_0_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__DurabilityAlternatives_1_4_1_0" + + + // $ANTLR start "rule__EString__Alternatives" + // InternalRos2Parser.g:2452:1: rule__EString__Alternatives : ( ( RULE_STRING ) | ( RULE_ID ) ); + public final void rule__EString__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2456:1: ( ( RULE_STRING ) | ( RULE_ID ) ) + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0==RULE_STRING) ) { + alt5=1; + } + else if ( (LA5_0==RULE_ID) ) { + alt5=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + + throw nvae; + } + switch (alt5) { + case 1 : + // InternalRos2Parser.g:2457:2: ( RULE_STRING ) + { + // InternalRos2Parser.g:2457:2: ( RULE_STRING ) + // InternalRos2Parser.g:2458:3: RULE_STRING + { + before(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + match(input,RULE_STRING,FOLLOW_2); + after(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2463:2: ( RULE_ID ) + { + // InternalRos2Parser.g:2463:2: ( RULE_ID ) + // InternalRos2Parser.g:2464: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__RosNames__Alternatives" + // InternalRos2Parser.g:2473:1: rule__RosNames__Alternatives : ( ( RULE_ROS_CONVENTION_A ) | ( RULE_ID ) | ( Node ) ); + public final void rule__RosNames__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2477:1: ( ( RULE_ROS_CONVENTION_A ) | ( RULE_ID ) | ( Node ) ) + int alt6=3; + switch ( input.LA(1) ) { + case RULE_ROS_CONVENTION_A: + { + alt6=1; + } + break; + case RULE_ID: + { + alt6=2; + } + break; + case Node: + { + alt6=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + + switch (alt6) { + case 1 : + // InternalRos2Parser.g:2478:2: ( RULE_ROS_CONVENTION_A ) + { + // InternalRos2Parser.g:2478:2: ( RULE_ROS_CONVENTION_A ) + // InternalRos2Parser.g:2479: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 : + // InternalRos2Parser.g:2484:2: ( RULE_ID ) + { + // InternalRos2Parser.g:2484:2: ( RULE_ID ) + // InternalRos2Parser.g:2485:3: RULE_ID + { + before(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); + match(input,RULE_ID,FOLLOW_2); + after(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:2490:2: ( Node ) + { + // InternalRos2Parser.g:2490:2: ( Node ) + // InternalRos2Parser.g:2491: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__Node__Alternatives_3" + // InternalRos2Parser.g:2500:1: rule__Node__Alternatives_3 : ( ( ( rule__Node__Group_3_0__0 ) ) | ( ( rule__Node__Group_3_1__0 ) ) | ( ( rule__Node__Group_3_2__0 ) ) | ( ( rule__Node__Group_3_3__0 ) ) | ( ( rule__Node__Group_3_4__0 ) ) | ( ( rule__Node__Group_3_5__0 ) ) | ( ( rule__Node__Group_3_6__0 ) ) ); + public final void rule__Node__Alternatives_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2504:1: ( ( ( rule__Node__Group_3_0__0 ) ) | ( ( rule__Node__Group_3_1__0 ) ) | ( ( rule__Node__Group_3_2__0 ) ) | ( ( rule__Node__Group_3_3__0 ) ) | ( ( rule__Node__Group_3_4__0 ) ) | ( ( rule__Node__Group_3_5__0 ) ) | ( ( rule__Node__Group_3_6__0 ) ) ) + int alt7=7; + switch ( input.LA(1) ) { + case Publishers: + { + alt7=1; + } + break; + case Subscribers: + { + alt7=2; + } + break; + case Serviceserver: + { + alt7=3; + } + break; + case Serviceclient: + { + alt7=4; + } + break; + case Actionserver: + { + alt7=5; + } + break; + case Actionclient: + { + alt7=6; + } + break; + case Parameters: + { + alt7=7; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + + throw nvae; + } + + switch (alt7) { + case 1 : + // InternalRos2Parser.g:2505:2: ( ( rule__Node__Group_3_0__0 ) ) + { + // InternalRos2Parser.g:2505:2: ( ( rule__Node__Group_3_0__0 ) ) + // InternalRos2Parser.g:2506:3: ( rule__Node__Group_3_0__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_0()); + // InternalRos2Parser.g:2507:3: ( rule__Node__Group_3_0__0 ) + // InternalRos2Parser.g:2507:4: rule__Node__Group_3_0__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_0__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2511:2: ( ( rule__Node__Group_3_1__0 ) ) + { + // InternalRos2Parser.g:2511:2: ( ( rule__Node__Group_3_1__0 ) ) + // InternalRos2Parser.g:2512:3: ( rule__Node__Group_3_1__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_1()); + // InternalRos2Parser.g:2513:3: ( rule__Node__Group_3_1__0 ) + // InternalRos2Parser.g:2513:4: rule__Node__Group_3_1__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_1__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_1()); + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:2517:2: ( ( rule__Node__Group_3_2__0 ) ) + { + // InternalRos2Parser.g:2517:2: ( ( rule__Node__Group_3_2__0 ) ) + // InternalRos2Parser.g:2518:3: ( rule__Node__Group_3_2__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_2()); + // InternalRos2Parser.g:2519:3: ( rule__Node__Group_3_2__0 ) + // InternalRos2Parser.g:2519:4: rule__Node__Group_3_2__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_2__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_2()); + + } + + + } + break; + case 4 : + // InternalRos2Parser.g:2523:2: ( ( rule__Node__Group_3_3__0 ) ) + { + // InternalRos2Parser.g:2523:2: ( ( rule__Node__Group_3_3__0 ) ) + // InternalRos2Parser.g:2524:3: ( rule__Node__Group_3_3__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_3()); + // InternalRos2Parser.g:2525:3: ( rule__Node__Group_3_3__0 ) + // InternalRos2Parser.g:2525:4: rule__Node__Group_3_3__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_3__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_3()); + + } + + + } + break; + case 5 : + // InternalRos2Parser.g:2529:2: ( ( rule__Node__Group_3_4__0 ) ) + { + // InternalRos2Parser.g:2529:2: ( ( rule__Node__Group_3_4__0 ) ) + // InternalRos2Parser.g:2530:3: ( rule__Node__Group_3_4__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_4()); + // InternalRos2Parser.g:2531:3: ( rule__Node__Group_3_4__0 ) + // InternalRos2Parser.g:2531:4: rule__Node__Group_3_4__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_4__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_4()); + + } + + + } + break; + case 6 : + // InternalRos2Parser.g:2535:2: ( ( rule__Node__Group_3_5__0 ) ) + { + // InternalRos2Parser.g:2535:2: ( ( rule__Node__Group_3_5__0 ) ) + // InternalRos2Parser.g:2536:3: ( rule__Node__Group_3_5__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_5()); + // InternalRos2Parser.g:2537:3: ( rule__Node__Group_3_5__0 ) + // InternalRos2Parser.g:2537:4: rule__Node__Group_3_5__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_5__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_5()); + + } + + + } + break; + case 7 : + // InternalRos2Parser.g:2541:2: ( ( rule__Node__Group_3_6__0 ) ) + { + // InternalRos2Parser.g:2541:2: ( ( rule__Node__Group_3_6__0 ) ) + // InternalRos2Parser.g:2542:3: ( rule__Node__Group_3_6__0 ) + { + before(grammarAccess.getNodeAccess().getGroup_3_6()); + // InternalRos2Parser.g:2543:3: ( rule__Node__Group_3_6__0 ) + // InternalRos2Parser.g:2543:4: rule__Node__Group_3_6__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_6__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup_3_6()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Alternatives_3" + + + // $ANTLR start "rule__SpecBase__Alternatives" + // InternalRos2Parser.g:2551:1: rule__SpecBase__Alternatives : ( ( ruleTopicSpec ) | ( ruleServiceSpec ) | ( ruleActionSpec ) ); + public final void rule__SpecBase__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2555:1: ( ( ruleTopicSpec ) | ( ruleServiceSpec ) | ( ruleActionSpec ) ) + int alt8=3; + switch ( input.LA(1) ) { + case Msg: + { + alt8=1; + } + break; + case Srv: + { + alt8=2; + } + break; + case Action_1: + { + alt8=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 8, 0, input); + + throw nvae; + } + + switch (alt8) { + case 1 : + // InternalRos2Parser.g:2556:2: ( ruleTopicSpec ) + { + // InternalRos2Parser.g:2556:2: ( ruleTopicSpec ) + // InternalRos2Parser.g:2557:3: ruleTopicSpec + { + before(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleTopicSpec(); + + state._fsp--; + + after(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2562:2: ( ruleServiceSpec ) + { + // InternalRos2Parser.g:2562:2: ( ruleServiceSpec ) + // InternalRos2Parser.g:2563:3: ruleServiceSpec + { + before(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleServiceSpec(); + + state._fsp--; + + after(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:2568:2: ( ruleActionSpec ) + { + // InternalRos2Parser.g:2568:2: ( ruleActionSpec ) + // InternalRos2Parser.g:2569:3: ruleActionSpec + { + before(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); + pushFollow(FOLLOW_2); + ruleActionSpec(); + + state._fsp--; + + after(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SpecBase__Alternatives" + + + // $ANTLR start "rule__TopicSpec__NameAlternatives_2_0" + // InternalRos2Parser.g:2578:1: rule__TopicSpec__NameAlternatives_2_0 : ( ( ruleEString ) | ( Header ) | ( String ) ); + public final void rule__TopicSpec__NameAlternatives_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2582:1: ( ( ruleEString ) | ( Header ) | ( String ) ) + int alt9=3; + switch ( input.LA(1) ) { + case RULE_ID: + case RULE_STRING: + { + alt9=1; + } + break; + case Header: + { + alt9=2; + } + break; + case String: + { + alt9=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + + throw nvae; + } + + switch (alt9) { + case 1 : + // InternalRos2Parser.g:2583:2: ( ruleEString ) + { + // InternalRos2Parser.g:2583:2: ( ruleEString ) + // InternalRos2Parser.g:2584:3: ruleEString + { + before(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2589:2: ( Header ) + { + // InternalRos2Parser.g:2589:2: ( Header ) + // InternalRos2Parser.g:2590:3: Header + { + before(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); + match(input,Header,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:2595:2: ( String ) + { + // InternalRos2Parser.g:2595:2: ( String ) + // InternalRos2Parser.g:2596:3: String + { + before(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); + match(input,String,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__NameAlternatives_2_0" + + + // $ANTLR start "rule__Dependency__Alternatives" + // InternalRos2Parser.g:2605:1: rule__Dependency__Alternatives : ( ( rulePackageDependency ) | ( ruleExternalDependency ) ); + public final void rule__Dependency__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2609:1: ( ( rulePackageDependency ) | ( ruleExternalDependency ) ) + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==RULE_ID||LA10_0==RULE_STRING) ) { + alt10=1; + } + else if ( (LA10_0==ExternalDependency) ) { + alt10=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 10, 0, input); + + throw nvae; + } + switch (alt10) { + case 1 : + // InternalRos2Parser.g:2610:2: ( rulePackageDependency ) + { + // InternalRos2Parser.g:2610:2: ( rulePackageDependency ) + // InternalRos2Parser.g:2611:3: rulePackageDependency + { + before(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + pushFollow(FOLLOW_2); + rulePackageDependency(); + + state._fsp--; + + after(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2616:2: ( ruleExternalDependency ) + { + // InternalRos2Parser.g:2616:2: ( ruleExternalDependency ) + // InternalRos2Parser.g:2617: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__Namespace__Alternatives" + // InternalRos2Parser.g:2626:1: rule__Namespace__Alternatives : ( ( ruleGlobalNamespace ) | ( ruleRelativeNamespace_Impl ) | ( rulePrivateNamespace ) ); + public final void rule__Namespace__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2630:1: ( ( ruleGlobalNamespace ) | ( ruleRelativeNamespace_Impl ) | ( rulePrivateNamespace ) ) + int alt11=3; + switch ( input.LA(1) ) { + case GlobalNamespace: + { + alt11=1; + } + break; + case RelativeNamespace: + { + alt11=2; + } + break; + case PrivateNamespace: + { + alt11=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 11, 0, input); + + throw nvae; + } + + switch (alt11) { + case 1 : + // InternalRos2Parser.g:2631:2: ( ruleGlobalNamespace ) + { + // InternalRos2Parser.g:2631:2: ( ruleGlobalNamespace ) + // InternalRos2Parser.g:2632:3: ruleGlobalNamespace + { + before(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleGlobalNamespace(); + + state._fsp--; + + after(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2637:2: ( ruleRelativeNamespace_Impl ) + { + // InternalRos2Parser.g:2637:2: ( ruleRelativeNamespace_Impl ) + // InternalRos2Parser.g:2638:3: ruleRelativeNamespace_Impl + { + before(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleRelativeNamespace_Impl(); + + state._fsp--; + + after(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:2643:2: ( rulePrivateNamespace ) + { + // InternalRos2Parser.g:2643:2: ( rulePrivateNamespace ) + // InternalRos2Parser.g:2644:3: rulePrivateNamespace + { + before(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + pushFollow(FOLLOW_2); + rulePrivateNamespace(); + + state._fsp--; + + after(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Namespace__Alternatives" + + + // $ANTLR start "rule__ParameterType__Alternatives" + // InternalRos2Parser.g:2653:1: rule__ParameterType__Alternatives : ( ( ruleParameterListType ) | ( ruleParameterStructType ) | ( ruleParameterIntegerType ) | ( ruleParameterStringType ) | ( ruleParameterDoubleType ) | ( ruleParameterBooleanType ) | ( ruleParameterBase64Type ) | ( ruleParameterArrayType ) ); + public final void rule__ParameterType__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2657:1: ( ( ruleParameterListType ) | ( ruleParameterStructType ) | ( ruleParameterIntegerType ) | ( ruleParameterStringType ) | ( ruleParameterDoubleType ) | ( ruleParameterBooleanType ) | ( ruleParameterBase64Type ) | ( ruleParameterArrayType ) ) + int alt12=8; + switch ( input.LA(1) ) { + case List: + { + alt12=1; + } + break; + case Struct: + { + alt12=2; + } + break; + case Integer: + { + alt12=3; + } + break; + case String: + { + alt12=4; + } + break; + case Double: + { + alt12=5; + } + break; + case Boolean: + { + alt12=6; + } + break; + case Base64: + { + alt12=7; + } + break; + case Array: + { + alt12=8; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 12, 0, input); + + throw nvae; + } + + switch (alt12) { + case 1 : + // InternalRos2Parser.g:2658:2: ( ruleParameterListType ) + { + // InternalRos2Parser.g:2658:2: ( ruleParameterListType ) + // InternalRos2Parser.g:2659:3: ruleParameterListType + { + before(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleParameterListType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2664:2: ( ruleParameterStructType ) + { + // InternalRos2Parser.g:2664:2: ( ruleParameterStructType ) + // InternalRos2Parser.g:2665:3: ruleParameterStructType + { + before(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleParameterStructType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:2670:2: ( ruleParameterIntegerType ) + { + // InternalRos2Parser.g:2670:2: ( ruleParameterIntegerType ) + // InternalRos2Parser.g:2671:3: ruleParameterIntegerType + { + before(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); + pushFollow(FOLLOW_2); + ruleParameterIntegerType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); + + } + + + } + break; + case 4 : + // InternalRos2Parser.g:2676:2: ( ruleParameterStringType ) + { + // InternalRos2Parser.g:2676:2: ( ruleParameterStringType ) + // InternalRos2Parser.g:2677:3: ruleParameterStringType + { + before(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); + pushFollow(FOLLOW_2); + ruleParameterStringType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); + + } + + + } + break; + case 5 : + // InternalRos2Parser.g:2682:2: ( ruleParameterDoubleType ) + { + // InternalRos2Parser.g:2682:2: ( ruleParameterDoubleType ) + // InternalRos2Parser.g:2683:3: ruleParameterDoubleType + { + before(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); + pushFollow(FOLLOW_2); + ruleParameterDoubleType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); + + } + + + } + break; + case 6 : + // InternalRos2Parser.g:2688:2: ( ruleParameterBooleanType ) + { + // InternalRos2Parser.g:2688:2: ( ruleParameterBooleanType ) + // InternalRos2Parser.g:2689:3: ruleParameterBooleanType + { + before(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); + pushFollow(FOLLOW_2); + ruleParameterBooleanType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); + + } + + + } + break; + case 7 : + // InternalRos2Parser.g:2694:2: ( ruleParameterBase64Type ) + { + // InternalRos2Parser.g:2694:2: ( ruleParameterBase64Type ) + // InternalRos2Parser.g:2695:3: ruleParameterBase64Type + { + before(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); + pushFollow(FOLLOW_2); + ruleParameterBase64Type(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); + + } + + + } + break; + case 8 : + // InternalRos2Parser.g:2700:2: ( ruleParameterArrayType ) + { + // InternalRos2Parser.g:2700:2: ( ruleParameterArrayType ) + // InternalRos2Parser.g:2701:3: ruleParameterArrayType + { + before(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); + pushFollow(FOLLOW_2); + ruleParameterArrayType(); + + state._fsp--; + + after(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterType__Alternatives" + + + // $ANTLR start "rule__ParameterValue__Alternatives" + // InternalRos2Parser.g:2710:1: rule__ParameterValue__Alternatives : ( ( ruleParameterString ) | ( ruleParameterBase64 ) | ( ruleParameterInteger ) | ( ruleParameterDouble ) | ( ruleParameterBoolean ) | ( ruleParameterList ) | ( ruleParameterStruct ) ); + public final void rule__ParameterValue__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2714:1: ( ( ruleParameterString ) | ( ruleParameterBase64 ) | ( ruleParameterInteger ) | ( ruleParameterDouble ) | ( ruleParameterBoolean ) | ( ruleParameterList ) | ( ruleParameterStruct ) ) + int alt13=7; + switch ( input.LA(1) ) { + case RULE_ID: + case RULE_STRING: + { + alt13=1; + } + break; + case RULE_BINARY: + { + alt13=2; + } + break; + case RULE_DECINT: + { + alt13=3; + } + break; + case RULE_DOUBLE: + { + alt13=4; + } + break; + case RULE_BOOLEAN: + { + alt13=5; + } + break; + case LeftSquareBracket: + { + int LA13_6 = input.LA(2); + + if ( (LA13_6==Comma||(LA13_6>=LeftSquareBracket && LA13_6<=RightSquareBracket)||LA13_6==RULE_ID||LA13_6==RULE_STRING||(LA13_6>=RULE_BINARY && LA13_6<=RULE_DOUBLE)) ) { + alt13=6; + } + else if ( (LA13_6==ParameterStructMember) ) { + alt13=7; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 13, 6, input); + + throw nvae; + } + } + break; + case EOF: + case Comma: + case RightSquareBracket: + case RULE_END: + { + alt13=7; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 13, 0, input); + + throw nvae; + } + + switch (alt13) { + case 1 : + // InternalRos2Parser.g:2715:2: ( ruleParameterString ) + { + // InternalRos2Parser.g:2715:2: ( ruleParameterString ) + // InternalRos2Parser.g:2716:3: ruleParameterString + { + before(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleParameterString(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2721:2: ( ruleParameterBase64 ) + { + // InternalRos2Parser.g:2721:2: ( ruleParameterBase64 ) + // InternalRos2Parser.g:2722:3: ruleParameterBase64 + { + before(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleParameterBase64(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:2727:2: ( ruleParameterInteger ) + { + // InternalRos2Parser.g:2727:2: ( ruleParameterInteger ) + // InternalRos2Parser.g:2728:3: ruleParameterInteger + { + before(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); + pushFollow(FOLLOW_2); + ruleParameterInteger(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); + + } + + + } + break; + case 4 : + // InternalRos2Parser.g:2733:2: ( ruleParameterDouble ) + { + // InternalRos2Parser.g:2733:2: ( ruleParameterDouble ) + // InternalRos2Parser.g:2734:3: ruleParameterDouble + { + before(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); + pushFollow(FOLLOW_2); + ruleParameterDouble(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); + + } + + + } + break; + case 5 : + // InternalRos2Parser.g:2739:2: ( ruleParameterBoolean ) + { + // InternalRos2Parser.g:2739:2: ( ruleParameterBoolean ) + // InternalRos2Parser.g:2740:3: ruleParameterBoolean + { + before(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); + pushFollow(FOLLOW_2); + ruleParameterBoolean(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); + + } + + + } + break; + case 6 : + // InternalRos2Parser.g:2745:2: ( ruleParameterList ) + { + // InternalRos2Parser.g:2745:2: ( ruleParameterList ) + // InternalRos2Parser.g:2746:3: ruleParameterList + { + before(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); + pushFollow(FOLLOW_2); + ruleParameterList(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); + + } + + + } + break; + case 7 : + // InternalRos2Parser.g:2751:2: ( ruleParameterStruct ) + { + // InternalRos2Parser.g:2751:2: ( ruleParameterStruct ) + // InternalRos2Parser.g:2752:3: ruleParameterStruct + { + before(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); + pushFollow(FOLLOW_2); + ruleParameterStruct(); + + state._fsp--; + + after(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterValue__Alternatives" + + + // $ANTLR start "rule__MessagePart__DataAlternatives_1_0" + // InternalRos2Parser.g:2761:1: rule__MessagePart__DataAlternatives_1_0 : ( ( ruleKEYWORD ) | ( RULE_MESSAGE_ASIGMENT ) | ( ruleEString ) ); + public final void rule__MessagePart__DataAlternatives_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2765:1: ( ( ruleKEYWORD ) | ( RULE_MESSAGE_ASIGMENT ) | ( ruleEString ) ) + int alt14=3; + switch ( input.LA(1) ) { + case Duration: + case Feedback: + case Message: + case Service: + case Action: + case Result: + case Value: + case Goal: + case Name: + case Time: + case Type: + { + alt14=1; + } + break; + case RULE_MESSAGE_ASIGMENT: + { + alt14=2; + } + break; + case RULE_ID: + case RULE_STRING: + { + alt14=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + + throw nvae; + } + + switch (alt14) { + case 1 : + // InternalRos2Parser.g:2766:2: ( ruleKEYWORD ) + { + // InternalRos2Parser.g:2766:2: ( ruleKEYWORD ) + // InternalRos2Parser.g:2767:3: ruleKEYWORD + { + before(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); + pushFollow(FOLLOW_2); + ruleKEYWORD(); + + state._fsp--; + + after(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2772:2: ( RULE_MESSAGE_ASIGMENT ) + { + // InternalRos2Parser.g:2772:2: ( RULE_MESSAGE_ASIGMENT ) + // InternalRos2Parser.g:2773:3: RULE_MESSAGE_ASIGMENT + { + before(grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); + match(input,RULE_MESSAGE_ASIGMENT,FOLLOW_2); + after(grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:2778:2: ( ruleEString ) + { + // InternalRos2Parser.g:2778:2: ( ruleEString ) + // InternalRos2Parser.g:2779:3: ruleEString + { + before(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__DataAlternatives_1_0" + + + // $ANTLR start "rule__AbstractType__Alternatives" + // InternalRos2Parser.g:2788:1: rule__AbstractType__Alternatives : ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) ); + public final void rule__AbstractType__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2792:1: ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) ) + int alt15=31; + alt15 = dfa15.predict(input); + switch (alt15) { + case 1 : + // InternalRos2Parser.g:2793:2: ( rulebool ) + { + // InternalRos2Parser.g:2793:2: ( rulebool ) + // InternalRos2Parser.g:2794:3: rulebool + { + before(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); + pushFollow(FOLLOW_2); + rulebool(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2799:2: ( ruleint8 ) + { + // InternalRos2Parser.g:2799:2: ( ruleint8 ) + // InternalRos2Parser.g:2800:3: ruleint8 + { + before(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleint8(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:2805:2: ( ruleuint8 ) + { + // InternalRos2Parser.g:2805:2: ( ruleuint8 ) + // InternalRos2Parser.g:2806:3: ruleuint8 + { + before(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); + pushFollow(FOLLOW_2); + ruleuint8(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); + + } + + + } + break; + case 4 : + // InternalRos2Parser.g:2811:2: ( ruleint16 ) + { + // InternalRos2Parser.g:2811:2: ( ruleint16 ) + // InternalRos2Parser.g:2812:3: ruleint16 + { + before(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); + pushFollow(FOLLOW_2); + ruleint16(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); + + } + + + } + break; + case 5 : + // InternalRos2Parser.g:2817:2: ( ruleuint16 ) + { + // InternalRos2Parser.g:2817:2: ( ruleuint16 ) + // InternalRos2Parser.g:2818:3: ruleuint16 + { + before(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); + pushFollow(FOLLOW_2); + ruleuint16(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); + + } + + + } + break; + case 6 : + // InternalRos2Parser.g:2823:2: ( ruleint32 ) + { + // InternalRos2Parser.g:2823:2: ( ruleint32 ) + // InternalRos2Parser.g:2824:3: ruleint32 + { + before(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); + pushFollow(FOLLOW_2); + ruleint32(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); + + } + + + } + break; + case 7 : + // InternalRos2Parser.g:2829:2: ( ruleuint32 ) + { + // InternalRos2Parser.g:2829:2: ( ruleuint32 ) + // InternalRos2Parser.g:2830:3: ruleuint32 + { + before(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); + pushFollow(FOLLOW_2); + ruleuint32(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); + + } + + + } + break; + case 8 : + // InternalRos2Parser.g:2835:2: ( ruleint64 ) + { + // InternalRos2Parser.g:2835:2: ( ruleint64 ) + // InternalRos2Parser.g:2836:3: ruleint64 + { + before(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); + pushFollow(FOLLOW_2); + ruleint64(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); + + } + + + } + break; + case 9 : + // InternalRos2Parser.g:2841:2: ( ruleuint64 ) + { + // InternalRos2Parser.g:2841:2: ( ruleuint64 ) + // InternalRos2Parser.g:2842:3: ruleuint64 + { + before(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); + pushFollow(FOLLOW_2); + ruleuint64(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); + + } + + + } + break; + case 10 : + // InternalRos2Parser.g:2847:2: ( rulefloat32 ) + { + // InternalRos2Parser.g:2847:2: ( rulefloat32 ) + // InternalRos2Parser.g:2848:3: rulefloat32 + { + before(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); + pushFollow(FOLLOW_2); + rulefloat32(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); + + } + + + } + break; + case 11 : + // InternalRos2Parser.g:2853:2: ( rulefloat64 ) + { + // InternalRos2Parser.g:2853:2: ( rulefloat64 ) + // InternalRos2Parser.g:2854:3: rulefloat64 + { + before(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); + pushFollow(FOLLOW_2); + rulefloat64(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); + + } + + + } + break; + case 12 : + // InternalRos2Parser.g:2859:2: ( rulestring0 ) + { + // InternalRos2Parser.g:2859:2: ( rulestring0 ) + // InternalRos2Parser.g:2860:3: rulestring0 + { + before(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); + pushFollow(FOLLOW_2); + rulestring0(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); + + } + + + } + break; + case 13 : + // InternalRos2Parser.g:2865:2: ( rulebyte ) + { + // InternalRos2Parser.g:2865:2: ( rulebyte ) + // InternalRos2Parser.g:2866:3: rulebyte + { + before(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); + pushFollow(FOLLOW_2); + rulebyte(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); + + } + + + } + break; + case 14 : + // InternalRos2Parser.g:2871:2: ( ruletime ) + { + // InternalRos2Parser.g:2871:2: ( ruletime ) + // InternalRos2Parser.g:2872:3: ruletime + { + before(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); + pushFollow(FOLLOW_2); + ruletime(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); + + } + + + } + break; + case 15 : + // InternalRos2Parser.g:2877:2: ( ruleduration ) + { + // InternalRos2Parser.g:2877:2: ( ruleduration ) + // InternalRos2Parser.g:2878:3: ruleduration + { + before(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); + pushFollow(FOLLOW_2); + ruleduration(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); + + } + + + } + break; + case 16 : + // InternalRos2Parser.g:2883:2: ( ruleHeader ) + { + // InternalRos2Parser.g:2883:2: ( ruleHeader ) + // InternalRos2Parser.g:2884:3: ruleHeader + { + before(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); + pushFollow(FOLLOW_2); + ruleHeader(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); + + } + + + } + break; + case 17 : + // InternalRos2Parser.g:2889:2: ( ruleboolArray ) + { + // InternalRos2Parser.g:2889:2: ( ruleboolArray ) + // InternalRos2Parser.g:2890:3: ruleboolArray + { + before(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); + pushFollow(FOLLOW_2); + ruleboolArray(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); + + } + + + } + break; + case 18 : + // InternalRos2Parser.g:2895:2: ( ruleint8Array ) + { + // InternalRos2Parser.g:2895:2: ( ruleint8Array ) + // InternalRos2Parser.g:2896:3: ruleint8Array + { + before(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); + pushFollow(FOLLOW_2); + ruleint8Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); + + } + + + } + break; + case 19 : + // InternalRos2Parser.g:2901:2: ( ruleuint8Array ) + { + // InternalRos2Parser.g:2901:2: ( ruleuint8Array ) + // InternalRos2Parser.g:2902:3: ruleuint8Array + { + before(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); + pushFollow(FOLLOW_2); + ruleuint8Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); + + } + + + } + break; + case 20 : + // InternalRos2Parser.g:2907:2: ( ruleint16Array ) + { + // InternalRos2Parser.g:2907:2: ( ruleint16Array ) + // InternalRos2Parser.g:2908:3: ruleint16Array + { + before(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); + pushFollow(FOLLOW_2); + ruleint16Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); + + } + + + } + break; + case 21 : + // InternalRos2Parser.g:2913:2: ( ruleuint16Array ) + { + // InternalRos2Parser.g:2913:2: ( ruleuint16Array ) + // InternalRos2Parser.g:2914:3: ruleuint16Array + { + before(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); + pushFollow(FOLLOW_2); + ruleuint16Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); + + } + + + } + break; + case 22 : + // InternalRos2Parser.g:2919:2: ( ruleint32Array ) + { + // InternalRos2Parser.g:2919:2: ( ruleint32Array ) + // InternalRos2Parser.g:2920:3: ruleint32Array + { + before(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); + pushFollow(FOLLOW_2); + ruleint32Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); + + } + + + } + break; + case 23 : + // InternalRos2Parser.g:2925:2: ( ruleuint32Array ) + { + // InternalRos2Parser.g:2925:2: ( ruleuint32Array ) + // InternalRos2Parser.g:2926:3: ruleuint32Array + { + before(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); + pushFollow(FOLLOW_2); + ruleuint32Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); + + } + + + } + break; + case 24 : + // InternalRos2Parser.g:2931:2: ( ruleint64Array ) + { + // InternalRos2Parser.g:2931:2: ( ruleint64Array ) + // InternalRos2Parser.g:2932:3: ruleint64Array + { + before(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); + pushFollow(FOLLOW_2); + ruleint64Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); + + } + + + } + break; + case 25 : + // InternalRos2Parser.g:2937:2: ( ruleuint64Array ) + { + // InternalRos2Parser.g:2937:2: ( ruleuint64Array ) + // InternalRos2Parser.g:2938:3: ruleuint64Array + { + before(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); + pushFollow(FOLLOW_2); + ruleuint64Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); + + } + + + } + break; + case 26 : + // InternalRos2Parser.g:2943:2: ( rulefloat32Array ) + { + // InternalRos2Parser.g:2943:2: ( rulefloat32Array ) + // InternalRos2Parser.g:2944:3: rulefloat32Array + { + before(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); + pushFollow(FOLLOW_2); + rulefloat32Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); + + } + + + } + break; + case 27 : + // InternalRos2Parser.g:2949:2: ( rulefloat64Array ) + { + // InternalRos2Parser.g:2949:2: ( rulefloat64Array ) + // InternalRos2Parser.g:2950:3: rulefloat64Array + { + before(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); + pushFollow(FOLLOW_2); + rulefloat64Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); + + } + + + } + break; + case 28 : + // InternalRos2Parser.g:2955:2: ( rulestring0Array ) + { + // InternalRos2Parser.g:2955:2: ( rulestring0Array ) + // InternalRos2Parser.g:2956:3: rulestring0Array + { + before(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); + pushFollow(FOLLOW_2); + rulestring0Array(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); + + } + + + } + break; + case 29 : + // InternalRos2Parser.g:2961:2: ( rulebyteArray ) + { + // InternalRos2Parser.g:2961:2: ( rulebyteArray ) + // InternalRos2Parser.g:2962:3: rulebyteArray + { + before(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); + pushFollow(FOLLOW_2); + rulebyteArray(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); + + } + + + } + break; + case 30 : + // InternalRos2Parser.g:2967:2: ( ruleTopicSpecRef ) + { + // InternalRos2Parser.g:2967:2: ( ruleTopicSpecRef ) + // InternalRos2Parser.g:2968:3: ruleTopicSpecRef + { + before(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); + pushFollow(FOLLOW_2); + ruleTopicSpecRef(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); + + } + + + } + break; + case 31 : + // InternalRos2Parser.g:2973:2: ( ruleArrayTopicSpecRef ) + { + // InternalRos2Parser.g:2973:2: ( ruleArrayTopicSpecRef ) + // InternalRos2Parser.g:2974:3: ruleArrayTopicSpecRef + { + before(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); + pushFollow(FOLLOW_2); + ruleArrayTopicSpecRef(); + + state._fsp--; + + after(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AbstractType__Alternatives" + + + // $ANTLR start "rule__KEYWORD__Alternatives" + // InternalRos2Parser.g:2983:1: rule__KEYWORD__Alternatives : ( ( Goal ) | ( Message ) | ( Result ) | ( Feedback ) | ( Name ) | ( Value ) | ( Service ) | ( Type ) | ( Action ) | ( Duration ) | ( Time ) ); + public final void rule__KEYWORD__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:2987:1: ( ( Goal ) | ( Message ) | ( Result ) | ( Feedback ) | ( Name ) | ( Value ) | ( Service ) | ( Type ) | ( Action ) | ( Duration ) | ( Time ) ) + int alt16=11; + switch ( input.LA(1) ) { + case Goal: + { + alt16=1; + } + break; + case Message: + { + alt16=2; + } + break; + case Result: + { + alt16=3; + } + break; + case Feedback: + { + alt16=4; + } + break; + case Name: + { + alt16=5; + } + break; + case Value: + { + alt16=6; + } + break; + case Service: + { + alt16=7; + } + break; + case Type: + { + alt16=8; + } + break; + case Action: + { + alt16=9; + } + break; + case Duration: + { + alt16=10; + } + break; + case Time: + { + alt16=11; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + + throw nvae; + } + + switch (alt16) { + case 1 : + // InternalRos2Parser.g:2988:2: ( Goal ) + { + // InternalRos2Parser.g:2988:2: ( Goal ) + // InternalRos2Parser.g:2989:3: Goal + { + before(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); + match(input,Goal,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:2994:2: ( Message ) + { + // InternalRos2Parser.g:2994:2: ( Message ) + // InternalRos2Parser.g:2995:3: Message + { + before(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); + match(input,Message,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:3000:2: ( Result ) + { + // InternalRos2Parser.g:3000:2: ( Result ) + // InternalRos2Parser.g:3001:3: Result + { + before(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); + match(input,Result,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getResultKeyword_2()); + + } + + + } + break; + case 4 : + // InternalRos2Parser.g:3006:2: ( Feedback ) + { + // InternalRos2Parser.g:3006:2: ( Feedback ) + // InternalRos2Parser.g:3007:3: Feedback + { + before(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); + match(input,Feedback,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); + + } + + + } + break; + case 5 : + // InternalRos2Parser.g:3012:2: ( Name ) + { + // InternalRos2Parser.g:3012:2: ( Name ) + // InternalRos2Parser.g:3013:3: Name + { + before(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); + match(input,Name,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getNameKeyword_4()); + + } + + + } + break; + case 6 : + // InternalRos2Parser.g:3018:2: ( Value ) + { + // InternalRos2Parser.g:3018:2: ( Value ) + // InternalRos2Parser.g:3019:3: Value + { + before(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); + match(input,Value,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getValueKeyword_5()); + + } + + + } + break; + case 7 : + // InternalRos2Parser.g:3024:2: ( Service ) + { + // InternalRos2Parser.g:3024:2: ( Service ) + // InternalRos2Parser.g:3025:3: Service + { + before(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); + match(input,Service,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); + + } + + + } + break; + case 8 : + // InternalRos2Parser.g:3030:2: ( Type ) + { + // InternalRos2Parser.g:3030:2: ( Type ) + // InternalRos2Parser.g:3031:3: Type + { + before(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); + match(input,Type,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); + + } + + + } + break; + case 9 : + // InternalRos2Parser.g:3036:2: ( Action ) + { + // InternalRos2Parser.g:3036:2: ( Action ) + // InternalRos2Parser.g:3037:3: Action + { + before(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); + match(input,Action,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getActionKeyword_8()); + + } + + + } + break; + case 10 : + // InternalRos2Parser.g:3042:2: ( Duration ) + { + // InternalRos2Parser.g:3042:2: ( Duration ) + // InternalRos2Parser.g:3043:3: Duration + { + before(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); + match(input,Duration,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); + + } + + + } + break; + case 11 : + // InternalRos2Parser.g:3048:2: ( Time ) + { + // InternalRos2Parser.g:3048:2: ( Time ) + // InternalRos2Parser.g:3049:3: Time + { + before(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); + match(input,Time,FOLLOW_2); + after(grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__KEYWORD__Alternatives" + + + // $ANTLR start "rule__AmentPackage__Group__0" + // InternalRos2Parser.g:3058:1: rule__AmentPackage__Group__0 : rule__AmentPackage__Group__0__Impl rule__AmentPackage__Group__1 ; + public final void rule__AmentPackage__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3062:1: ( rule__AmentPackage__Group__0__Impl rule__AmentPackage__Group__1 ) + // InternalRos2Parser.g:3063:2: rule__AmentPackage__Group__0__Impl rule__AmentPackage__Group__1 + { + pushFollow(FOLLOW_3); + rule__AmentPackage__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__0" + + + // $ANTLR start "rule__AmentPackage__Group__0__Impl" + // InternalRos2Parser.g:3070:1: rule__AmentPackage__Group__0__Impl : ( () ) ; + public final void rule__AmentPackage__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3074:1: ( ( () ) ) + // InternalRos2Parser.g:3075:1: ( () ) + { + // InternalRos2Parser.g:3075:1: ( () ) + // InternalRos2Parser.g:3076:2: () + { + before(grammarAccess.getAmentPackageAccess().getAmentPackageAction_0()); + // InternalRos2Parser.g:3077:2: () + // InternalRos2Parser.g:3077:3: + { + } + + after(grammarAccess.getAmentPackageAccess().getAmentPackageAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__0__Impl" + + + // $ANTLR start "rule__AmentPackage__Group__1" + // InternalRos2Parser.g:3085:1: rule__AmentPackage__Group__1 : rule__AmentPackage__Group__1__Impl rule__AmentPackage__Group__2 ; + public final void rule__AmentPackage__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3089:1: ( rule__AmentPackage__Group__1__Impl rule__AmentPackage__Group__2 ) + // InternalRos2Parser.g:3090:2: rule__AmentPackage__Group__1__Impl rule__AmentPackage__Group__2 + { + pushFollow(FOLLOW_4); + rule__AmentPackage__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__1" + + + // $ANTLR start "rule__AmentPackage__Group__1__Impl" + // InternalRos2Parser.g:3097:1: rule__AmentPackage__Group__1__Impl : ( ( rule__AmentPackage__NameAssignment_1 ) ) ; + public final void rule__AmentPackage__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3101:1: ( ( ( rule__AmentPackage__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:3102:1: ( ( rule__AmentPackage__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:3102:1: ( ( rule__AmentPackage__NameAssignment_1 ) ) + // InternalRos2Parser.g:3103:2: ( rule__AmentPackage__NameAssignment_1 ) + { + before(grammarAccess.getAmentPackageAccess().getNameAssignment_1()); + // InternalRos2Parser.g:3104:2: ( rule__AmentPackage__NameAssignment_1 ) + // InternalRos2Parser.g:3104:3: rule__AmentPackage__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__AmentPackage__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getAmentPackageAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__1__Impl" + + + // $ANTLR start "rule__AmentPackage__Group__2" + // InternalRos2Parser.g:3112:1: rule__AmentPackage__Group__2 : rule__AmentPackage__Group__2__Impl rule__AmentPackage__Group__3 ; + public final void rule__AmentPackage__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3116:1: ( rule__AmentPackage__Group__2__Impl rule__AmentPackage__Group__3 ) + // InternalRos2Parser.g:3117:2: rule__AmentPackage__Group__2__Impl rule__AmentPackage__Group__3 + { + pushFollow(FOLLOW_5); + rule__AmentPackage__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__2" + + + // $ANTLR start "rule__AmentPackage__Group__2__Impl" + // InternalRos2Parser.g:3124:1: rule__AmentPackage__Group__2__Impl : ( Colon ) ; + public final void rule__AmentPackage__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3128:1: ( ( Colon ) ) + // InternalRos2Parser.g:3129:1: ( Colon ) + { + // InternalRos2Parser.g:3129:1: ( Colon ) + // InternalRos2Parser.g:3130:2: Colon + { + before(grammarAccess.getAmentPackageAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getAmentPackageAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__2__Impl" + + + // $ANTLR start "rule__AmentPackage__Group__3" + // InternalRos2Parser.g:3139:1: rule__AmentPackage__Group__3 : rule__AmentPackage__Group__3__Impl rule__AmentPackage__Group__4 ; + public final void rule__AmentPackage__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3143:1: ( rule__AmentPackage__Group__3__Impl rule__AmentPackage__Group__4 ) + // InternalRos2Parser.g:3144:2: rule__AmentPackage__Group__3__Impl rule__AmentPackage__Group__4 + { + pushFollow(FOLLOW_6); + rule__AmentPackage__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__3" + + + // $ANTLR start "rule__AmentPackage__Group__3__Impl" + // InternalRos2Parser.g:3151:1: rule__AmentPackage__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__AmentPackage__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3155:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:3156:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:3156:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:3157:2: RULE_BEGIN + { + before(grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__3__Impl" + + + // $ANTLR start "rule__AmentPackage__Group__4" + // InternalRos2Parser.g:3166:1: rule__AmentPackage__Group__4 : rule__AmentPackage__Group__4__Impl rule__AmentPackage__Group__5 ; + public final void rule__AmentPackage__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3170:1: ( rule__AmentPackage__Group__4__Impl rule__AmentPackage__Group__5 ) + // InternalRos2Parser.g:3171:2: rule__AmentPackage__Group__4__Impl rule__AmentPackage__Group__5 + { + pushFollow(FOLLOW_6); + rule__AmentPackage__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__4" + + + // $ANTLR start "rule__AmentPackage__Group__4__Impl" + // InternalRos2Parser.g:3178:1: rule__AmentPackage__Group__4__Impl : ( ( rule__AmentPackage__Group_4__0 )? ) ; + public final void rule__AmentPackage__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3182:1: ( ( ( rule__AmentPackage__Group_4__0 )? ) ) + // InternalRos2Parser.g:3183:1: ( ( rule__AmentPackage__Group_4__0 )? ) + { + // InternalRos2Parser.g:3183:1: ( ( rule__AmentPackage__Group_4__0 )? ) + // InternalRos2Parser.g:3184:2: ( rule__AmentPackage__Group_4__0 )? + { + before(grammarAccess.getAmentPackageAccess().getGroup_4()); + // InternalRos2Parser.g:3185:2: ( rule__AmentPackage__Group_4__0 )? + int alt17=2; + int LA17_0 = input.LA(1); + + if ( (LA17_0==FromGitRepo) ) { + alt17=1; + } + switch (alt17) { + case 1 : + // InternalRos2Parser.g:3185:3: rule__AmentPackage__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_4__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getAmentPackageAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__4__Impl" + + + // $ANTLR start "rule__AmentPackage__Group__5" + // InternalRos2Parser.g:3193:1: rule__AmentPackage__Group__5 : rule__AmentPackage__Group__5__Impl rule__AmentPackage__Group__6 ; + public final void rule__AmentPackage__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3197:1: ( rule__AmentPackage__Group__5__Impl rule__AmentPackage__Group__6 ) + // InternalRos2Parser.g:3198:2: rule__AmentPackage__Group__5__Impl rule__AmentPackage__Group__6 + { + pushFollow(FOLLOW_6); + rule__AmentPackage__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__5" + + + // $ANTLR start "rule__AmentPackage__Group__5__Impl" + // InternalRos2Parser.g:3205:1: rule__AmentPackage__Group__5__Impl : ( ( rule__AmentPackage__Group_5__0 )? ) ; + public final void rule__AmentPackage__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3209:1: ( ( ( rule__AmentPackage__Group_5__0 )? ) ) + // InternalRos2Parser.g:3210:1: ( ( rule__AmentPackage__Group_5__0 )? ) + { + // InternalRos2Parser.g:3210:1: ( ( rule__AmentPackage__Group_5__0 )? ) + // InternalRos2Parser.g:3211:2: ( rule__AmentPackage__Group_5__0 )? + { + before(grammarAccess.getAmentPackageAccess().getGroup_5()); + // InternalRos2Parser.g:3212:2: ( rule__AmentPackage__Group_5__0 )? + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0==Artifacts) ) { + alt18=1; + } + switch (alt18) { + case 1 : + // InternalRos2Parser.g:3212:3: rule__AmentPackage__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getAmentPackageAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__5__Impl" + + + // $ANTLR start "rule__AmentPackage__Group__6" + // InternalRos2Parser.g:3220:1: rule__AmentPackage__Group__6 : rule__AmentPackage__Group__6__Impl rule__AmentPackage__Group__7 ; + public final void rule__AmentPackage__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3224:1: ( rule__AmentPackage__Group__6__Impl rule__AmentPackage__Group__7 ) + // InternalRos2Parser.g:3225:2: rule__AmentPackage__Group__6__Impl rule__AmentPackage__Group__7 + { + pushFollow(FOLLOW_6); + rule__AmentPackage__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__6" + + + // $ANTLR start "rule__AmentPackage__Group__6__Impl" + // InternalRos2Parser.g:3232:1: rule__AmentPackage__Group__6__Impl : ( ( rule__AmentPackage__Group_6__0 )? ) ; + public final void rule__AmentPackage__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3236:1: ( ( ( rule__AmentPackage__Group_6__0 )? ) ) + // InternalRos2Parser.g:3237:1: ( ( rule__AmentPackage__Group_6__0 )? ) + { + // InternalRos2Parser.g:3237:1: ( ( rule__AmentPackage__Group_6__0 )? ) + // InternalRos2Parser.g:3238:2: ( rule__AmentPackage__Group_6__0 )? + { + before(grammarAccess.getAmentPackageAccess().getGroup_6()); + // InternalRos2Parser.g:3239:2: ( rule__AmentPackage__Group_6__0 )? + int alt19=2; + int LA19_0 = input.LA(1); + + if ( (LA19_0==Dependencies) ) { + alt19=1; + } + switch (alt19) { + case 1 : + // InternalRos2Parser.g:3239:3: rule__AmentPackage__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getAmentPackageAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__6__Impl" + + + // $ANTLR start "rule__AmentPackage__Group__7" + // InternalRos2Parser.g:3247:1: rule__AmentPackage__Group__7 : rule__AmentPackage__Group__7__Impl ; + public final void rule__AmentPackage__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3251:1: ( rule__AmentPackage__Group__7__Impl ) + // InternalRos2Parser.g:3252:2: rule__AmentPackage__Group__7__Impl + { + pushFollow(FOLLOW_2); + rule__AmentPackage__Group__7__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__7" + + + // $ANTLR start "rule__AmentPackage__Group__7__Impl" + // InternalRos2Parser.g:3258:1: rule__AmentPackage__Group__7__Impl : ( RULE_END ) ; + public final void rule__AmentPackage__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3262:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:3263:1: ( RULE_END ) + { + // InternalRos2Parser.g:3263:1: ( RULE_END ) + // InternalRos2Parser.g:3264:2: RULE_END + { + before(grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group__7__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_4__0" + // InternalRos2Parser.g:3274:1: rule__AmentPackage__Group_4__0 : rule__AmentPackage__Group_4__0__Impl rule__AmentPackage__Group_4__1 ; + public final void rule__AmentPackage__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3278:1: ( rule__AmentPackage__Group_4__0__Impl rule__AmentPackage__Group_4__1 ) + // InternalRos2Parser.g:3279:2: rule__AmentPackage__Group_4__0__Impl rule__AmentPackage__Group_4__1 + { + pushFollow(FOLLOW_7); + rule__AmentPackage__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_4__0" + + + // $ANTLR start "rule__AmentPackage__Group_4__0__Impl" + // InternalRos2Parser.g:3286:1: rule__AmentPackage__Group_4__0__Impl : ( FromGitRepo ) ; + public final void rule__AmentPackage__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3290:1: ( ( FromGitRepo ) ) + // InternalRos2Parser.g:3291:1: ( FromGitRepo ) + { + // InternalRos2Parser.g:3291:1: ( FromGitRepo ) + // InternalRos2Parser.g:3292:2: FromGitRepo + { + before(grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); + match(input,FromGitRepo,FOLLOW_2); + after(grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_4__0__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_4__1" + // InternalRos2Parser.g:3301:1: rule__AmentPackage__Group_4__1 : rule__AmentPackage__Group_4__1__Impl ; + public final void rule__AmentPackage__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3305:1: ( rule__AmentPackage__Group_4__1__Impl ) + // InternalRos2Parser.g:3306:2: rule__AmentPackage__Group_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_4__1" + + + // $ANTLR start "rule__AmentPackage__Group_4__1__Impl" + // InternalRos2Parser.g:3312:1: rule__AmentPackage__Group_4__1__Impl : ( ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) ) ; + public final void rule__AmentPackage__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3316:1: ( ( ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) ) ) + // InternalRos2Parser.g:3317:1: ( ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) ) + { + // InternalRos2Parser.g:3317:1: ( ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) ) + // InternalRos2Parser.g:3318:2: ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) + { + before(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_4_1()); + // InternalRos2Parser.g:3319:2: ( rule__AmentPackage__FromGitRepoAssignment_4_1 ) + // InternalRos2Parser.g:3319:3: rule__AmentPackage__FromGitRepoAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__AmentPackage__FromGitRepoAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getAmentPackageAccess().getFromGitRepoAssignment_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_4__1__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_5__0" + // InternalRos2Parser.g:3328:1: rule__AmentPackage__Group_5__0 : rule__AmentPackage__Group_5__0__Impl rule__AmentPackage__Group_5__1 ; + public final void rule__AmentPackage__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3332:1: ( rule__AmentPackage__Group_5__0__Impl rule__AmentPackage__Group_5__1 ) + // InternalRos2Parser.g:3333:2: rule__AmentPackage__Group_5__0__Impl rule__AmentPackage__Group_5__1 + { + pushFollow(FOLLOW_5); + rule__AmentPackage__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_5__0" + + + // $ANTLR start "rule__AmentPackage__Group_5__0__Impl" + // InternalRos2Parser.g:3340:1: rule__AmentPackage__Group_5__0__Impl : ( Artifacts ) ; + public final void rule__AmentPackage__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3344:1: ( ( Artifacts ) ) + // InternalRos2Parser.g:3345:1: ( Artifacts ) + { + // InternalRos2Parser.g:3345:1: ( Artifacts ) + // InternalRos2Parser.g:3346:2: Artifacts + { + before(grammarAccess.getAmentPackageAccess().getArtifactsKeyword_5_0()); + match(input,Artifacts,FOLLOW_2); + after(grammarAccess.getAmentPackageAccess().getArtifactsKeyword_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_5__0__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_5__1" + // InternalRos2Parser.g:3355:1: rule__AmentPackage__Group_5__1 : rule__AmentPackage__Group_5__1__Impl rule__AmentPackage__Group_5__2 ; + public final void rule__AmentPackage__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3359:1: ( rule__AmentPackage__Group_5__1__Impl rule__AmentPackage__Group_5__2 ) + // InternalRos2Parser.g:3360:2: rule__AmentPackage__Group_5__1__Impl rule__AmentPackage__Group_5__2 + { + pushFollow(FOLLOW_8); + rule__AmentPackage__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_5__1" + + + // $ANTLR start "rule__AmentPackage__Group_5__1__Impl" + // InternalRos2Parser.g:3367:1: rule__AmentPackage__Group_5__1__Impl : ( RULE_BEGIN ) ; + public final void rule__AmentPackage__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3371:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:3372:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:3372:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:3373:2: RULE_BEGIN + { + before(grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_5_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_5__1__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_5__2" + // InternalRos2Parser.g:3382:1: rule__AmentPackage__Group_5__2 : rule__AmentPackage__Group_5__2__Impl rule__AmentPackage__Group_5__3 ; + public final void rule__AmentPackage__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3386:1: ( rule__AmentPackage__Group_5__2__Impl rule__AmentPackage__Group_5__3 ) + // InternalRos2Parser.g:3387:2: rule__AmentPackage__Group_5__2__Impl rule__AmentPackage__Group_5__3 + { + pushFollow(FOLLOW_8); + rule__AmentPackage__Group_5__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_5__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_5__2" + + + // $ANTLR start "rule__AmentPackage__Group_5__2__Impl" + // InternalRos2Parser.g:3394:1: rule__AmentPackage__Group_5__2__Impl : ( ( rule__AmentPackage__ArtifactAssignment_5_2 )* ) ; + public final void rule__AmentPackage__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3398:1: ( ( ( rule__AmentPackage__ArtifactAssignment_5_2 )* ) ) + // InternalRos2Parser.g:3399:1: ( ( rule__AmentPackage__ArtifactAssignment_5_2 )* ) + { + // InternalRos2Parser.g:3399:1: ( ( rule__AmentPackage__ArtifactAssignment_5_2 )* ) + // InternalRos2Parser.g:3400:2: ( rule__AmentPackage__ArtifactAssignment_5_2 )* + { + before(grammarAccess.getAmentPackageAccess().getArtifactAssignment_5_2()); + // InternalRos2Parser.g:3401:2: ( rule__AmentPackage__ArtifactAssignment_5_2 )* + loop20: + do { + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0==Node||(LA20_0>=RULE_ID && LA20_0<=RULE_ROS_CONVENTION_A)) ) { + alt20=1; + } + + + switch (alt20) { + case 1 : + // InternalRos2Parser.g:3401:3: rule__AmentPackage__ArtifactAssignment_5_2 + { + pushFollow(FOLLOW_9); + rule__AmentPackage__ArtifactAssignment_5_2(); + + state._fsp--; + + + } + break; + + default : + break loop20; + } + } while (true); + + after(grammarAccess.getAmentPackageAccess().getArtifactAssignment_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_5__2__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_5__3" + // InternalRos2Parser.g:3409:1: rule__AmentPackage__Group_5__3 : rule__AmentPackage__Group_5__3__Impl ; + public final void rule__AmentPackage__Group_5__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3413:1: ( rule__AmentPackage__Group_5__3__Impl ) + // InternalRos2Parser.g:3414:2: rule__AmentPackage__Group_5__3__Impl + { + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_5__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_5__3" + + + // $ANTLR start "rule__AmentPackage__Group_5__3__Impl" + // InternalRos2Parser.g:3420:1: rule__AmentPackage__Group_5__3__Impl : ( RULE_END ) ; + public final void rule__AmentPackage__Group_5__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3424:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:3425:1: ( RULE_END ) + { + // InternalRos2Parser.g:3425:1: ( RULE_END ) + // InternalRos2Parser.g:3426:2: RULE_END + { + before(grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_5_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_5_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_5__3__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_6__0" + // InternalRos2Parser.g:3436:1: rule__AmentPackage__Group_6__0 : rule__AmentPackage__Group_6__0__Impl rule__AmentPackage__Group_6__1 ; + public final void rule__AmentPackage__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3440:1: ( rule__AmentPackage__Group_6__0__Impl rule__AmentPackage__Group_6__1 ) + // InternalRos2Parser.g:3441:2: rule__AmentPackage__Group_6__0__Impl rule__AmentPackage__Group_6__1 + { + pushFollow(FOLLOW_10); + rule__AmentPackage__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6__0" + + + // $ANTLR start "rule__AmentPackage__Group_6__0__Impl" + // InternalRos2Parser.g:3448:1: rule__AmentPackage__Group_6__0__Impl : ( Dependencies ) ; + public final void rule__AmentPackage__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3452:1: ( ( Dependencies ) ) + // InternalRos2Parser.g:3453:1: ( Dependencies ) + { + // InternalRos2Parser.g:3453:1: ( Dependencies ) + // InternalRos2Parser.g:3454:2: Dependencies + { + before(grammarAccess.getAmentPackageAccess().getDependenciesKeyword_6_0()); + match(input,Dependencies,FOLLOW_2); + after(grammarAccess.getAmentPackageAccess().getDependenciesKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6__0__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_6__1" + // InternalRos2Parser.g:3463:1: rule__AmentPackage__Group_6__1 : rule__AmentPackage__Group_6__1__Impl rule__AmentPackage__Group_6__2 ; + public final void rule__AmentPackage__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3467:1: ( rule__AmentPackage__Group_6__1__Impl rule__AmentPackage__Group_6__2 ) + // InternalRos2Parser.g:3468:2: rule__AmentPackage__Group_6__1__Impl rule__AmentPackage__Group_6__2 + { + pushFollow(FOLLOW_11); + rule__AmentPackage__Group_6__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_6__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6__1" + + + // $ANTLR start "rule__AmentPackage__Group_6__1__Impl" + // InternalRos2Parser.g:3475:1: rule__AmentPackage__Group_6__1__Impl : ( LeftSquareBracket ) ; + public final void rule__AmentPackage__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3479:1: ( ( LeftSquareBracket ) ) + // InternalRos2Parser.g:3480:1: ( LeftSquareBracket ) + { + // InternalRos2Parser.g:3480:1: ( LeftSquareBracket ) + // InternalRos2Parser.g:3481:2: LeftSquareBracket + { + before(grammarAccess.getAmentPackageAccess().getLeftSquareBracketKeyword_6_1()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getAmentPackageAccess().getLeftSquareBracketKeyword_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6__1__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_6__2" + // InternalRos2Parser.g:3490:1: rule__AmentPackage__Group_6__2 : rule__AmentPackage__Group_6__2__Impl rule__AmentPackage__Group_6__3 ; + public final void rule__AmentPackage__Group_6__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3494:1: ( rule__AmentPackage__Group_6__2__Impl rule__AmentPackage__Group_6__3 ) + // InternalRos2Parser.g:3495:2: rule__AmentPackage__Group_6__2__Impl rule__AmentPackage__Group_6__3 + { + pushFollow(FOLLOW_12); + rule__AmentPackage__Group_6__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_6__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6__2" + + + // $ANTLR start "rule__AmentPackage__Group_6__2__Impl" + // InternalRos2Parser.g:3502:1: rule__AmentPackage__Group_6__2__Impl : ( ( rule__AmentPackage__DependencyAssignment_6_2 ) ) ; + public final void rule__AmentPackage__Group_6__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3506:1: ( ( ( rule__AmentPackage__DependencyAssignment_6_2 ) ) ) + // InternalRos2Parser.g:3507:1: ( ( rule__AmentPackage__DependencyAssignment_6_2 ) ) + { + // InternalRos2Parser.g:3507:1: ( ( rule__AmentPackage__DependencyAssignment_6_2 ) ) + // InternalRos2Parser.g:3508:2: ( rule__AmentPackage__DependencyAssignment_6_2 ) + { + before(grammarAccess.getAmentPackageAccess().getDependencyAssignment_6_2()); + // InternalRos2Parser.g:3509:2: ( rule__AmentPackage__DependencyAssignment_6_2 ) + // InternalRos2Parser.g:3509:3: rule__AmentPackage__DependencyAssignment_6_2 + { + pushFollow(FOLLOW_2); + rule__AmentPackage__DependencyAssignment_6_2(); + + state._fsp--; + + + } + + after(grammarAccess.getAmentPackageAccess().getDependencyAssignment_6_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6__2__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_6__3" + // InternalRos2Parser.g:3517:1: rule__AmentPackage__Group_6__3 : rule__AmentPackage__Group_6__3__Impl rule__AmentPackage__Group_6__4 ; + public final void rule__AmentPackage__Group_6__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3521:1: ( rule__AmentPackage__Group_6__3__Impl rule__AmentPackage__Group_6__4 ) + // InternalRos2Parser.g:3522:2: rule__AmentPackage__Group_6__3__Impl rule__AmentPackage__Group_6__4 + { + pushFollow(FOLLOW_12); + rule__AmentPackage__Group_6__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_6__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6__3" + + + // $ANTLR start "rule__AmentPackage__Group_6__3__Impl" + // InternalRos2Parser.g:3529:1: rule__AmentPackage__Group_6__3__Impl : ( ( rule__AmentPackage__Group_6_3__0 )* ) ; + public final void rule__AmentPackage__Group_6__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3533:1: ( ( ( rule__AmentPackage__Group_6_3__0 )* ) ) + // InternalRos2Parser.g:3534:1: ( ( rule__AmentPackage__Group_6_3__0 )* ) + { + // InternalRos2Parser.g:3534:1: ( ( rule__AmentPackage__Group_6_3__0 )* ) + // InternalRos2Parser.g:3535:2: ( rule__AmentPackage__Group_6_3__0 )* + { + before(grammarAccess.getAmentPackageAccess().getGroup_6_3()); + // InternalRos2Parser.g:3536:2: ( rule__AmentPackage__Group_6_3__0 )* + loop21: + do { + int alt21=2; + int LA21_0 = input.LA(1); + + if ( (LA21_0==Comma) ) { + alt21=1; + } + + + switch (alt21) { + case 1 : + // InternalRos2Parser.g:3536:3: rule__AmentPackage__Group_6_3__0 + { + pushFollow(FOLLOW_13); + rule__AmentPackage__Group_6_3__0(); + + state._fsp--; + + + } + break; + + default : + break loop21; + } + } while (true); + + after(grammarAccess.getAmentPackageAccess().getGroup_6_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6__3__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_6__4" + // InternalRos2Parser.g:3544:1: rule__AmentPackage__Group_6__4 : rule__AmentPackage__Group_6__4__Impl ; + public final void rule__AmentPackage__Group_6__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3548:1: ( rule__AmentPackage__Group_6__4__Impl ) + // InternalRos2Parser.g:3549:2: rule__AmentPackage__Group_6__4__Impl + { + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_6__4__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6__4" + + + // $ANTLR start "rule__AmentPackage__Group_6__4__Impl" + // InternalRos2Parser.g:3555:1: rule__AmentPackage__Group_6__4__Impl : ( RightSquareBracket ) ; + public final void rule__AmentPackage__Group_6__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3559:1: ( ( RightSquareBracket ) ) + // InternalRos2Parser.g:3560:1: ( RightSquareBracket ) + { + // InternalRos2Parser.g:3560:1: ( RightSquareBracket ) + // InternalRos2Parser.g:3561:2: RightSquareBracket + { + before(grammarAccess.getAmentPackageAccess().getRightSquareBracketKeyword_6_4()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getAmentPackageAccess().getRightSquareBracketKeyword_6_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6__4__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_6_3__0" + // InternalRos2Parser.g:3571:1: rule__AmentPackage__Group_6_3__0 : rule__AmentPackage__Group_6_3__0__Impl rule__AmentPackage__Group_6_3__1 ; + public final void rule__AmentPackage__Group_6_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3575:1: ( rule__AmentPackage__Group_6_3__0__Impl rule__AmentPackage__Group_6_3__1 ) + // InternalRos2Parser.g:3576:2: rule__AmentPackage__Group_6_3__0__Impl rule__AmentPackage__Group_6_3__1 + { + pushFollow(FOLLOW_11); + rule__AmentPackage__Group_6_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_6_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6_3__0" + + + // $ANTLR start "rule__AmentPackage__Group_6_3__0__Impl" + // InternalRos2Parser.g:3583:1: rule__AmentPackage__Group_6_3__0__Impl : ( Comma ) ; + public final void rule__AmentPackage__Group_6_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3587:1: ( ( Comma ) ) + // InternalRos2Parser.g:3588:1: ( Comma ) + { + // InternalRos2Parser.g:3588:1: ( Comma ) + // InternalRos2Parser.g:3589:2: Comma + { + before(grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6_3__0__Impl" + + + // $ANTLR start "rule__AmentPackage__Group_6_3__1" + // InternalRos2Parser.g:3598:1: rule__AmentPackage__Group_6_3__1 : rule__AmentPackage__Group_6_3__1__Impl ; + public final void rule__AmentPackage__Group_6_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3602:1: ( rule__AmentPackage__Group_6_3__1__Impl ) + // InternalRos2Parser.g:3603:2: rule__AmentPackage__Group_6_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__AmentPackage__Group_6_3__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6_3__1" + + + // $ANTLR start "rule__AmentPackage__Group_6_3__1__Impl" + // InternalRos2Parser.g:3609:1: rule__AmentPackage__Group_6_3__1__Impl : ( ( rule__AmentPackage__DependencyAssignment_6_3_1 ) ) ; + public final void rule__AmentPackage__Group_6_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3613:1: ( ( ( rule__AmentPackage__DependencyAssignment_6_3_1 ) ) ) + // InternalRos2Parser.g:3614:1: ( ( rule__AmentPackage__DependencyAssignment_6_3_1 ) ) + { + // InternalRos2Parser.g:3614:1: ( ( rule__AmentPackage__DependencyAssignment_6_3_1 ) ) + // InternalRos2Parser.g:3615:2: ( rule__AmentPackage__DependencyAssignment_6_3_1 ) + { + before(grammarAccess.getAmentPackageAccess().getDependencyAssignment_6_3_1()); + // InternalRos2Parser.g:3616:2: ( rule__AmentPackage__DependencyAssignment_6_3_1 ) + // InternalRos2Parser.g:3616:3: rule__AmentPackage__DependencyAssignment_6_3_1 + { + pushFollow(FOLLOW_2); + rule__AmentPackage__DependencyAssignment_6_3_1(); + + state._fsp--; + + + } + + after(grammarAccess.getAmentPackageAccess().getDependencyAssignment_6_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__Group_6_3__1__Impl" + + + // $ANTLR start "rule__QualityOfService__Group__0" + // InternalRos2Parser.g:3625:1: rule__QualityOfService__Group__0 : rule__QualityOfService__Group__0__Impl rule__QualityOfService__Group__1 ; + public final void rule__QualityOfService__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3629:1: ( rule__QualityOfService__Group__0__Impl rule__QualityOfService__Group__1 ) + // InternalRos2Parser.g:3630:2: rule__QualityOfService__Group__0__Impl rule__QualityOfService__Group__1 + { + pushFollow(FOLLOW_14); + rule__QualityOfService__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__QualityOfService__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group__0" + + + // $ANTLR start "rule__QualityOfService__Group__0__Impl" + // InternalRos2Parser.g:3637:1: rule__QualityOfService__Group__0__Impl : ( () ) ; + public final void rule__QualityOfService__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3641:1: ( ( () ) ) + // InternalRos2Parser.g:3642:1: ( () ) + { + // InternalRos2Parser.g:3642:1: ( () ) + // InternalRos2Parser.g:3643:2: () + { + before(grammarAccess.getQualityOfServiceAccess().getQualityOfServiceAction_0()); + // InternalRos2Parser.g:3644:2: () + // InternalRos2Parser.g:3644:3: + { + } + + after(grammarAccess.getQualityOfServiceAccess().getQualityOfServiceAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group__0__Impl" + + + // $ANTLR start "rule__QualityOfService__Group__1" + // InternalRos2Parser.g:3652:1: rule__QualityOfService__Group__1 : rule__QualityOfService__Group__1__Impl ; + public final void rule__QualityOfService__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3656:1: ( rule__QualityOfService__Group__1__Impl ) + // InternalRos2Parser.g:3657:2: rule__QualityOfService__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group__1" + + + // $ANTLR start "rule__QualityOfService__Group__1__Impl" + // InternalRos2Parser.g:3663:1: rule__QualityOfService__Group__1__Impl : ( ( rule__QualityOfService__UnorderedGroup_1 ) ) ; + public final void rule__QualityOfService__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3667:1: ( ( ( rule__QualityOfService__UnorderedGroup_1 ) ) ) + // InternalRos2Parser.g:3668:1: ( ( rule__QualityOfService__UnorderedGroup_1 ) ) + { + // InternalRos2Parser.g:3668:1: ( ( rule__QualityOfService__UnorderedGroup_1 ) ) + // InternalRos2Parser.g:3669:2: ( rule__QualityOfService__UnorderedGroup_1 ) + { + before(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + // InternalRos2Parser.g:3670:2: ( rule__QualityOfService__UnorderedGroup_1 ) + // InternalRos2Parser.g:3670:3: rule__QualityOfService__UnorderedGroup_1 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__UnorderedGroup_1(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group__1__Impl" + + + // $ANTLR start "rule__QualityOfService__Group_1_0__0" + // InternalRos2Parser.g:3679:1: rule__QualityOfService__Group_1_0__0 : rule__QualityOfService__Group_1_0__0__Impl rule__QualityOfService__Group_1_0__1 ; + public final void rule__QualityOfService__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3683:1: ( rule__QualityOfService__Group_1_0__0__Impl rule__QualityOfService__Group_1_0__1 ) + // InternalRos2Parser.g:3684:2: rule__QualityOfService__Group_1_0__0__Impl rule__QualityOfService__Group_1_0__1 + { + pushFollow(FOLLOW_15); + rule__QualityOfService__Group_1_0__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_0__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_0__0" + + + // $ANTLR start "rule__QualityOfService__Group_1_0__0__Impl" + // InternalRos2Parser.g:3691:1: rule__QualityOfService__Group_1_0__0__Impl : ( Profile ) ; + public final void rule__QualityOfService__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3695:1: ( ( Profile ) ) + // InternalRos2Parser.g:3696:1: ( Profile ) + { + // InternalRos2Parser.g:3696:1: ( Profile ) + // InternalRos2Parser.g:3697:2: Profile + { + before(grammarAccess.getQualityOfServiceAccess().getProfileKeyword_1_0_0()); + match(input,Profile,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getProfileKeyword_1_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_0__0__Impl" + + + // $ANTLR start "rule__QualityOfService__Group_1_0__1" + // InternalRos2Parser.g:3706:1: rule__QualityOfService__Group_1_0__1 : rule__QualityOfService__Group_1_0__1__Impl ; + public final void rule__QualityOfService__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3710:1: ( rule__QualityOfService__Group_1_0__1__Impl ) + // InternalRos2Parser.g:3711:2: rule__QualityOfService__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_0__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_0__1" + + + // $ANTLR start "rule__QualityOfService__Group_1_0__1__Impl" + // InternalRos2Parser.g:3717:1: rule__QualityOfService__Group_1_0__1__Impl : ( ( rule__QualityOfService__QoSProfileAssignment_1_0_1 ) ) ; + public final void rule__QualityOfService__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3721:1: ( ( ( rule__QualityOfService__QoSProfileAssignment_1_0_1 ) ) ) + // InternalRos2Parser.g:3722:1: ( ( rule__QualityOfService__QoSProfileAssignment_1_0_1 ) ) + { + // InternalRos2Parser.g:3722:1: ( ( rule__QualityOfService__QoSProfileAssignment_1_0_1 ) ) + // InternalRos2Parser.g:3723:2: ( rule__QualityOfService__QoSProfileAssignment_1_0_1 ) + { + before(grammarAccess.getQualityOfServiceAccess().getQoSProfileAssignment_1_0_1()); + // InternalRos2Parser.g:3724:2: ( rule__QualityOfService__QoSProfileAssignment_1_0_1 ) + // InternalRos2Parser.g:3724:3: rule__QualityOfService__QoSProfileAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__QoSProfileAssignment_1_0_1(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getQoSProfileAssignment_1_0_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_0__1__Impl" + + + // $ANTLR start "rule__QualityOfService__Group_1_1__0" + // InternalRos2Parser.g:3733:1: rule__QualityOfService__Group_1_1__0 : rule__QualityOfService__Group_1_1__0__Impl rule__QualityOfService__Group_1_1__1 ; + public final void rule__QualityOfService__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3737:1: ( rule__QualityOfService__Group_1_1__0__Impl rule__QualityOfService__Group_1_1__1 ) + // InternalRos2Parser.g:3738:2: rule__QualityOfService__Group_1_1__0__Impl rule__QualityOfService__Group_1_1__1 + { + pushFollow(FOLLOW_16); + rule__QualityOfService__Group_1_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_1__0" + + + // $ANTLR start "rule__QualityOfService__Group_1_1__0__Impl" + // InternalRos2Parser.g:3745:1: rule__QualityOfService__Group_1_1__0__Impl : ( History ) ; + public final void rule__QualityOfService__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3749:1: ( ( History ) ) + // InternalRos2Parser.g:3750:1: ( History ) + { + // InternalRos2Parser.g:3750:1: ( History ) + // InternalRos2Parser.g:3751:2: History + { + before(grammarAccess.getQualityOfServiceAccess().getHistoryKeyword_1_1_0()); + match(input,History,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getHistoryKeyword_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_1__0__Impl" + + + // $ANTLR start "rule__QualityOfService__Group_1_1__1" + // InternalRos2Parser.g:3760:1: rule__QualityOfService__Group_1_1__1 : rule__QualityOfService__Group_1_1__1__Impl ; + public final void rule__QualityOfService__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3764:1: ( rule__QualityOfService__Group_1_1__1__Impl ) + // InternalRos2Parser.g:3765:2: rule__QualityOfService__Group_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_1__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_1__1" + + + // $ANTLR start "rule__QualityOfService__Group_1_1__1__Impl" + // InternalRos2Parser.g:3771:1: rule__QualityOfService__Group_1_1__1__Impl : ( ( rule__QualityOfService__HistoryAssignment_1_1_1 ) ) ; + public final void rule__QualityOfService__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3775:1: ( ( ( rule__QualityOfService__HistoryAssignment_1_1_1 ) ) ) + // InternalRos2Parser.g:3776:1: ( ( rule__QualityOfService__HistoryAssignment_1_1_1 ) ) + { + // InternalRos2Parser.g:3776:1: ( ( rule__QualityOfService__HistoryAssignment_1_1_1 ) ) + // InternalRos2Parser.g:3777:2: ( rule__QualityOfService__HistoryAssignment_1_1_1 ) + { + before(grammarAccess.getQualityOfServiceAccess().getHistoryAssignment_1_1_1()); + // InternalRos2Parser.g:3778:2: ( rule__QualityOfService__HistoryAssignment_1_1_1 ) + // InternalRos2Parser.g:3778:3: rule__QualityOfService__HistoryAssignment_1_1_1 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__HistoryAssignment_1_1_1(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getHistoryAssignment_1_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_1__1__Impl" + + + // $ANTLR start "rule__QualityOfService__Group_1_2__0" + // InternalRos2Parser.g:3787:1: rule__QualityOfService__Group_1_2__0 : rule__QualityOfService__Group_1_2__0__Impl rule__QualityOfService__Group_1_2__1 ; + public final void rule__QualityOfService__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3791:1: ( rule__QualityOfService__Group_1_2__0__Impl rule__QualityOfService__Group_1_2__1 ) + // InternalRos2Parser.g:3792:2: rule__QualityOfService__Group_1_2__0__Impl rule__QualityOfService__Group_1_2__1 + { + pushFollow(FOLLOW_17); + rule__QualityOfService__Group_1_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_2__0" + + + // $ANTLR start "rule__QualityOfService__Group_1_2__0__Impl" + // InternalRos2Parser.g:3799:1: rule__QualityOfService__Group_1_2__0__Impl : ( Depth ) ; + public final void rule__QualityOfService__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3803:1: ( ( Depth ) ) + // InternalRos2Parser.g:3804:1: ( Depth ) + { + // InternalRos2Parser.g:3804:1: ( Depth ) + // InternalRos2Parser.g:3805:2: Depth + { + before(grammarAccess.getQualityOfServiceAccess().getDepthKeyword_1_2_0()); + match(input,Depth,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getDepthKeyword_1_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_2__0__Impl" + + + // $ANTLR start "rule__QualityOfService__Group_1_2__1" + // InternalRos2Parser.g:3814:1: rule__QualityOfService__Group_1_2__1 : rule__QualityOfService__Group_1_2__1__Impl ; + public final void rule__QualityOfService__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3818:1: ( rule__QualityOfService__Group_1_2__1__Impl ) + // InternalRos2Parser.g:3819:2: rule__QualityOfService__Group_1_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_2__1" + + + // $ANTLR start "rule__QualityOfService__Group_1_2__1__Impl" + // InternalRos2Parser.g:3825:1: rule__QualityOfService__Group_1_2__1__Impl : ( ( rule__QualityOfService__DepthAssignment_1_2_1 ) ) ; + public final void rule__QualityOfService__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3829:1: ( ( ( rule__QualityOfService__DepthAssignment_1_2_1 ) ) ) + // InternalRos2Parser.g:3830:1: ( ( rule__QualityOfService__DepthAssignment_1_2_1 ) ) + { + // InternalRos2Parser.g:3830:1: ( ( rule__QualityOfService__DepthAssignment_1_2_1 ) ) + // InternalRos2Parser.g:3831:2: ( rule__QualityOfService__DepthAssignment_1_2_1 ) + { + before(grammarAccess.getQualityOfServiceAccess().getDepthAssignment_1_2_1()); + // InternalRos2Parser.g:3832:2: ( rule__QualityOfService__DepthAssignment_1_2_1 ) + // InternalRos2Parser.g:3832:3: rule__QualityOfService__DepthAssignment_1_2_1 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__DepthAssignment_1_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getDepthAssignment_1_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_2__1__Impl" + + + // $ANTLR start "rule__QualityOfService__Group_1_3__0" + // InternalRos2Parser.g:3841:1: rule__QualityOfService__Group_1_3__0 : rule__QualityOfService__Group_1_3__0__Impl rule__QualityOfService__Group_1_3__1 ; + public final void rule__QualityOfService__Group_1_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3845:1: ( rule__QualityOfService__Group_1_3__0__Impl rule__QualityOfService__Group_1_3__1 ) + // InternalRos2Parser.g:3846:2: rule__QualityOfService__Group_1_3__0__Impl rule__QualityOfService__Group_1_3__1 + { + pushFollow(FOLLOW_18); + rule__QualityOfService__Group_1_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_3__0" + + + // $ANTLR start "rule__QualityOfService__Group_1_3__0__Impl" + // InternalRos2Parser.g:3853:1: rule__QualityOfService__Group_1_3__0__Impl : ( Reliability ) ; + public final void rule__QualityOfService__Group_1_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3857:1: ( ( Reliability ) ) + // InternalRos2Parser.g:3858:1: ( Reliability ) + { + // InternalRos2Parser.g:3858:1: ( Reliability ) + // InternalRos2Parser.g:3859:2: Reliability + { + before(grammarAccess.getQualityOfServiceAccess().getReliabilityKeyword_1_3_0()); + match(input,Reliability,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getReliabilityKeyword_1_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_3__0__Impl" + + + // $ANTLR start "rule__QualityOfService__Group_1_3__1" + // InternalRos2Parser.g:3868:1: rule__QualityOfService__Group_1_3__1 : rule__QualityOfService__Group_1_3__1__Impl ; + public final void rule__QualityOfService__Group_1_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3872:1: ( rule__QualityOfService__Group_1_3__1__Impl ) + // InternalRos2Parser.g:3873:2: rule__QualityOfService__Group_1_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_3__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_3__1" + + + // $ANTLR start "rule__QualityOfService__Group_1_3__1__Impl" + // InternalRos2Parser.g:3879:1: rule__QualityOfService__Group_1_3__1__Impl : ( ( rule__QualityOfService__ReliabilityAssignment_1_3_1 ) ) ; + public final void rule__QualityOfService__Group_1_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3883:1: ( ( ( rule__QualityOfService__ReliabilityAssignment_1_3_1 ) ) ) + // InternalRos2Parser.g:3884:1: ( ( rule__QualityOfService__ReliabilityAssignment_1_3_1 ) ) + { + // InternalRos2Parser.g:3884:1: ( ( rule__QualityOfService__ReliabilityAssignment_1_3_1 ) ) + // InternalRos2Parser.g:3885:2: ( rule__QualityOfService__ReliabilityAssignment_1_3_1 ) + { + before(grammarAccess.getQualityOfServiceAccess().getReliabilityAssignment_1_3_1()); + // InternalRos2Parser.g:3886:2: ( rule__QualityOfService__ReliabilityAssignment_1_3_1 ) + // InternalRos2Parser.g:3886:3: rule__QualityOfService__ReliabilityAssignment_1_3_1 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__ReliabilityAssignment_1_3_1(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getReliabilityAssignment_1_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_3__1__Impl" + + + // $ANTLR start "rule__QualityOfService__Group_1_4__0" + // InternalRos2Parser.g:3895:1: rule__QualityOfService__Group_1_4__0 : rule__QualityOfService__Group_1_4__0__Impl rule__QualityOfService__Group_1_4__1 ; + public final void rule__QualityOfService__Group_1_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3899:1: ( rule__QualityOfService__Group_1_4__0__Impl rule__QualityOfService__Group_1_4__1 ) + // InternalRos2Parser.g:3900:2: rule__QualityOfService__Group_1_4__0__Impl rule__QualityOfService__Group_1_4__1 + { + pushFollow(FOLLOW_19); + rule__QualityOfService__Group_1_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_4__0" + + + // $ANTLR start "rule__QualityOfService__Group_1_4__0__Impl" + // InternalRos2Parser.g:3907:1: rule__QualityOfService__Group_1_4__0__Impl : ( Durability ) ; + public final void rule__QualityOfService__Group_1_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3911:1: ( ( Durability ) ) + // InternalRos2Parser.g:3912:1: ( Durability ) + { + // InternalRos2Parser.g:3912:1: ( Durability ) + // InternalRos2Parser.g:3913:2: Durability + { + before(grammarAccess.getQualityOfServiceAccess().getDurabilityKeyword_1_4_0()); + match(input,Durability,FOLLOW_2); + after(grammarAccess.getQualityOfServiceAccess().getDurabilityKeyword_1_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_4__0__Impl" + + + // $ANTLR start "rule__QualityOfService__Group_1_4__1" + // InternalRos2Parser.g:3922:1: rule__QualityOfService__Group_1_4__1 : rule__QualityOfService__Group_1_4__1__Impl ; + public final void rule__QualityOfService__Group_1_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3926:1: ( rule__QualityOfService__Group_1_4__1__Impl ) + // InternalRos2Parser.g:3927:2: rule__QualityOfService__Group_1_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_4__1" + + + // $ANTLR start "rule__QualityOfService__Group_1_4__1__Impl" + // InternalRos2Parser.g:3933:1: rule__QualityOfService__Group_1_4__1__Impl : ( ( rule__QualityOfService__DurabilityAssignment_1_4_1 ) ) ; + public final void rule__QualityOfService__Group_1_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3937:1: ( ( ( rule__QualityOfService__DurabilityAssignment_1_4_1 ) ) ) + // InternalRos2Parser.g:3938:1: ( ( rule__QualityOfService__DurabilityAssignment_1_4_1 ) ) + { + // InternalRos2Parser.g:3938:1: ( ( rule__QualityOfService__DurabilityAssignment_1_4_1 ) ) + // InternalRos2Parser.g:3939:2: ( rule__QualityOfService__DurabilityAssignment_1_4_1 ) + { + before(grammarAccess.getQualityOfServiceAccess().getDurabilityAssignment_1_4_1()); + // InternalRos2Parser.g:3940:2: ( rule__QualityOfService__DurabilityAssignment_1_4_1 ) + // InternalRos2Parser.g:3940:3: rule__QualityOfService__DurabilityAssignment_1_4_1 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__DurabilityAssignment_1_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getDurabilityAssignment_1_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__Group_1_4__1__Impl" + + + // $ANTLR start "rule__Publisher__Group__0" + // InternalRos2Parser.g:3949: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 { + // InternalRos2Parser.g:3953:1: ( rule__Publisher__Group__0__Impl rule__Publisher__Group__1 ) + // InternalRos2Parser.g:3954: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" + // InternalRos2Parser.g:3961:1: rule__Publisher__Group__0__Impl : ( () ) ; + public final void rule__Publisher__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3965:1: ( ( () ) ) + // InternalRos2Parser.g:3966:1: ( () ) + { + // InternalRos2Parser.g:3966:1: ( () ) + // InternalRos2Parser.g:3967:2: () + { + before(grammarAccess.getPublisherAccess().getPublisherAction_0()); + // InternalRos2Parser.g:3968:2: () + // InternalRos2Parser.g:3968:3: + { + } + + after(grammarAccess.getPublisherAccess().getPublisherAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__0__Impl" + + + // $ANTLR start "rule__Publisher__Group__1" + // InternalRos2Parser.g:3976: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 { + // InternalRos2Parser.g:3980:1: ( rule__Publisher__Group__1__Impl rule__Publisher__Group__2 ) + // InternalRos2Parser.g:3981: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" + // InternalRos2Parser.g:3988:1: rule__Publisher__Group__1__Impl : ( ( rule__Publisher__NameAssignment_1 ) ) ; + public final void rule__Publisher__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:3992:1: ( ( ( rule__Publisher__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:3993:1: ( ( rule__Publisher__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:3993:1: ( ( rule__Publisher__NameAssignment_1 ) ) + // InternalRos2Parser.g:3994:2: ( rule__Publisher__NameAssignment_1 ) + { + before(grammarAccess.getPublisherAccess().getNameAssignment_1()); + // InternalRos2Parser.g:3995:2: ( rule__Publisher__NameAssignment_1 ) + // InternalRos2Parser.g:3995: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" + // InternalRos2Parser.g:4003: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 { + // InternalRos2Parser.g:4007:1: ( rule__Publisher__Group__2__Impl rule__Publisher__Group__3 ) + // InternalRos2Parser.g:4008: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" + // InternalRos2Parser.g:4015:1: rule__Publisher__Group__2__Impl : ( Colon ) ; + public final void rule__Publisher__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4019:1: ( ( Colon ) ) + // InternalRos2Parser.g:4020:1: ( Colon ) + { + // InternalRos2Parser.g:4020:1: ( Colon ) + // InternalRos2Parser.g:4021: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" + // InternalRos2Parser.g:4030: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 { + // InternalRos2Parser.g:4034:1: ( rule__Publisher__Group__3__Impl rule__Publisher__Group__4 ) + // InternalRos2Parser.g:4035:2: rule__Publisher__Group__3__Impl rule__Publisher__Group__4 + { + pushFollow(FOLLOW_20); + 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" + // InternalRos2Parser.g:4042:1: rule__Publisher__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Publisher__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4046:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:4047:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:4047:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:4048: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" + // InternalRos2Parser.g:4057: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 { + // InternalRos2Parser.g:4061:1: ( rule__Publisher__Group__4__Impl rule__Publisher__Group__5 ) + // InternalRos2Parser.g:4062: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" + // InternalRos2Parser.g:4069:1: rule__Publisher__Group__4__Impl : ( Type_1 ) ; + public final void rule__Publisher__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4073:1: ( ( Type_1 ) ) + // InternalRos2Parser.g:4074:1: ( Type_1 ) + { + // InternalRos2Parser.g:4074:1: ( Type_1 ) + // InternalRos2Parser.g:4075:2: Type_1 + { + before(grammarAccess.getPublisherAccess().getTypeKeyword_4()); + match(input,Type_1,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" + // InternalRos2Parser.g:4084: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 { + // InternalRos2Parser.g:4088:1: ( rule__Publisher__Group__5__Impl rule__Publisher__Group__6 ) + // InternalRos2Parser.g:4089:2: rule__Publisher__Group__5__Impl rule__Publisher__Group__6 + { + pushFollow(FOLLOW_21); + 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" + // InternalRos2Parser.g:4096:1: rule__Publisher__Group__5__Impl : ( ( rule__Publisher__MessageAssignment_5 ) ) ; + public final void rule__Publisher__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4100:1: ( ( ( rule__Publisher__MessageAssignment_5 ) ) ) + // InternalRos2Parser.g:4101:1: ( ( rule__Publisher__MessageAssignment_5 ) ) + { + // InternalRos2Parser.g:4101:1: ( ( rule__Publisher__MessageAssignment_5 ) ) + // InternalRos2Parser.g:4102:2: ( rule__Publisher__MessageAssignment_5 ) + { + before(grammarAccess.getPublisherAccess().getMessageAssignment_5()); + // InternalRos2Parser.g:4103:2: ( rule__Publisher__MessageAssignment_5 ) + // InternalRos2Parser.g:4103: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" + // InternalRos2Parser.g:4111:1: rule__Publisher__Group__6 : rule__Publisher__Group__6__Impl rule__Publisher__Group__7 ; + public final void rule__Publisher__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4115:1: ( rule__Publisher__Group__6__Impl rule__Publisher__Group__7 ) + // InternalRos2Parser.g:4116:2: rule__Publisher__Group__6__Impl rule__Publisher__Group__7 + { + pushFollow(FOLLOW_21); + rule__Publisher__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group__7(); + + 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" + // InternalRos2Parser.g:4123:1: rule__Publisher__Group__6__Impl : ( ( rule__Publisher__Group_6__0 )? ) ; + public final void rule__Publisher__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4127:1: ( ( ( rule__Publisher__Group_6__0 )? ) ) + // InternalRos2Parser.g:4128:1: ( ( rule__Publisher__Group_6__0 )? ) + { + // InternalRos2Parser.g:4128:1: ( ( rule__Publisher__Group_6__0 )? ) + // InternalRos2Parser.g:4129:2: ( rule__Publisher__Group_6__0 )? + { + before(grammarAccess.getPublisherAccess().getGroup_6()); + // InternalRos2Parser.g:4130:2: ( rule__Publisher__Group_6__0 )? + int alt22=2; + int LA22_0 = input.LA(1); + + if ( (LA22_0==Ns) ) { + alt22=1; + } + switch (alt22) { + case 1 : + // InternalRos2Parser.g:4130:3: rule__Publisher__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Publisher__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPublisherAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__6__Impl" + + + // $ANTLR start "rule__Publisher__Group__7" + // InternalRos2Parser.g:4138:1: rule__Publisher__Group__7 : rule__Publisher__Group__7__Impl rule__Publisher__Group__8 ; + public final void rule__Publisher__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4142:1: ( rule__Publisher__Group__7__Impl rule__Publisher__Group__8 ) + // InternalRos2Parser.g:4143:2: rule__Publisher__Group__7__Impl rule__Publisher__Group__8 + { + pushFollow(FOLLOW_21); + rule__Publisher__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__7" + + + // $ANTLR start "rule__Publisher__Group__7__Impl" + // InternalRos2Parser.g:4150:1: rule__Publisher__Group__7__Impl : ( ( rule__Publisher__Group_7__0 )? ) ; + public final void rule__Publisher__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4154:1: ( ( ( rule__Publisher__Group_7__0 )? ) ) + // InternalRos2Parser.g:4155:1: ( ( rule__Publisher__Group_7__0 )? ) + { + // InternalRos2Parser.g:4155:1: ( ( rule__Publisher__Group_7__0 )? ) + // InternalRos2Parser.g:4156:2: ( rule__Publisher__Group_7__0 )? + { + before(grammarAccess.getPublisherAccess().getGroup_7()); + // InternalRos2Parser.g:4157:2: ( rule__Publisher__Group_7__0 )? + int alt23=2; + int LA23_0 = input.LA(1); + + if ( (LA23_0==Qos) ) { + alt23=1; + } + switch (alt23) { + case 1 : + // InternalRos2Parser.g:4157:3: rule__Publisher__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__Publisher__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPublisherAccess().getGroup_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__7__Impl" + + + // $ANTLR start "rule__Publisher__Group__8" + // InternalRos2Parser.g:4165:1: rule__Publisher__Group__8 : rule__Publisher__Group__8__Impl ; + public final void rule__Publisher__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4169:1: ( rule__Publisher__Group__8__Impl ) + // InternalRos2Parser.g:4170:2: rule__Publisher__Group__8__Impl + { + pushFollow(FOLLOW_2); + rule__Publisher__Group__8__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__8" + + + // $ANTLR start "rule__Publisher__Group__8__Impl" + // InternalRos2Parser.g:4176:1: rule__Publisher__Group__8__Impl : ( RULE_END ) ; + public final void rule__Publisher__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4180:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:4181:1: ( RULE_END ) + { + // InternalRos2Parser.g:4181:1: ( RULE_END ) + // InternalRos2Parser.g:4182:2: RULE_END + { + before(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_8()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__8__Impl" + + + // $ANTLR start "rule__Publisher__Group_6__0" + // InternalRos2Parser.g:4192:1: rule__Publisher__Group_6__0 : rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 ; + public final void rule__Publisher__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4196:1: ( rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 ) + // InternalRos2Parser.g:4197:2: rule__Publisher__Group_6__0__Impl rule__Publisher__Group_6__1 + { + pushFollow(FOLLOW_22); + rule__Publisher__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_6__0" + + + // $ANTLR start "rule__Publisher__Group_6__0__Impl" + // InternalRos2Parser.g:4204:1: rule__Publisher__Group_6__0__Impl : ( Ns ) ; + public final void rule__Publisher__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4208:1: ( ( Ns ) ) + // InternalRos2Parser.g:4209:1: ( Ns ) + { + // InternalRos2Parser.g:4209:1: ( Ns ) + // InternalRos2Parser.g:4210:2: Ns + { + before(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_6__0__Impl" + + + // $ANTLR start "rule__Publisher__Group_6__1" + // InternalRos2Parser.g:4219:1: rule__Publisher__Group_6__1 : rule__Publisher__Group_6__1__Impl ; + public final void rule__Publisher__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4223:1: ( rule__Publisher__Group_6__1__Impl ) + // InternalRos2Parser.g:4224:2: rule__Publisher__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__Publisher__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_6__1" + + + // $ANTLR start "rule__Publisher__Group_6__1__Impl" + // InternalRos2Parser.g:4230:1: rule__Publisher__Group_6__1__Impl : ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) ; + public final void rule__Publisher__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4234:1: ( ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) ) + // InternalRos2Parser.g:4235:1: ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) + { + // InternalRos2Parser.g:4235:1: ( ( rule__Publisher__NamespaceAssignment_6_1 ) ) + // InternalRos2Parser.g:4236:2: ( rule__Publisher__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); + // InternalRos2Parser.g:4237:2: ( rule__Publisher__NamespaceAssignment_6_1 ) + // InternalRos2Parser.g:4237:3: rule__Publisher__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__Publisher__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPublisherAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_6__1__Impl" + + + // $ANTLR start "rule__Publisher__Group_7__0" + // InternalRos2Parser.g:4246:1: rule__Publisher__Group_7__0 : rule__Publisher__Group_7__0__Impl rule__Publisher__Group_7__1 ; + public final void rule__Publisher__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4250:1: ( rule__Publisher__Group_7__0__Impl rule__Publisher__Group_7__1 ) + // InternalRos2Parser.g:4251:2: rule__Publisher__Group_7__0__Impl rule__Publisher__Group_7__1 + { + pushFollow(FOLLOW_5); + rule__Publisher__Group_7__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group_7__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_7__0" + + + // $ANTLR start "rule__Publisher__Group_7__0__Impl" + // InternalRos2Parser.g:4258:1: rule__Publisher__Group_7__0__Impl : ( Qos ) ; + public final void rule__Publisher__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4262:1: ( ( Qos ) ) + // InternalRos2Parser.g:4263:1: ( Qos ) + { + // InternalRos2Parser.g:4263:1: ( Qos ) + // InternalRos2Parser.g:4264:2: Qos + { + before(grammarAccess.getPublisherAccess().getQosKeyword_7_0()); + match(input,Qos,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getQosKeyword_7_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_7__0__Impl" + + + // $ANTLR start "rule__Publisher__Group_7__1" + // InternalRos2Parser.g:4273:1: rule__Publisher__Group_7__1 : rule__Publisher__Group_7__1__Impl rule__Publisher__Group_7__2 ; + public final void rule__Publisher__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4277:1: ( rule__Publisher__Group_7__1__Impl rule__Publisher__Group_7__2 ) + // InternalRos2Parser.g:4278:2: rule__Publisher__Group_7__1__Impl rule__Publisher__Group_7__2 + { + pushFollow(FOLLOW_14); + rule__Publisher__Group_7__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group_7__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_7__1" + + + // $ANTLR start "rule__Publisher__Group_7__1__Impl" + // InternalRos2Parser.g:4285:1: rule__Publisher__Group_7__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Publisher__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4289:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:4290:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:4290:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:4291:2: RULE_BEGIN + { + before(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_7_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_7_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_7__1__Impl" + + + // $ANTLR start "rule__Publisher__Group_7__2" + // InternalRos2Parser.g:4300:1: rule__Publisher__Group_7__2 : rule__Publisher__Group_7__2__Impl rule__Publisher__Group_7__3 ; + public final void rule__Publisher__Group_7__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4304:1: ( rule__Publisher__Group_7__2__Impl rule__Publisher__Group_7__3 ) + // InternalRos2Parser.g:4305:2: rule__Publisher__Group_7__2__Impl rule__Publisher__Group_7__3 + { + pushFollow(FOLLOW_23); + rule__Publisher__Group_7__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group_7__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_7__2" + + + // $ANTLR start "rule__Publisher__Group_7__2__Impl" + // InternalRos2Parser.g:4312:1: rule__Publisher__Group_7__2__Impl : ( ( rule__Publisher__QosAssignment_7_2 ) ) ; + public final void rule__Publisher__Group_7__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4316:1: ( ( ( rule__Publisher__QosAssignment_7_2 ) ) ) + // InternalRos2Parser.g:4317:1: ( ( rule__Publisher__QosAssignment_7_2 ) ) + { + // InternalRos2Parser.g:4317:1: ( ( rule__Publisher__QosAssignment_7_2 ) ) + // InternalRos2Parser.g:4318:2: ( rule__Publisher__QosAssignment_7_2 ) + { + before(grammarAccess.getPublisherAccess().getQosAssignment_7_2()); + // InternalRos2Parser.g:4319:2: ( rule__Publisher__QosAssignment_7_2 ) + // InternalRos2Parser.g:4319:3: rule__Publisher__QosAssignment_7_2 + { + pushFollow(FOLLOW_2); + rule__Publisher__QosAssignment_7_2(); + + state._fsp--; + + + } + + after(grammarAccess.getPublisherAccess().getQosAssignment_7_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_7__2__Impl" + + + // $ANTLR start "rule__Publisher__Group_7__3" + // InternalRos2Parser.g:4327:1: rule__Publisher__Group_7__3 : rule__Publisher__Group_7__3__Impl ; + public final void rule__Publisher__Group_7__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4331:1: ( rule__Publisher__Group_7__3__Impl ) + // InternalRos2Parser.g:4332:2: rule__Publisher__Group_7__3__Impl + { + pushFollow(FOLLOW_2); + rule__Publisher__Group_7__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_7__3" + + + // $ANTLR start "rule__Publisher__Group_7__3__Impl" + // InternalRos2Parser.g:4338:1: rule__Publisher__Group_7__3__Impl : ( RULE_END ) ; + public final void rule__Publisher__Group_7__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4342:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:4343:1: ( RULE_END ) + { + // InternalRos2Parser.g:4343:1: ( RULE_END ) + // InternalRos2Parser.g:4344:2: RULE_END + { + before(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group_7__3__Impl" + + + // $ANTLR start "rule__Subscriber__Group__0" + // InternalRos2Parser.g:4354: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 { + // InternalRos2Parser.g:4358:1: ( rule__Subscriber__Group__0__Impl rule__Subscriber__Group__1 ) + // InternalRos2Parser.g:4359: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" + // InternalRos2Parser.g:4366:1: rule__Subscriber__Group__0__Impl : ( () ) ; + public final void rule__Subscriber__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4370:1: ( ( () ) ) + // InternalRos2Parser.g:4371:1: ( () ) + { + // InternalRos2Parser.g:4371:1: ( () ) + // InternalRos2Parser.g:4372:2: () + { + before(grammarAccess.getSubscriberAccess().getSubscriberAction_0()); + // InternalRos2Parser.g:4373:2: () + // InternalRos2Parser.g:4373:3: + { + } + + after(grammarAccess.getSubscriberAccess().getSubscriberAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__0__Impl" + + + // $ANTLR start "rule__Subscriber__Group__1" + // InternalRos2Parser.g:4381: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 { + // InternalRos2Parser.g:4385:1: ( rule__Subscriber__Group__1__Impl rule__Subscriber__Group__2 ) + // InternalRos2Parser.g:4386: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" + // InternalRos2Parser.g:4393:1: rule__Subscriber__Group__1__Impl : ( ( rule__Subscriber__NameAssignment_1 ) ) ; + public final void rule__Subscriber__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4397:1: ( ( ( rule__Subscriber__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:4398:1: ( ( rule__Subscriber__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:4398:1: ( ( rule__Subscriber__NameAssignment_1 ) ) + // InternalRos2Parser.g:4399:2: ( rule__Subscriber__NameAssignment_1 ) + { + before(grammarAccess.getSubscriberAccess().getNameAssignment_1()); + // InternalRos2Parser.g:4400:2: ( rule__Subscriber__NameAssignment_1 ) + // InternalRos2Parser.g:4400: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" + // InternalRos2Parser.g:4408: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 { + // InternalRos2Parser.g:4412:1: ( rule__Subscriber__Group__2__Impl rule__Subscriber__Group__3 ) + // InternalRos2Parser.g:4413: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" + // InternalRos2Parser.g:4420:1: rule__Subscriber__Group__2__Impl : ( Colon ) ; + public final void rule__Subscriber__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4424:1: ( ( Colon ) ) + // InternalRos2Parser.g:4425:1: ( Colon ) + { + // InternalRos2Parser.g:4425:1: ( Colon ) + // InternalRos2Parser.g:4426: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" + // InternalRos2Parser.g:4435: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 { + // InternalRos2Parser.g:4439:1: ( rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 ) + // InternalRos2Parser.g:4440:2: rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 + { + pushFollow(FOLLOW_20); + 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" + // InternalRos2Parser.g:4447:1: rule__Subscriber__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Subscriber__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4451:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:4452:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:4452:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:4453: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" + // InternalRos2Parser.g:4462: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 { + // InternalRos2Parser.g:4466:1: ( rule__Subscriber__Group__4__Impl rule__Subscriber__Group__5 ) + // InternalRos2Parser.g:4467: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" + // InternalRos2Parser.g:4474:1: rule__Subscriber__Group__4__Impl : ( Type_1 ) ; + public final void rule__Subscriber__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4478:1: ( ( Type_1 ) ) + // InternalRos2Parser.g:4479:1: ( Type_1 ) + { + // InternalRos2Parser.g:4479:1: ( Type_1 ) + // InternalRos2Parser.g:4480:2: Type_1 + { + before(grammarAccess.getSubscriberAccess().getTypeKeyword_4()); + match(input,Type_1,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" + // InternalRos2Parser.g:4489: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 { + // InternalRos2Parser.g:4493:1: ( rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 ) + // InternalRos2Parser.g:4494:2: rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 + { + pushFollow(FOLLOW_21); + 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" + // InternalRos2Parser.g:4501:1: rule__Subscriber__Group__5__Impl : ( ( rule__Subscriber__MessageAssignment_5 ) ) ; + public final void rule__Subscriber__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4505:1: ( ( ( rule__Subscriber__MessageAssignment_5 ) ) ) + // InternalRos2Parser.g:4506:1: ( ( rule__Subscriber__MessageAssignment_5 ) ) + { + // InternalRos2Parser.g:4506:1: ( ( rule__Subscriber__MessageAssignment_5 ) ) + // InternalRos2Parser.g:4507:2: ( rule__Subscriber__MessageAssignment_5 ) + { + before(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); + // InternalRos2Parser.g:4508:2: ( rule__Subscriber__MessageAssignment_5 ) + // InternalRos2Parser.g:4508: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" + // InternalRos2Parser.g:4516:1: rule__Subscriber__Group__6 : rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 ; + public final void rule__Subscriber__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4520:1: ( rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 ) + // InternalRos2Parser.g:4521:2: rule__Subscriber__Group__6__Impl rule__Subscriber__Group__7 + { + pushFollow(FOLLOW_21); + rule__Subscriber__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group__7(); + + 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" + // InternalRos2Parser.g:4528:1: rule__Subscriber__Group__6__Impl : ( ( rule__Subscriber__Group_6__0 )? ) ; + public final void rule__Subscriber__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4532:1: ( ( ( rule__Subscriber__Group_6__0 )? ) ) + // InternalRos2Parser.g:4533:1: ( ( rule__Subscriber__Group_6__0 )? ) + { + // InternalRos2Parser.g:4533:1: ( ( rule__Subscriber__Group_6__0 )? ) + // InternalRos2Parser.g:4534:2: ( rule__Subscriber__Group_6__0 )? + { + before(grammarAccess.getSubscriberAccess().getGroup_6()); + // InternalRos2Parser.g:4535:2: ( rule__Subscriber__Group_6__0 )? + int alt24=2; + int LA24_0 = input.LA(1); + + if ( (LA24_0==Ns) ) { + alt24=1; + } + switch (alt24) { + case 1 : + // InternalRos2Parser.g:4535:3: rule__Subscriber__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Subscriber__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getSubscriberAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__6__Impl" + + + // $ANTLR start "rule__Subscriber__Group__7" + // InternalRos2Parser.g:4543:1: rule__Subscriber__Group__7 : rule__Subscriber__Group__7__Impl rule__Subscriber__Group__8 ; + public final void rule__Subscriber__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4547:1: ( rule__Subscriber__Group__7__Impl rule__Subscriber__Group__8 ) + // InternalRos2Parser.g:4548:2: rule__Subscriber__Group__7__Impl rule__Subscriber__Group__8 + { + pushFollow(FOLLOW_21); + rule__Subscriber__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__7" + + + // $ANTLR start "rule__Subscriber__Group__7__Impl" + // InternalRos2Parser.g:4555:1: rule__Subscriber__Group__7__Impl : ( ( rule__Subscriber__Group_7__0 )? ) ; + public final void rule__Subscriber__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4559:1: ( ( ( rule__Subscriber__Group_7__0 )? ) ) + // InternalRos2Parser.g:4560:1: ( ( rule__Subscriber__Group_7__0 )? ) + { + // InternalRos2Parser.g:4560:1: ( ( rule__Subscriber__Group_7__0 )? ) + // InternalRos2Parser.g:4561:2: ( rule__Subscriber__Group_7__0 )? + { + before(grammarAccess.getSubscriberAccess().getGroup_7()); + // InternalRos2Parser.g:4562:2: ( rule__Subscriber__Group_7__0 )? + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0==Qos) ) { + alt25=1; + } + switch (alt25) { + case 1 : + // InternalRos2Parser.g:4562:3: rule__Subscriber__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__Subscriber__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getSubscriberAccess().getGroup_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__7__Impl" + + + // $ANTLR start "rule__Subscriber__Group__8" + // InternalRos2Parser.g:4570:1: rule__Subscriber__Group__8 : rule__Subscriber__Group__8__Impl ; + public final void rule__Subscriber__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4574:1: ( rule__Subscriber__Group__8__Impl ) + // InternalRos2Parser.g:4575:2: rule__Subscriber__Group__8__Impl + { + pushFollow(FOLLOW_2); + rule__Subscriber__Group__8__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__8" + + + // $ANTLR start "rule__Subscriber__Group__8__Impl" + // InternalRos2Parser.g:4581:1: rule__Subscriber__Group__8__Impl : ( RULE_END ) ; + public final void rule__Subscriber__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4585:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:4586:1: ( RULE_END ) + { + // InternalRos2Parser.g:4586:1: ( RULE_END ) + // InternalRos2Parser.g:4587:2: RULE_END + { + before(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_8()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__8__Impl" + + + // $ANTLR start "rule__Subscriber__Group_6__0" + // InternalRos2Parser.g:4597:1: rule__Subscriber__Group_6__0 : rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 ; + public final void rule__Subscriber__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4601:1: ( rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 ) + // InternalRos2Parser.g:4602:2: rule__Subscriber__Group_6__0__Impl rule__Subscriber__Group_6__1 + { + pushFollow(FOLLOW_22); + rule__Subscriber__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_6__0" + + + // $ANTLR start "rule__Subscriber__Group_6__0__Impl" + // InternalRos2Parser.g:4609:1: rule__Subscriber__Group_6__0__Impl : ( Ns ) ; + public final void rule__Subscriber__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4613:1: ( ( Ns ) ) + // InternalRos2Parser.g:4614:1: ( Ns ) + { + // InternalRos2Parser.g:4614:1: ( Ns ) + // InternalRos2Parser.g:4615:2: Ns + { + before(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_6__0__Impl" + + + // $ANTLR start "rule__Subscriber__Group_6__1" + // InternalRos2Parser.g:4624:1: rule__Subscriber__Group_6__1 : rule__Subscriber__Group_6__1__Impl ; + public final void rule__Subscriber__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4628:1: ( rule__Subscriber__Group_6__1__Impl ) + // InternalRos2Parser.g:4629:2: rule__Subscriber__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__Subscriber__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_6__1" + + + // $ANTLR start "rule__Subscriber__Group_6__1__Impl" + // InternalRos2Parser.g:4635:1: rule__Subscriber__Group_6__1__Impl : ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) ; + public final void rule__Subscriber__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4639:1: ( ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) ) + // InternalRos2Parser.g:4640:1: ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) + { + // InternalRos2Parser.g:4640:1: ( ( rule__Subscriber__NamespaceAssignment_6_1 ) ) + // InternalRos2Parser.g:4641:2: ( rule__Subscriber__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); + // InternalRos2Parser.g:4642:2: ( rule__Subscriber__NamespaceAssignment_6_1 ) + // InternalRos2Parser.g:4642:3: rule__Subscriber__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__Subscriber__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getSubscriberAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_6__1__Impl" + + + // $ANTLR start "rule__Subscriber__Group_7__0" + // InternalRos2Parser.g:4651:1: rule__Subscriber__Group_7__0 : rule__Subscriber__Group_7__0__Impl rule__Subscriber__Group_7__1 ; + public final void rule__Subscriber__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4655:1: ( rule__Subscriber__Group_7__0__Impl rule__Subscriber__Group_7__1 ) + // InternalRos2Parser.g:4656:2: rule__Subscriber__Group_7__0__Impl rule__Subscriber__Group_7__1 + { + pushFollow(FOLLOW_14); + rule__Subscriber__Group_7__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group_7__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_7__0" + + + // $ANTLR start "rule__Subscriber__Group_7__0__Impl" + // InternalRos2Parser.g:4663:1: rule__Subscriber__Group_7__0__Impl : ( Qos ) ; + public final void rule__Subscriber__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4667:1: ( ( Qos ) ) + // InternalRos2Parser.g:4668:1: ( Qos ) + { + // InternalRos2Parser.g:4668:1: ( Qos ) + // InternalRos2Parser.g:4669:2: Qos + { + before(grammarAccess.getSubscriberAccess().getQosKeyword_7_0()); + match(input,Qos,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getQosKeyword_7_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_7__0__Impl" + + + // $ANTLR start "rule__Subscriber__Group_7__1" + // InternalRos2Parser.g:4678:1: rule__Subscriber__Group_7__1 : rule__Subscriber__Group_7__1__Impl ; + public final void rule__Subscriber__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4682:1: ( rule__Subscriber__Group_7__1__Impl ) + // InternalRos2Parser.g:4683:2: rule__Subscriber__Group_7__1__Impl + { + pushFollow(FOLLOW_2); + rule__Subscriber__Group_7__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_7__1" + + + // $ANTLR start "rule__Subscriber__Group_7__1__Impl" + // InternalRos2Parser.g:4689:1: rule__Subscriber__Group_7__1__Impl : ( ( rule__Subscriber__QosAssignment_7_1 ) ) ; + public final void rule__Subscriber__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4693:1: ( ( ( rule__Subscriber__QosAssignment_7_1 ) ) ) + // InternalRos2Parser.g:4694:1: ( ( rule__Subscriber__QosAssignment_7_1 ) ) + { + // InternalRos2Parser.g:4694:1: ( ( rule__Subscriber__QosAssignment_7_1 ) ) + // InternalRos2Parser.g:4695:2: ( rule__Subscriber__QosAssignment_7_1 ) + { + before(grammarAccess.getSubscriberAccess().getQosAssignment_7_1()); + // InternalRos2Parser.g:4696:2: ( rule__Subscriber__QosAssignment_7_1 ) + // InternalRos2Parser.g:4696:3: rule__Subscriber__QosAssignment_7_1 + { + pushFollow(FOLLOW_2); + rule__Subscriber__QosAssignment_7_1(); + + state._fsp--; + + + } + + after(grammarAccess.getSubscriberAccess().getQosAssignment_7_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group_7__1__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__0" + // InternalRos2Parser.g:4705:1: rule__ServiceServer__Group__0 : rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 ; + public final void rule__ServiceServer__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4709:1: ( rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 ) + // InternalRos2Parser.g:4710:2: rule__ServiceServer__Group__0__Impl rule__ServiceServer__Group__1 + { + pushFollow(FOLLOW_7); + rule__ServiceServer__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__0" + + + // $ANTLR start "rule__ServiceServer__Group__0__Impl" + // InternalRos2Parser.g:4717:1: rule__ServiceServer__Group__0__Impl : ( () ) ; + public final void rule__ServiceServer__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4721:1: ( ( () ) ) + // InternalRos2Parser.g:4722:1: ( () ) + { + // InternalRos2Parser.g:4722:1: ( () ) + // InternalRos2Parser.g:4723:2: () + { + before(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); + // InternalRos2Parser.g:4724:2: () + // InternalRos2Parser.g:4724:3: + { + } + + after(grammarAccess.getServiceServerAccess().getServiceServerAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__0__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__1" + // InternalRos2Parser.g:4732:1: rule__ServiceServer__Group__1 : rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 ; + public final void rule__ServiceServer__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4736:1: ( rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 ) + // InternalRos2Parser.g:4737:2: rule__ServiceServer__Group__1__Impl rule__ServiceServer__Group__2 + { + pushFollow(FOLLOW_4); + rule__ServiceServer__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__1" + + + // $ANTLR start "rule__ServiceServer__Group__1__Impl" + // InternalRos2Parser.g:4744:1: rule__ServiceServer__Group__1__Impl : ( ( rule__ServiceServer__NameAssignment_1 ) ) ; + public final void rule__ServiceServer__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4748:1: ( ( ( rule__ServiceServer__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:4749:1: ( ( rule__ServiceServer__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:4749:1: ( ( rule__ServiceServer__NameAssignment_1 ) ) + // InternalRos2Parser.g:4750:2: ( rule__ServiceServer__NameAssignment_1 ) + { + before(grammarAccess.getServiceServerAccess().getNameAssignment_1()); + // InternalRos2Parser.g:4751:2: ( rule__ServiceServer__NameAssignment_1 ) + // InternalRos2Parser.g:4751:3: rule__ServiceServer__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceServerAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__1__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__2" + // InternalRos2Parser.g:4759:1: rule__ServiceServer__Group__2 : rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 ; + public final void rule__ServiceServer__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4763:1: ( rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 ) + // InternalRos2Parser.g:4764:2: rule__ServiceServer__Group__2__Impl rule__ServiceServer__Group__3 + { + pushFollow(FOLLOW_5); + rule__ServiceServer__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__2" + + + // $ANTLR start "rule__ServiceServer__Group__2__Impl" + // InternalRos2Parser.g:4771:1: rule__ServiceServer__Group__2__Impl : ( Colon ) ; + public final void rule__ServiceServer__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4775:1: ( ( Colon ) ) + // InternalRos2Parser.g:4776:1: ( Colon ) + { + // InternalRos2Parser.g:4776:1: ( Colon ) + // InternalRos2Parser.g:4777:2: Colon + { + before(grammarAccess.getServiceServerAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__2__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__3" + // InternalRos2Parser.g:4786:1: rule__ServiceServer__Group__3 : rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 ; + public final void rule__ServiceServer__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4790:1: ( rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 ) + // InternalRos2Parser.g:4791:2: rule__ServiceServer__Group__3__Impl rule__ServiceServer__Group__4 + { + pushFollow(FOLLOW_20); + rule__ServiceServer__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__3" + + + // $ANTLR start "rule__ServiceServer__Group__3__Impl" + // InternalRos2Parser.g:4798:1: rule__ServiceServer__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceServer__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4802:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:4803:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:4803:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:4804:2: RULE_BEGIN + { + before(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__3__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__4" + // InternalRos2Parser.g:4813:1: rule__ServiceServer__Group__4 : rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 ; + public final void rule__ServiceServer__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4817:1: ( rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 ) + // InternalRos2Parser.g:4818:2: rule__ServiceServer__Group__4__Impl rule__ServiceServer__Group__5 + { + pushFollow(FOLLOW_7); + rule__ServiceServer__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__4" + + + // $ANTLR start "rule__ServiceServer__Group__4__Impl" + // InternalRos2Parser.g:4825:1: rule__ServiceServer__Group__4__Impl : ( Type_1 ) ; + public final void rule__ServiceServer__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4829:1: ( ( Type_1 ) ) + // InternalRos2Parser.g:4830:1: ( Type_1 ) + { + // InternalRos2Parser.g:4830:1: ( Type_1 ) + // InternalRos2Parser.g:4831:2: Type_1 + { + before(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getTypeKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__4__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__5" + // InternalRos2Parser.g:4840:1: rule__ServiceServer__Group__5 : rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 ; + public final void rule__ServiceServer__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4844:1: ( rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 ) + // InternalRos2Parser.g:4845:2: rule__ServiceServer__Group__5__Impl rule__ServiceServer__Group__6 + { + pushFollow(FOLLOW_21); + rule__ServiceServer__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__5" + + + // $ANTLR start "rule__ServiceServer__Group__5__Impl" + // InternalRos2Parser.g:4852:1: rule__ServiceServer__Group__5__Impl : ( ( rule__ServiceServer__ServiceAssignment_5 ) ) ; + public final void rule__ServiceServer__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4856:1: ( ( ( rule__ServiceServer__ServiceAssignment_5 ) ) ) + // InternalRos2Parser.g:4857:1: ( ( rule__ServiceServer__ServiceAssignment_5 ) ) + { + // InternalRos2Parser.g:4857:1: ( ( rule__ServiceServer__ServiceAssignment_5 ) ) + // InternalRos2Parser.g:4858:2: ( rule__ServiceServer__ServiceAssignment_5 ) + { + before(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); + // InternalRos2Parser.g:4859:2: ( rule__ServiceServer__ServiceAssignment_5 ) + // InternalRos2Parser.g:4859:3: rule__ServiceServer__ServiceAssignment_5 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__ServiceAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceServerAccess().getServiceAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__5__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__6" + // InternalRos2Parser.g:4867:1: rule__ServiceServer__Group__6 : rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 ; + public final void rule__ServiceServer__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4871:1: ( rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 ) + // InternalRos2Parser.g:4872:2: rule__ServiceServer__Group__6__Impl rule__ServiceServer__Group__7 + { + pushFollow(FOLLOW_21); + rule__ServiceServer__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__6" + + + // $ANTLR start "rule__ServiceServer__Group__6__Impl" + // InternalRos2Parser.g:4879:1: rule__ServiceServer__Group__6__Impl : ( ( rule__ServiceServer__Group_6__0 )? ) ; + public final void rule__ServiceServer__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4883:1: ( ( ( rule__ServiceServer__Group_6__0 )? ) ) + // InternalRos2Parser.g:4884:1: ( ( rule__ServiceServer__Group_6__0 )? ) + { + // InternalRos2Parser.g:4884:1: ( ( rule__ServiceServer__Group_6__0 )? ) + // InternalRos2Parser.g:4885:2: ( rule__ServiceServer__Group_6__0 )? + { + before(grammarAccess.getServiceServerAccess().getGroup_6()); + // InternalRos2Parser.g:4886:2: ( rule__ServiceServer__Group_6__0 )? + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0==Ns) ) { + alt26=1; + } + switch (alt26) { + case 1 : + // InternalRos2Parser.g:4886:3: rule__ServiceServer__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceServerAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__6__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__7" + // InternalRos2Parser.g:4894:1: rule__ServiceServer__Group__7 : rule__ServiceServer__Group__7__Impl rule__ServiceServer__Group__8 ; + public final void rule__ServiceServer__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4898:1: ( rule__ServiceServer__Group__7__Impl rule__ServiceServer__Group__8 ) + // InternalRos2Parser.g:4899:2: rule__ServiceServer__Group__7__Impl rule__ServiceServer__Group__8 + { + pushFollow(FOLLOW_21); + rule__ServiceServer__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__7" + + + // $ANTLR start "rule__ServiceServer__Group__7__Impl" + // InternalRos2Parser.g:4906:1: rule__ServiceServer__Group__7__Impl : ( ( rule__ServiceServer__Group_7__0 )? ) ; + public final void rule__ServiceServer__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4910:1: ( ( ( rule__ServiceServer__Group_7__0 )? ) ) + // InternalRos2Parser.g:4911:1: ( ( rule__ServiceServer__Group_7__0 )? ) + { + // InternalRos2Parser.g:4911:1: ( ( rule__ServiceServer__Group_7__0 )? ) + // InternalRos2Parser.g:4912:2: ( rule__ServiceServer__Group_7__0 )? + { + before(grammarAccess.getServiceServerAccess().getGroup_7()); + // InternalRos2Parser.g:4913:2: ( rule__ServiceServer__Group_7__0 )? + int alt27=2; + int LA27_0 = input.LA(1); + + if ( (LA27_0==Qos) ) { + alt27=1; + } + switch (alt27) { + case 1 : + // InternalRos2Parser.g:4913:3: rule__ServiceServer__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceServerAccess().getGroup_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__7__Impl" + + + // $ANTLR start "rule__ServiceServer__Group__8" + // InternalRos2Parser.g:4921:1: rule__ServiceServer__Group__8 : rule__ServiceServer__Group__8__Impl ; + public final void rule__ServiceServer__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4925:1: ( rule__ServiceServer__Group__8__Impl ) + // InternalRos2Parser.g:4926:2: rule__ServiceServer__Group__8__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceServer__Group__8__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__8" + + + // $ANTLR start "rule__ServiceServer__Group__8__Impl" + // InternalRos2Parser.g:4932:1: rule__ServiceServer__Group__8__Impl : ( RULE_END ) ; + public final void rule__ServiceServer__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4936:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:4937:1: ( RULE_END ) + { + // InternalRos2Parser.g:4937:1: ( RULE_END ) + // InternalRos2Parser.g:4938:2: RULE_END + { + before(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_8()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group__8__Impl" + + + // $ANTLR start "rule__ServiceServer__Group_6__0" + // InternalRos2Parser.g:4948:1: rule__ServiceServer__Group_6__0 : rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 ; + public final void rule__ServiceServer__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4952:1: ( rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 ) + // InternalRos2Parser.g:4953:2: rule__ServiceServer__Group_6__0__Impl rule__ServiceServer__Group_6__1 + { + pushFollow(FOLLOW_22); + rule__ServiceServer__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_6__0" + + + // $ANTLR start "rule__ServiceServer__Group_6__0__Impl" + // InternalRos2Parser.g:4960:1: rule__ServiceServer__Group_6__0__Impl : ( Ns ) ; + public final void rule__ServiceServer__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4964:1: ( ( Ns ) ) + // InternalRos2Parser.g:4965:1: ( Ns ) + { + // InternalRos2Parser.g:4965:1: ( Ns ) + // InternalRos2Parser.g:4966:2: Ns + { + before(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_6__0__Impl" + + + // $ANTLR start "rule__ServiceServer__Group_6__1" + // InternalRos2Parser.g:4975:1: rule__ServiceServer__Group_6__1 : rule__ServiceServer__Group_6__1__Impl ; + public final void rule__ServiceServer__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4979:1: ( rule__ServiceServer__Group_6__1__Impl ) + // InternalRos2Parser.g:4980:2: rule__ServiceServer__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceServer__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_6__1" + + + // $ANTLR start "rule__ServiceServer__Group_6__1__Impl" + // InternalRos2Parser.g:4986:1: rule__ServiceServer__Group_6__1__Impl : ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) ; + public final void rule__ServiceServer__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:4990:1: ( ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) ) + // InternalRos2Parser.g:4991:1: ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) + { + // InternalRos2Parser.g:4991:1: ( ( rule__ServiceServer__NamespaceAssignment_6_1 ) ) + // InternalRos2Parser.g:4992:2: ( rule__ServiceServer__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); + // InternalRos2Parser.g:4993:2: ( rule__ServiceServer__NamespaceAssignment_6_1 ) + // InternalRos2Parser.g:4993:3: rule__ServiceServer__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceServerAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_6__1__Impl" + + + // $ANTLR start "rule__ServiceServer__Group_7__0" + // InternalRos2Parser.g:5002:1: rule__ServiceServer__Group_7__0 : rule__ServiceServer__Group_7__0__Impl rule__ServiceServer__Group_7__1 ; + public final void rule__ServiceServer__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5006:1: ( rule__ServiceServer__Group_7__0__Impl rule__ServiceServer__Group_7__1 ) + // InternalRos2Parser.g:5007:2: rule__ServiceServer__Group_7__0__Impl rule__ServiceServer__Group_7__1 + { + pushFollow(FOLLOW_14); + rule__ServiceServer__Group_7__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceServer__Group_7__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_7__0" + + + // $ANTLR start "rule__ServiceServer__Group_7__0__Impl" + // InternalRos2Parser.g:5014:1: rule__ServiceServer__Group_7__0__Impl : ( Qos ) ; + public final void rule__ServiceServer__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5018:1: ( ( Qos ) ) + // InternalRos2Parser.g:5019:1: ( Qos ) + { + // InternalRos2Parser.g:5019:1: ( Qos ) + // InternalRos2Parser.g:5020:2: Qos + { + before(grammarAccess.getServiceServerAccess().getQosKeyword_7_0()); + match(input,Qos,FOLLOW_2); + after(grammarAccess.getServiceServerAccess().getQosKeyword_7_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_7__0__Impl" + + + // $ANTLR start "rule__ServiceServer__Group_7__1" + // InternalRos2Parser.g:5029:1: rule__ServiceServer__Group_7__1 : rule__ServiceServer__Group_7__1__Impl ; + public final void rule__ServiceServer__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5033:1: ( rule__ServiceServer__Group_7__1__Impl ) + // InternalRos2Parser.g:5034:2: rule__ServiceServer__Group_7__1__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceServer__Group_7__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_7__1" + + + // $ANTLR start "rule__ServiceServer__Group_7__1__Impl" + // InternalRos2Parser.g:5040:1: rule__ServiceServer__Group_7__1__Impl : ( ( rule__ServiceServer__QosAssignment_7_1 ) ) ; + public final void rule__ServiceServer__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5044:1: ( ( ( rule__ServiceServer__QosAssignment_7_1 ) ) ) + // InternalRos2Parser.g:5045:1: ( ( rule__ServiceServer__QosAssignment_7_1 ) ) + { + // InternalRos2Parser.g:5045:1: ( ( rule__ServiceServer__QosAssignment_7_1 ) ) + // InternalRos2Parser.g:5046:2: ( rule__ServiceServer__QosAssignment_7_1 ) + { + before(grammarAccess.getServiceServerAccess().getQosAssignment_7_1()); + // InternalRos2Parser.g:5047:2: ( rule__ServiceServer__QosAssignment_7_1 ) + // InternalRos2Parser.g:5047:3: rule__ServiceServer__QosAssignment_7_1 + { + pushFollow(FOLLOW_2); + rule__ServiceServer__QosAssignment_7_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceServerAccess().getQosAssignment_7_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__Group_7__1__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__0" + // InternalRos2Parser.g:5056:1: rule__ServiceClient__Group__0 : rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 ; + public final void rule__ServiceClient__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5060:1: ( rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 ) + // InternalRos2Parser.g:5061:2: rule__ServiceClient__Group__0__Impl rule__ServiceClient__Group__1 + { + pushFollow(FOLLOW_7); + rule__ServiceClient__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__0" + + + // $ANTLR start "rule__ServiceClient__Group__0__Impl" + // InternalRos2Parser.g:5068:1: rule__ServiceClient__Group__0__Impl : ( () ) ; + public final void rule__ServiceClient__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5072:1: ( ( () ) ) + // InternalRos2Parser.g:5073:1: ( () ) + { + // InternalRos2Parser.g:5073:1: ( () ) + // InternalRos2Parser.g:5074:2: () + { + before(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); + // InternalRos2Parser.g:5075:2: () + // InternalRos2Parser.g:5075:3: + { + } + + after(grammarAccess.getServiceClientAccess().getServiceClientAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__0__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__1" + // InternalRos2Parser.g:5083:1: rule__ServiceClient__Group__1 : rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 ; + public final void rule__ServiceClient__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5087:1: ( rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 ) + // InternalRos2Parser.g:5088:2: rule__ServiceClient__Group__1__Impl rule__ServiceClient__Group__2 + { + pushFollow(FOLLOW_4); + rule__ServiceClient__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__1" + + + // $ANTLR start "rule__ServiceClient__Group__1__Impl" + // InternalRos2Parser.g:5095:1: rule__ServiceClient__Group__1__Impl : ( ( rule__ServiceClient__NameAssignment_1 ) ) ; + public final void rule__ServiceClient__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5099:1: ( ( ( rule__ServiceClient__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:5100:1: ( ( rule__ServiceClient__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:5100:1: ( ( rule__ServiceClient__NameAssignment_1 ) ) + // InternalRos2Parser.g:5101:2: ( rule__ServiceClient__NameAssignment_1 ) + { + before(grammarAccess.getServiceClientAccess().getNameAssignment_1()); + // InternalRos2Parser.g:5102:2: ( rule__ServiceClient__NameAssignment_1 ) + // InternalRos2Parser.g:5102:3: rule__ServiceClient__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceClientAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__1__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__2" + // InternalRos2Parser.g:5110:1: rule__ServiceClient__Group__2 : rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 ; + public final void rule__ServiceClient__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5114:1: ( rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 ) + // InternalRos2Parser.g:5115:2: rule__ServiceClient__Group__2__Impl rule__ServiceClient__Group__3 + { + pushFollow(FOLLOW_5); + rule__ServiceClient__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__2" + + + // $ANTLR start "rule__ServiceClient__Group__2__Impl" + // InternalRos2Parser.g:5122:1: rule__ServiceClient__Group__2__Impl : ( Colon ) ; + public final void rule__ServiceClient__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5126:1: ( ( Colon ) ) + // InternalRos2Parser.g:5127:1: ( Colon ) + { + // InternalRos2Parser.g:5127:1: ( Colon ) + // InternalRos2Parser.g:5128:2: Colon + { + before(grammarAccess.getServiceClientAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__2__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__3" + // InternalRos2Parser.g:5137:1: rule__ServiceClient__Group__3 : rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 ; + public final void rule__ServiceClient__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5141:1: ( rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 ) + // InternalRos2Parser.g:5142:2: rule__ServiceClient__Group__3__Impl rule__ServiceClient__Group__4 + { + pushFollow(FOLLOW_20); + rule__ServiceClient__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__3" + + + // $ANTLR start "rule__ServiceClient__Group__3__Impl" + // InternalRos2Parser.g:5149:1: rule__ServiceClient__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceClient__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5153:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:5154:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:5154:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:5155:2: RULE_BEGIN + { + before(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__3__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__4" + // InternalRos2Parser.g:5164:1: rule__ServiceClient__Group__4 : rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 ; + public final void rule__ServiceClient__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5168:1: ( rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 ) + // InternalRos2Parser.g:5169:2: rule__ServiceClient__Group__4__Impl rule__ServiceClient__Group__5 + { + pushFollow(FOLLOW_7); + rule__ServiceClient__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__4" + + + // $ANTLR start "rule__ServiceClient__Group__4__Impl" + // InternalRos2Parser.g:5176:1: rule__ServiceClient__Group__4__Impl : ( Type_1 ) ; + public final void rule__ServiceClient__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5180:1: ( ( Type_1 ) ) + // InternalRos2Parser.g:5181:1: ( Type_1 ) + { + // InternalRos2Parser.g:5181:1: ( Type_1 ) + // InternalRos2Parser.g:5182:2: Type_1 + { + before(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getTypeKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__4__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__5" + // InternalRos2Parser.g:5191:1: rule__ServiceClient__Group__5 : rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 ; + public final void rule__ServiceClient__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5195:1: ( rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 ) + // InternalRos2Parser.g:5196:2: rule__ServiceClient__Group__5__Impl rule__ServiceClient__Group__6 + { + pushFollow(FOLLOW_21); + rule__ServiceClient__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__5" + + + // $ANTLR start "rule__ServiceClient__Group__5__Impl" + // InternalRos2Parser.g:5203:1: rule__ServiceClient__Group__5__Impl : ( ( rule__ServiceClient__ServiceAssignment_5 ) ) ; + public final void rule__ServiceClient__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5207:1: ( ( ( rule__ServiceClient__ServiceAssignment_5 ) ) ) + // InternalRos2Parser.g:5208:1: ( ( rule__ServiceClient__ServiceAssignment_5 ) ) + { + // InternalRos2Parser.g:5208:1: ( ( rule__ServiceClient__ServiceAssignment_5 ) ) + // InternalRos2Parser.g:5209:2: ( rule__ServiceClient__ServiceAssignment_5 ) + { + before(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); + // InternalRos2Parser.g:5210:2: ( rule__ServiceClient__ServiceAssignment_5 ) + // InternalRos2Parser.g:5210:3: rule__ServiceClient__ServiceAssignment_5 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__ServiceAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceClientAccess().getServiceAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__5__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__6" + // InternalRos2Parser.g:5218:1: rule__ServiceClient__Group__6 : rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 ; + public final void rule__ServiceClient__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5222:1: ( rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 ) + // InternalRos2Parser.g:5223:2: rule__ServiceClient__Group__6__Impl rule__ServiceClient__Group__7 + { + pushFollow(FOLLOW_21); + rule__ServiceClient__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__6" + + + // $ANTLR start "rule__ServiceClient__Group__6__Impl" + // InternalRos2Parser.g:5230:1: rule__ServiceClient__Group__6__Impl : ( ( rule__ServiceClient__Group_6__0 )? ) ; + public final void rule__ServiceClient__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5234:1: ( ( ( rule__ServiceClient__Group_6__0 )? ) ) + // InternalRos2Parser.g:5235:1: ( ( rule__ServiceClient__Group_6__0 )? ) + { + // InternalRos2Parser.g:5235:1: ( ( rule__ServiceClient__Group_6__0 )? ) + // InternalRos2Parser.g:5236:2: ( rule__ServiceClient__Group_6__0 )? + { + before(grammarAccess.getServiceClientAccess().getGroup_6()); + // InternalRos2Parser.g:5237:2: ( rule__ServiceClient__Group_6__0 )? + int alt28=2; + int LA28_0 = input.LA(1); + + if ( (LA28_0==Ns) ) { + alt28=1; + } + switch (alt28) { + case 1 : + // InternalRos2Parser.g:5237:3: rule__ServiceClient__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceClientAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__6__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__7" + // InternalRos2Parser.g:5245:1: rule__ServiceClient__Group__7 : rule__ServiceClient__Group__7__Impl rule__ServiceClient__Group__8 ; + public final void rule__ServiceClient__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5249:1: ( rule__ServiceClient__Group__7__Impl rule__ServiceClient__Group__8 ) + // InternalRos2Parser.g:5250:2: rule__ServiceClient__Group__7__Impl rule__ServiceClient__Group__8 + { + pushFollow(FOLLOW_21); + rule__ServiceClient__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__7" + + + // $ANTLR start "rule__ServiceClient__Group__7__Impl" + // InternalRos2Parser.g:5257:1: rule__ServiceClient__Group__7__Impl : ( ( rule__ServiceClient__Group_7__0 )? ) ; + public final void rule__ServiceClient__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5261:1: ( ( ( rule__ServiceClient__Group_7__0 )? ) ) + // InternalRos2Parser.g:5262:1: ( ( rule__ServiceClient__Group_7__0 )? ) + { + // InternalRos2Parser.g:5262:1: ( ( rule__ServiceClient__Group_7__0 )? ) + // InternalRos2Parser.g:5263:2: ( rule__ServiceClient__Group_7__0 )? + { + before(grammarAccess.getServiceClientAccess().getGroup_7()); + // InternalRos2Parser.g:5264:2: ( rule__ServiceClient__Group_7__0 )? + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0==Qos) ) { + alt29=1; + } + switch (alt29) { + case 1 : + // InternalRos2Parser.g:5264:3: rule__ServiceClient__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceClientAccess().getGroup_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__7__Impl" + + + // $ANTLR start "rule__ServiceClient__Group__8" + // InternalRos2Parser.g:5272:1: rule__ServiceClient__Group__8 : rule__ServiceClient__Group__8__Impl ; + public final void rule__ServiceClient__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5276:1: ( rule__ServiceClient__Group__8__Impl ) + // InternalRos2Parser.g:5277:2: rule__ServiceClient__Group__8__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceClient__Group__8__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__8" + + + // $ANTLR start "rule__ServiceClient__Group__8__Impl" + // InternalRos2Parser.g:5283:1: rule__ServiceClient__Group__8__Impl : ( RULE_END ) ; + public final void rule__ServiceClient__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5287:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:5288:1: ( RULE_END ) + { + // InternalRos2Parser.g:5288:1: ( RULE_END ) + // InternalRos2Parser.g:5289:2: RULE_END + { + before(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_8()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group__8__Impl" + + + // $ANTLR start "rule__ServiceClient__Group_6__0" + // InternalRos2Parser.g:5299:1: rule__ServiceClient__Group_6__0 : rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 ; + public final void rule__ServiceClient__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5303:1: ( rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 ) + // InternalRos2Parser.g:5304:2: rule__ServiceClient__Group_6__0__Impl rule__ServiceClient__Group_6__1 + { + pushFollow(FOLLOW_22); + rule__ServiceClient__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_6__0" + + + // $ANTLR start "rule__ServiceClient__Group_6__0__Impl" + // InternalRos2Parser.g:5311:1: rule__ServiceClient__Group_6__0__Impl : ( Ns ) ; + public final void rule__ServiceClient__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5315:1: ( ( Ns ) ) + // InternalRos2Parser.g:5316:1: ( Ns ) + { + // InternalRos2Parser.g:5316:1: ( Ns ) + // InternalRos2Parser.g:5317:2: Ns + { + before(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_6__0__Impl" + + + // $ANTLR start "rule__ServiceClient__Group_6__1" + // InternalRos2Parser.g:5326:1: rule__ServiceClient__Group_6__1 : rule__ServiceClient__Group_6__1__Impl ; + public final void rule__ServiceClient__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5330:1: ( rule__ServiceClient__Group_6__1__Impl ) + // InternalRos2Parser.g:5331:2: rule__ServiceClient__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceClient__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_6__1" + + + // $ANTLR start "rule__ServiceClient__Group_6__1__Impl" + // InternalRos2Parser.g:5337:1: rule__ServiceClient__Group_6__1__Impl : ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) ; + public final void rule__ServiceClient__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5341:1: ( ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) ) + // InternalRos2Parser.g:5342:1: ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) + { + // InternalRos2Parser.g:5342:1: ( ( rule__ServiceClient__NamespaceAssignment_6_1 ) ) + // InternalRos2Parser.g:5343:2: ( rule__ServiceClient__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); + // InternalRos2Parser.g:5344:2: ( rule__ServiceClient__NamespaceAssignment_6_1 ) + // InternalRos2Parser.g:5344:3: rule__ServiceClient__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceClientAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_6__1__Impl" + + + // $ANTLR start "rule__ServiceClient__Group_7__0" + // InternalRos2Parser.g:5353:1: rule__ServiceClient__Group_7__0 : rule__ServiceClient__Group_7__0__Impl rule__ServiceClient__Group_7__1 ; + public final void rule__ServiceClient__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5357:1: ( rule__ServiceClient__Group_7__0__Impl rule__ServiceClient__Group_7__1 ) + // InternalRos2Parser.g:5358:2: rule__ServiceClient__Group_7__0__Impl rule__ServiceClient__Group_7__1 + { + pushFollow(FOLLOW_14); + rule__ServiceClient__Group_7__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceClient__Group_7__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_7__0" + + + // $ANTLR start "rule__ServiceClient__Group_7__0__Impl" + // InternalRos2Parser.g:5365:1: rule__ServiceClient__Group_7__0__Impl : ( Qos ) ; + public final void rule__ServiceClient__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5369:1: ( ( Qos ) ) + // InternalRos2Parser.g:5370:1: ( Qos ) + { + // InternalRos2Parser.g:5370:1: ( Qos ) + // InternalRos2Parser.g:5371:2: Qos + { + before(grammarAccess.getServiceClientAccess().getQosKeyword_7_0()); + match(input,Qos,FOLLOW_2); + after(grammarAccess.getServiceClientAccess().getQosKeyword_7_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_7__0__Impl" + + + // $ANTLR start "rule__ServiceClient__Group_7__1" + // InternalRos2Parser.g:5380:1: rule__ServiceClient__Group_7__1 : rule__ServiceClient__Group_7__1__Impl ; + public final void rule__ServiceClient__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5384:1: ( rule__ServiceClient__Group_7__1__Impl ) + // InternalRos2Parser.g:5385:2: rule__ServiceClient__Group_7__1__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceClient__Group_7__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_7__1" + + + // $ANTLR start "rule__ServiceClient__Group_7__1__Impl" + // InternalRos2Parser.g:5391:1: rule__ServiceClient__Group_7__1__Impl : ( ( rule__ServiceClient__QosAssignment_7_1 ) ) ; + public final void rule__ServiceClient__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5395:1: ( ( ( rule__ServiceClient__QosAssignment_7_1 ) ) ) + // InternalRos2Parser.g:5396:1: ( ( rule__ServiceClient__QosAssignment_7_1 ) ) + { + // InternalRos2Parser.g:5396:1: ( ( rule__ServiceClient__QosAssignment_7_1 ) ) + // InternalRos2Parser.g:5397:2: ( rule__ServiceClient__QosAssignment_7_1 ) + { + before(grammarAccess.getServiceClientAccess().getQosAssignment_7_1()); + // InternalRos2Parser.g:5398:2: ( rule__ServiceClient__QosAssignment_7_1 ) + // InternalRos2Parser.g:5398:3: rule__ServiceClient__QosAssignment_7_1 + { + pushFollow(FOLLOW_2); + rule__ServiceClient__QosAssignment_7_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceClientAccess().getQosAssignment_7_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__Group_7__1__Impl" + + + // $ANTLR start "rule__ActionServer__Group__0" + // InternalRos2Parser.g:5407:1: rule__ActionServer__Group__0 : rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 ; + public final void rule__ActionServer__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5411:1: ( rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 ) + // InternalRos2Parser.g:5412:2: rule__ActionServer__Group__0__Impl rule__ActionServer__Group__1 + { + pushFollow(FOLLOW_7); + rule__ActionServer__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__0" + + + // $ANTLR start "rule__ActionServer__Group__0__Impl" + // InternalRos2Parser.g:5419:1: rule__ActionServer__Group__0__Impl : ( () ) ; + public final void rule__ActionServer__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5423:1: ( ( () ) ) + // InternalRos2Parser.g:5424:1: ( () ) + { + // InternalRos2Parser.g:5424:1: ( () ) + // InternalRos2Parser.g:5425:2: () + { + before(grammarAccess.getActionServerAccess().getActionServerAction_0()); + // InternalRos2Parser.g:5426:2: () + // InternalRos2Parser.g:5426:3: + { + } + + after(grammarAccess.getActionServerAccess().getActionServerAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__0__Impl" + + + // $ANTLR start "rule__ActionServer__Group__1" + // InternalRos2Parser.g:5434:1: rule__ActionServer__Group__1 : rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 ; + public final void rule__ActionServer__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5438:1: ( rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 ) + // InternalRos2Parser.g:5439:2: rule__ActionServer__Group__1__Impl rule__ActionServer__Group__2 + { + pushFollow(FOLLOW_4); + rule__ActionServer__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__1" + + + // $ANTLR start "rule__ActionServer__Group__1__Impl" + // InternalRos2Parser.g:5446:1: rule__ActionServer__Group__1__Impl : ( ( rule__ActionServer__NameAssignment_1 ) ) ; + public final void rule__ActionServer__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5450:1: ( ( ( rule__ActionServer__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:5451:1: ( ( rule__ActionServer__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:5451:1: ( ( rule__ActionServer__NameAssignment_1 ) ) + // InternalRos2Parser.g:5452:2: ( rule__ActionServer__NameAssignment_1 ) + { + before(grammarAccess.getActionServerAccess().getNameAssignment_1()); + // InternalRos2Parser.g:5453:2: ( rule__ActionServer__NameAssignment_1 ) + // InternalRos2Parser.g:5453:3: rule__ActionServer__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ActionServer__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionServerAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__1__Impl" + + + // $ANTLR start "rule__ActionServer__Group__2" + // InternalRos2Parser.g:5461:1: rule__ActionServer__Group__2 : rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 ; + public final void rule__ActionServer__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5465:1: ( rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 ) + // InternalRos2Parser.g:5466:2: rule__ActionServer__Group__2__Impl rule__ActionServer__Group__3 + { + pushFollow(FOLLOW_5); + rule__ActionServer__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__2" + + + // $ANTLR start "rule__ActionServer__Group__2__Impl" + // InternalRos2Parser.g:5473:1: rule__ActionServer__Group__2__Impl : ( Colon ) ; + public final void rule__ActionServer__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5477:1: ( ( Colon ) ) + // InternalRos2Parser.g:5478:1: ( Colon ) + { + // InternalRos2Parser.g:5478:1: ( Colon ) + // InternalRos2Parser.g:5479:2: Colon + { + before(grammarAccess.getActionServerAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__2__Impl" + + + // $ANTLR start "rule__ActionServer__Group__3" + // InternalRos2Parser.g:5488:1: rule__ActionServer__Group__3 : rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 ; + public final void rule__ActionServer__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5492:1: ( rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 ) + // InternalRos2Parser.g:5493:2: rule__ActionServer__Group__3__Impl rule__ActionServer__Group__4 + { + pushFollow(FOLLOW_20); + rule__ActionServer__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__3" + + + // $ANTLR start "rule__ActionServer__Group__3__Impl" + // InternalRos2Parser.g:5500:1: rule__ActionServer__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionServer__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5504:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:5505:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:5505:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:5506:2: RULE_BEGIN + { + before(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__3__Impl" + + + // $ANTLR start "rule__ActionServer__Group__4" + // InternalRos2Parser.g:5515:1: rule__ActionServer__Group__4 : rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 ; + public final void rule__ActionServer__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5519:1: ( rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 ) + // InternalRos2Parser.g:5520:2: rule__ActionServer__Group__4__Impl rule__ActionServer__Group__5 + { + pushFollow(FOLLOW_7); + rule__ActionServer__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__4" + + + // $ANTLR start "rule__ActionServer__Group__4__Impl" + // InternalRos2Parser.g:5527:1: rule__ActionServer__Group__4__Impl : ( Type_1 ) ; + public final void rule__ActionServer__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5531:1: ( ( Type_1 ) ) + // InternalRos2Parser.g:5532:1: ( Type_1 ) + { + // InternalRos2Parser.g:5532:1: ( Type_1 ) + // InternalRos2Parser.g:5533:2: Type_1 + { + before(grammarAccess.getActionServerAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getTypeKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__4__Impl" + + + // $ANTLR start "rule__ActionServer__Group__5" + // InternalRos2Parser.g:5542:1: rule__ActionServer__Group__5 : rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 ; + public final void rule__ActionServer__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5546:1: ( rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 ) + // InternalRos2Parser.g:5547:2: rule__ActionServer__Group__5__Impl rule__ActionServer__Group__6 + { + pushFollow(FOLLOW_21); + rule__ActionServer__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__5" + + + // $ANTLR start "rule__ActionServer__Group__5__Impl" + // InternalRos2Parser.g:5554:1: rule__ActionServer__Group__5__Impl : ( ( rule__ActionServer__ActionAssignment_5 ) ) ; + public final void rule__ActionServer__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5558:1: ( ( ( rule__ActionServer__ActionAssignment_5 ) ) ) + // InternalRos2Parser.g:5559:1: ( ( rule__ActionServer__ActionAssignment_5 ) ) + { + // InternalRos2Parser.g:5559:1: ( ( rule__ActionServer__ActionAssignment_5 ) ) + // InternalRos2Parser.g:5560:2: ( rule__ActionServer__ActionAssignment_5 ) + { + before(grammarAccess.getActionServerAccess().getActionAssignment_5()); + // InternalRos2Parser.g:5561:2: ( rule__ActionServer__ActionAssignment_5 ) + // InternalRos2Parser.g:5561:3: rule__ActionServer__ActionAssignment_5 + { + pushFollow(FOLLOW_2); + rule__ActionServer__ActionAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getActionServerAccess().getActionAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__5__Impl" + + + // $ANTLR start "rule__ActionServer__Group__6" + // InternalRos2Parser.g:5569:1: rule__ActionServer__Group__6 : rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 ; + public final void rule__ActionServer__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5573:1: ( rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 ) + // InternalRos2Parser.g:5574:2: rule__ActionServer__Group__6__Impl rule__ActionServer__Group__7 + { + pushFollow(FOLLOW_21); + rule__ActionServer__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__6" + + + // $ANTLR start "rule__ActionServer__Group__6__Impl" + // InternalRos2Parser.g:5581:1: rule__ActionServer__Group__6__Impl : ( ( rule__ActionServer__Group_6__0 )? ) ; + public final void rule__ActionServer__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5585:1: ( ( ( rule__ActionServer__Group_6__0 )? ) ) + // InternalRos2Parser.g:5586:1: ( ( rule__ActionServer__Group_6__0 )? ) + { + // InternalRos2Parser.g:5586:1: ( ( rule__ActionServer__Group_6__0 )? ) + // InternalRos2Parser.g:5587:2: ( rule__ActionServer__Group_6__0 )? + { + before(grammarAccess.getActionServerAccess().getGroup_6()); + // InternalRos2Parser.g:5588:2: ( rule__ActionServer__Group_6__0 )? + int alt30=2; + int LA30_0 = input.LA(1); + + if ( (LA30_0==Ns) ) { + alt30=1; + } + switch (alt30) { + case 1 : + // InternalRos2Parser.g:5588:3: rule__ActionServer__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__ActionServer__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionServerAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__6__Impl" + + + // $ANTLR start "rule__ActionServer__Group__7" + // InternalRos2Parser.g:5596:1: rule__ActionServer__Group__7 : rule__ActionServer__Group__7__Impl rule__ActionServer__Group__8 ; + public final void rule__ActionServer__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5600:1: ( rule__ActionServer__Group__7__Impl rule__ActionServer__Group__8 ) + // InternalRos2Parser.g:5601:2: rule__ActionServer__Group__7__Impl rule__ActionServer__Group__8 + { + pushFollow(FOLLOW_21); + rule__ActionServer__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__7" + + + // $ANTLR start "rule__ActionServer__Group__7__Impl" + // InternalRos2Parser.g:5608:1: rule__ActionServer__Group__7__Impl : ( ( rule__ActionServer__Group_7__0 )? ) ; + public final void rule__ActionServer__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5612:1: ( ( ( rule__ActionServer__Group_7__0 )? ) ) + // InternalRos2Parser.g:5613:1: ( ( rule__ActionServer__Group_7__0 )? ) + { + // InternalRos2Parser.g:5613:1: ( ( rule__ActionServer__Group_7__0 )? ) + // InternalRos2Parser.g:5614:2: ( rule__ActionServer__Group_7__0 )? + { + before(grammarAccess.getActionServerAccess().getGroup_7()); + // InternalRos2Parser.g:5615:2: ( rule__ActionServer__Group_7__0 )? + int alt31=2; + int LA31_0 = input.LA(1); + + if ( (LA31_0==Qos) ) { + alt31=1; + } + switch (alt31) { + case 1 : + // InternalRos2Parser.g:5615:3: rule__ActionServer__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__ActionServer__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionServerAccess().getGroup_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__7__Impl" + + + // $ANTLR start "rule__ActionServer__Group__8" + // InternalRos2Parser.g:5623:1: rule__ActionServer__Group__8 : rule__ActionServer__Group__8__Impl ; + public final void rule__ActionServer__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5627:1: ( rule__ActionServer__Group__8__Impl ) + // InternalRos2Parser.g:5628:2: rule__ActionServer__Group__8__Impl + { + pushFollow(FOLLOW_2); + rule__ActionServer__Group__8__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__8" + + + // $ANTLR start "rule__ActionServer__Group__8__Impl" + // InternalRos2Parser.g:5634:1: rule__ActionServer__Group__8__Impl : ( RULE_END ) ; + public final void rule__ActionServer__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5638:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:5639:1: ( RULE_END ) + { + // InternalRos2Parser.g:5639:1: ( RULE_END ) + // InternalRos2Parser.g:5640:2: RULE_END + { + before(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_8()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getENDTerminalRuleCall_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group__8__Impl" + + + // $ANTLR start "rule__ActionServer__Group_6__0" + // InternalRos2Parser.g:5650:1: rule__ActionServer__Group_6__0 : rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 ; + public final void rule__ActionServer__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5654:1: ( rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 ) + // InternalRos2Parser.g:5655:2: rule__ActionServer__Group_6__0__Impl rule__ActionServer__Group_6__1 + { + pushFollow(FOLLOW_22); + rule__ActionServer__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_6__0" + + + // $ANTLR start "rule__ActionServer__Group_6__0__Impl" + // InternalRos2Parser.g:5662:1: rule__ActionServer__Group_6__0__Impl : ( Ns ) ; + public final void rule__ActionServer__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5666:1: ( ( Ns ) ) + // InternalRos2Parser.g:5667:1: ( Ns ) + { + // InternalRos2Parser.g:5667:1: ( Ns ) + // InternalRos2Parser.g:5668:2: Ns + { + before(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_6__0__Impl" + + + // $ANTLR start "rule__ActionServer__Group_6__1" + // InternalRos2Parser.g:5677:1: rule__ActionServer__Group_6__1 : rule__ActionServer__Group_6__1__Impl ; + public final void rule__ActionServer__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5681:1: ( rule__ActionServer__Group_6__1__Impl ) + // InternalRos2Parser.g:5682:2: rule__ActionServer__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__ActionServer__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_6__1" + + + // $ANTLR start "rule__ActionServer__Group_6__1__Impl" + // InternalRos2Parser.g:5688:1: rule__ActionServer__Group_6__1__Impl : ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) ; + public final void rule__ActionServer__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5692:1: ( ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) ) + // InternalRos2Parser.g:5693:1: ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) + { + // InternalRos2Parser.g:5693:1: ( ( rule__ActionServer__NamespaceAssignment_6_1 ) ) + // InternalRos2Parser.g:5694:2: ( rule__ActionServer__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); + // InternalRos2Parser.g:5695:2: ( rule__ActionServer__NamespaceAssignment_6_1 ) + // InternalRos2Parser.g:5695:3: rule__ActionServer__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__ActionServer__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionServerAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_6__1__Impl" + + + // $ANTLR start "rule__ActionServer__Group_7__0" + // InternalRos2Parser.g:5704:1: rule__ActionServer__Group_7__0 : rule__ActionServer__Group_7__0__Impl rule__ActionServer__Group_7__1 ; + public final void rule__ActionServer__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5708:1: ( rule__ActionServer__Group_7__0__Impl rule__ActionServer__Group_7__1 ) + // InternalRos2Parser.g:5709:2: rule__ActionServer__Group_7__0__Impl rule__ActionServer__Group_7__1 + { + pushFollow(FOLLOW_14); + rule__ActionServer__Group_7__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionServer__Group_7__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_7__0" + + + // $ANTLR start "rule__ActionServer__Group_7__0__Impl" + // InternalRos2Parser.g:5716:1: rule__ActionServer__Group_7__0__Impl : ( Qos ) ; + public final void rule__ActionServer__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5720:1: ( ( Qos ) ) + // InternalRos2Parser.g:5721:1: ( Qos ) + { + // InternalRos2Parser.g:5721:1: ( Qos ) + // InternalRos2Parser.g:5722:2: Qos + { + before(grammarAccess.getActionServerAccess().getQosKeyword_7_0()); + match(input,Qos,FOLLOW_2); + after(grammarAccess.getActionServerAccess().getQosKeyword_7_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_7__0__Impl" + + + // $ANTLR start "rule__ActionServer__Group_7__1" + // InternalRos2Parser.g:5731:1: rule__ActionServer__Group_7__1 : rule__ActionServer__Group_7__1__Impl ; + public final void rule__ActionServer__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5735:1: ( rule__ActionServer__Group_7__1__Impl ) + // InternalRos2Parser.g:5736:2: rule__ActionServer__Group_7__1__Impl + { + pushFollow(FOLLOW_2); + rule__ActionServer__Group_7__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_7__1" + + + // $ANTLR start "rule__ActionServer__Group_7__1__Impl" + // InternalRos2Parser.g:5742:1: rule__ActionServer__Group_7__1__Impl : ( ( rule__ActionServer__QosAssignment_7_1 ) ) ; + public final void rule__ActionServer__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5746:1: ( ( ( rule__ActionServer__QosAssignment_7_1 ) ) ) + // InternalRos2Parser.g:5747:1: ( ( rule__ActionServer__QosAssignment_7_1 ) ) + { + // InternalRos2Parser.g:5747:1: ( ( rule__ActionServer__QosAssignment_7_1 ) ) + // InternalRos2Parser.g:5748:2: ( rule__ActionServer__QosAssignment_7_1 ) + { + before(grammarAccess.getActionServerAccess().getQosAssignment_7_1()); + // InternalRos2Parser.g:5749:2: ( rule__ActionServer__QosAssignment_7_1 ) + // InternalRos2Parser.g:5749:3: rule__ActionServer__QosAssignment_7_1 + { + pushFollow(FOLLOW_2); + rule__ActionServer__QosAssignment_7_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionServerAccess().getQosAssignment_7_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__Group_7__1__Impl" + + + // $ANTLR start "rule__ActionClient__Group__0" + // InternalRos2Parser.g:5758:1: rule__ActionClient__Group__0 : rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 ; + public final void rule__ActionClient__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5762:1: ( rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 ) + // InternalRos2Parser.g:5763:2: rule__ActionClient__Group__0__Impl rule__ActionClient__Group__1 + { + pushFollow(FOLLOW_7); + rule__ActionClient__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__0" + + + // $ANTLR start "rule__ActionClient__Group__0__Impl" + // InternalRos2Parser.g:5770:1: rule__ActionClient__Group__0__Impl : ( () ) ; + public final void rule__ActionClient__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5774:1: ( ( () ) ) + // InternalRos2Parser.g:5775:1: ( () ) + { + // InternalRos2Parser.g:5775:1: ( () ) + // InternalRos2Parser.g:5776:2: () + { + before(grammarAccess.getActionClientAccess().getActionClientAction_0()); + // InternalRos2Parser.g:5777:2: () + // InternalRos2Parser.g:5777:3: + { + } + + after(grammarAccess.getActionClientAccess().getActionClientAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__0__Impl" + + + // $ANTLR start "rule__ActionClient__Group__1" + // InternalRos2Parser.g:5785:1: rule__ActionClient__Group__1 : rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 ; + public final void rule__ActionClient__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5789:1: ( rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 ) + // InternalRos2Parser.g:5790:2: rule__ActionClient__Group__1__Impl rule__ActionClient__Group__2 + { + pushFollow(FOLLOW_4); + rule__ActionClient__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__1" + + + // $ANTLR start "rule__ActionClient__Group__1__Impl" + // InternalRos2Parser.g:5797:1: rule__ActionClient__Group__1__Impl : ( ( rule__ActionClient__NameAssignment_1 ) ) ; + public final void rule__ActionClient__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5801:1: ( ( ( rule__ActionClient__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:5802:1: ( ( rule__ActionClient__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:5802:1: ( ( rule__ActionClient__NameAssignment_1 ) ) + // InternalRos2Parser.g:5803:2: ( rule__ActionClient__NameAssignment_1 ) + { + before(grammarAccess.getActionClientAccess().getNameAssignment_1()); + // InternalRos2Parser.g:5804:2: ( rule__ActionClient__NameAssignment_1 ) + // InternalRos2Parser.g:5804:3: rule__ActionClient__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ActionClient__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionClientAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__1__Impl" + + + // $ANTLR start "rule__ActionClient__Group__2" + // InternalRos2Parser.g:5812:1: rule__ActionClient__Group__2 : rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 ; + public final void rule__ActionClient__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5816:1: ( rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 ) + // InternalRos2Parser.g:5817:2: rule__ActionClient__Group__2__Impl rule__ActionClient__Group__3 + { + pushFollow(FOLLOW_5); + rule__ActionClient__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__2" + + + // $ANTLR start "rule__ActionClient__Group__2__Impl" + // InternalRos2Parser.g:5824:1: rule__ActionClient__Group__2__Impl : ( Colon ) ; + public final void rule__ActionClient__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5828:1: ( ( Colon ) ) + // InternalRos2Parser.g:5829:1: ( Colon ) + { + // InternalRos2Parser.g:5829:1: ( Colon ) + // InternalRos2Parser.g:5830:2: Colon + { + before(grammarAccess.getActionClientAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__2__Impl" + + + // $ANTLR start "rule__ActionClient__Group__3" + // InternalRos2Parser.g:5839:1: rule__ActionClient__Group__3 : rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 ; + public final void rule__ActionClient__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5843:1: ( rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 ) + // InternalRos2Parser.g:5844:2: rule__ActionClient__Group__3__Impl rule__ActionClient__Group__4 + { + pushFollow(FOLLOW_20); + rule__ActionClient__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__3" + + + // $ANTLR start "rule__ActionClient__Group__3__Impl" + // InternalRos2Parser.g:5851:1: rule__ActionClient__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionClient__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5855:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:5856:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:5856:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:5857:2: RULE_BEGIN + { + before(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__3__Impl" + + + // $ANTLR start "rule__ActionClient__Group__4" + // InternalRos2Parser.g:5866:1: rule__ActionClient__Group__4 : rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 ; + public final void rule__ActionClient__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5870:1: ( rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 ) + // InternalRos2Parser.g:5871:2: rule__ActionClient__Group__4__Impl rule__ActionClient__Group__5 + { + pushFollow(FOLLOW_7); + rule__ActionClient__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__4" + + + // $ANTLR start "rule__ActionClient__Group__4__Impl" + // InternalRos2Parser.g:5878:1: rule__ActionClient__Group__4__Impl : ( Type_1 ) ; + public final void rule__ActionClient__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5882:1: ( ( Type_1 ) ) + // InternalRos2Parser.g:5883:1: ( Type_1 ) + { + // InternalRos2Parser.g:5883:1: ( Type_1 ) + // InternalRos2Parser.g:5884:2: Type_1 + { + before(grammarAccess.getActionClientAccess().getTypeKeyword_4()); + match(input,Type_1,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getTypeKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__4__Impl" + + + // $ANTLR start "rule__ActionClient__Group__5" + // InternalRos2Parser.g:5893:1: rule__ActionClient__Group__5 : rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 ; + public final void rule__ActionClient__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5897:1: ( rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 ) + // InternalRos2Parser.g:5898:2: rule__ActionClient__Group__5__Impl rule__ActionClient__Group__6 + { + pushFollow(FOLLOW_21); + rule__ActionClient__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__5" + + + // $ANTLR start "rule__ActionClient__Group__5__Impl" + // InternalRos2Parser.g:5905:1: rule__ActionClient__Group__5__Impl : ( ( rule__ActionClient__ActionAssignment_5 ) ) ; + public final void rule__ActionClient__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5909:1: ( ( ( rule__ActionClient__ActionAssignment_5 ) ) ) + // InternalRos2Parser.g:5910:1: ( ( rule__ActionClient__ActionAssignment_5 ) ) + { + // InternalRos2Parser.g:5910:1: ( ( rule__ActionClient__ActionAssignment_5 ) ) + // InternalRos2Parser.g:5911:2: ( rule__ActionClient__ActionAssignment_5 ) + { + before(grammarAccess.getActionClientAccess().getActionAssignment_5()); + // InternalRos2Parser.g:5912:2: ( rule__ActionClient__ActionAssignment_5 ) + // InternalRos2Parser.g:5912:3: rule__ActionClient__ActionAssignment_5 + { + pushFollow(FOLLOW_2); + rule__ActionClient__ActionAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getActionClientAccess().getActionAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__5__Impl" + + + // $ANTLR start "rule__ActionClient__Group__6" + // InternalRos2Parser.g:5920:1: rule__ActionClient__Group__6 : rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 ; + public final void rule__ActionClient__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5924:1: ( rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 ) + // InternalRos2Parser.g:5925:2: rule__ActionClient__Group__6__Impl rule__ActionClient__Group__7 + { + pushFollow(FOLLOW_21); + rule__ActionClient__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__6" + + + // $ANTLR start "rule__ActionClient__Group__6__Impl" + // InternalRos2Parser.g:5932:1: rule__ActionClient__Group__6__Impl : ( ( rule__ActionClient__Group_6__0 )? ) ; + public final void rule__ActionClient__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5936:1: ( ( ( rule__ActionClient__Group_6__0 )? ) ) + // InternalRos2Parser.g:5937:1: ( ( rule__ActionClient__Group_6__0 )? ) + { + // InternalRos2Parser.g:5937:1: ( ( rule__ActionClient__Group_6__0 )? ) + // InternalRos2Parser.g:5938:2: ( rule__ActionClient__Group_6__0 )? + { + before(grammarAccess.getActionClientAccess().getGroup_6()); + // InternalRos2Parser.g:5939:2: ( rule__ActionClient__Group_6__0 )? + int alt32=2; + int LA32_0 = input.LA(1); + + if ( (LA32_0==Ns) ) { + alt32=1; + } + switch (alt32) { + case 1 : + // InternalRos2Parser.g:5939:3: rule__ActionClient__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__ActionClient__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionClientAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__6__Impl" + + + // $ANTLR start "rule__ActionClient__Group__7" + // InternalRos2Parser.g:5947:1: rule__ActionClient__Group__7 : rule__ActionClient__Group__7__Impl rule__ActionClient__Group__8 ; + public final void rule__ActionClient__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5951:1: ( rule__ActionClient__Group__7__Impl rule__ActionClient__Group__8 ) + // InternalRos2Parser.g:5952:2: rule__ActionClient__Group__7__Impl rule__ActionClient__Group__8 + { + pushFollow(FOLLOW_21); + rule__ActionClient__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__7" + + + // $ANTLR start "rule__ActionClient__Group__7__Impl" + // InternalRos2Parser.g:5959:1: rule__ActionClient__Group__7__Impl : ( ( rule__ActionClient__Group_7__0 )? ) ; + public final void rule__ActionClient__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5963:1: ( ( ( rule__ActionClient__Group_7__0 )? ) ) + // InternalRos2Parser.g:5964:1: ( ( rule__ActionClient__Group_7__0 )? ) + { + // InternalRos2Parser.g:5964:1: ( ( rule__ActionClient__Group_7__0 )? ) + // InternalRos2Parser.g:5965:2: ( rule__ActionClient__Group_7__0 )? + { + before(grammarAccess.getActionClientAccess().getGroup_7()); + // InternalRos2Parser.g:5966:2: ( rule__ActionClient__Group_7__0 )? + int alt33=2; + int LA33_0 = input.LA(1); + + if ( (LA33_0==Qos) ) { + alt33=1; + } + switch (alt33) { + case 1 : + // InternalRos2Parser.g:5966:3: rule__ActionClient__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__ActionClient__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionClientAccess().getGroup_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__7__Impl" + + + // $ANTLR start "rule__ActionClient__Group__8" + // InternalRos2Parser.g:5974:1: rule__ActionClient__Group__8 : rule__ActionClient__Group__8__Impl ; + public final void rule__ActionClient__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5978:1: ( rule__ActionClient__Group__8__Impl ) + // InternalRos2Parser.g:5979:2: rule__ActionClient__Group__8__Impl + { + pushFollow(FOLLOW_2); + rule__ActionClient__Group__8__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__8" + + + // $ANTLR start "rule__ActionClient__Group__8__Impl" + // InternalRos2Parser.g:5985:1: rule__ActionClient__Group__8__Impl : ( RULE_END ) ; + public final void rule__ActionClient__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:5989:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:5990:1: ( RULE_END ) + { + // InternalRos2Parser.g:5990:1: ( RULE_END ) + // InternalRos2Parser.g:5991:2: RULE_END + { + before(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_8()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getENDTerminalRuleCall_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group__8__Impl" + + + // $ANTLR start "rule__ActionClient__Group_6__0" + // InternalRos2Parser.g:6001:1: rule__ActionClient__Group_6__0 : rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 ; + public final void rule__ActionClient__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6005:1: ( rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 ) + // InternalRos2Parser.g:6006:2: rule__ActionClient__Group_6__0__Impl rule__ActionClient__Group_6__1 + { + pushFollow(FOLLOW_22); + rule__ActionClient__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_6__0" + + + // $ANTLR start "rule__ActionClient__Group_6__0__Impl" + // InternalRos2Parser.g:6013:1: rule__ActionClient__Group_6__0__Impl : ( Ns ) ; + public final void rule__ActionClient__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6017:1: ( ( Ns ) ) + // InternalRos2Parser.g:6018:1: ( Ns ) + { + // InternalRos2Parser.g:6018:1: ( Ns ) + // InternalRos2Parser.g:6019:2: Ns + { + before(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_6__0__Impl" + + + // $ANTLR start "rule__ActionClient__Group_6__1" + // InternalRos2Parser.g:6028:1: rule__ActionClient__Group_6__1 : rule__ActionClient__Group_6__1__Impl ; + public final void rule__ActionClient__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6032:1: ( rule__ActionClient__Group_6__1__Impl ) + // InternalRos2Parser.g:6033:2: rule__ActionClient__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__ActionClient__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_6__1" + + + // $ANTLR start "rule__ActionClient__Group_6__1__Impl" + // InternalRos2Parser.g:6039:1: rule__ActionClient__Group_6__1__Impl : ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) ; + public final void rule__ActionClient__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6043:1: ( ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) ) + // InternalRos2Parser.g:6044:1: ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) + { + // InternalRos2Parser.g:6044:1: ( ( rule__ActionClient__NamespaceAssignment_6_1 ) ) + // InternalRos2Parser.g:6045:2: ( rule__ActionClient__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); + // InternalRos2Parser.g:6046:2: ( rule__ActionClient__NamespaceAssignment_6_1 ) + // InternalRos2Parser.g:6046:3: rule__ActionClient__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__ActionClient__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionClientAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_6__1__Impl" + + + // $ANTLR start "rule__ActionClient__Group_7__0" + // InternalRos2Parser.g:6055:1: rule__ActionClient__Group_7__0 : rule__ActionClient__Group_7__0__Impl rule__ActionClient__Group_7__1 ; + public final void rule__ActionClient__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6059:1: ( rule__ActionClient__Group_7__0__Impl rule__ActionClient__Group_7__1 ) + // InternalRos2Parser.g:6060:2: rule__ActionClient__Group_7__0__Impl rule__ActionClient__Group_7__1 + { + pushFollow(FOLLOW_14); + rule__ActionClient__Group_7__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionClient__Group_7__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_7__0" + + + // $ANTLR start "rule__ActionClient__Group_7__0__Impl" + // InternalRos2Parser.g:6067:1: rule__ActionClient__Group_7__0__Impl : ( Qos ) ; + public final void rule__ActionClient__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6071:1: ( ( Qos ) ) + // InternalRos2Parser.g:6072:1: ( Qos ) + { + // InternalRos2Parser.g:6072:1: ( Qos ) + // InternalRos2Parser.g:6073:2: Qos + { + before(grammarAccess.getActionClientAccess().getQosKeyword_7_0()); + match(input,Qos,FOLLOW_2); + after(grammarAccess.getActionClientAccess().getQosKeyword_7_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_7__0__Impl" + + + // $ANTLR start "rule__ActionClient__Group_7__1" + // InternalRos2Parser.g:6082:1: rule__ActionClient__Group_7__1 : rule__ActionClient__Group_7__1__Impl ; + public final void rule__ActionClient__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6086:1: ( rule__ActionClient__Group_7__1__Impl ) + // InternalRos2Parser.g:6087:2: rule__ActionClient__Group_7__1__Impl + { + pushFollow(FOLLOW_2); + rule__ActionClient__Group_7__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_7__1" + + + // $ANTLR start "rule__ActionClient__Group_7__1__Impl" + // InternalRos2Parser.g:6093:1: rule__ActionClient__Group_7__1__Impl : ( ( rule__ActionClient__QosAssignment_7_1 ) ) ; + public final void rule__ActionClient__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6097:1: ( ( ( rule__ActionClient__QosAssignment_7_1 ) ) ) + // InternalRos2Parser.g:6098:1: ( ( rule__ActionClient__QosAssignment_7_1 ) ) + { + // InternalRos2Parser.g:6098:1: ( ( rule__ActionClient__QosAssignment_7_1 ) ) + // InternalRos2Parser.g:6099:2: ( rule__ActionClient__QosAssignment_7_1 ) + { + before(grammarAccess.getActionClientAccess().getQosAssignment_7_1()); + // InternalRos2Parser.g:6100:2: ( rule__ActionClient__QosAssignment_7_1 ) + // InternalRos2Parser.g:6100:3: rule__ActionClient__QosAssignment_7_1 + { + pushFollow(FOLLOW_2); + rule__ActionClient__QosAssignment_7_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionClientAccess().getQosAssignment_7_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__Group_7__1__Impl" + + + // $ANTLR start "rule__Parameter__Group__0" + // InternalRos2Parser.g:6109: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 { + // InternalRos2Parser.g:6113:1: ( rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ) + // InternalRos2Parser.g:6114: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" + // InternalRos2Parser.g:6121:1: rule__Parameter__Group__0__Impl : ( () ) ; + public final void rule__Parameter__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6125:1: ( ( () ) ) + // InternalRos2Parser.g:6126:1: ( () ) + { + // InternalRos2Parser.g:6126:1: ( () ) + // InternalRos2Parser.g:6127:2: () + { + before(grammarAccess.getParameterAccess().getParameterAction_0()); + // InternalRos2Parser.g:6128:2: () + // InternalRos2Parser.g:6128:3: + { + } + + after(grammarAccess.getParameterAccess().getParameterAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__0__Impl" + + + // $ANTLR start "rule__Parameter__Group__1" + // InternalRos2Parser.g:6136: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 { + // InternalRos2Parser.g:6140:1: ( rule__Parameter__Group__1__Impl rule__Parameter__Group__2 ) + // InternalRos2Parser.g:6141: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" + // InternalRos2Parser.g:6148:1: rule__Parameter__Group__1__Impl : ( ( rule__Parameter__NameAssignment_1 ) ) ; + public final void rule__Parameter__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6152:1: ( ( ( rule__Parameter__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:6153:1: ( ( rule__Parameter__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:6153:1: ( ( rule__Parameter__NameAssignment_1 ) ) + // InternalRos2Parser.g:6154:2: ( rule__Parameter__NameAssignment_1 ) + { + before(grammarAccess.getParameterAccess().getNameAssignment_1()); + // InternalRos2Parser.g:6155:2: ( rule__Parameter__NameAssignment_1 ) + // InternalRos2Parser.g:6155: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" + // InternalRos2Parser.g:6163: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 { + // InternalRos2Parser.g:6167:1: ( rule__Parameter__Group__2__Impl rule__Parameter__Group__3 ) + // InternalRos2Parser.g:6168: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" + // InternalRos2Parser.g:6175:1: rule__Parameter__Group__2__Impl : ( Colon ) ; + public final void rule__Parameter__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6179:1: ( ( Colon ) ) + // InternalRos2Parser.g:6180:1: ( Colon ) + { + // InternalRos2Parser.g:6180:1: ( Colon ) + // InternalRos2Parser.g:6181: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" + // InternalRos2Parser.g:6190: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 { + // InternalRos2Parser.g:6194:1: ( rule__Parameter__Group__3__Impl rule__Parameter__Group__4 ) + // InternalRos2Parser.g:6195:2: rule__Parameter__Group__3__Impl rule__Parameter__Group__4 + { + pushFollow(FOLLOW_24); + 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" + // InternalRos2Parser.g:6202:1: rule__Parameter__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Parameter__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6206:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:6207:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:6207:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:6208: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" + // InternalRos2Parser.g:6217: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 { + // InternalRos2Parser.g:6221:1: ( rule__Parameter__Group__4__Impl rule__Parameter__Group__5 ) + // InternalRos2Parser.g:6222:2: rule__Parameter__Group__4__Impl rule__Parameter__Group__5 + { + pushFollow(FOLLOW_25); + 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" + // InternalRos2Parser.g:6229:1: rule__Parameter__Group__4__Impl : ( Type ) ; + public final void rule__Parameter__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6233:1: ( ( Type ) ) + // InternalRos2Parser.g:6234:1: ( Type ) + { + // InternalRos2Parser.g:6234:1: ( Type ) + // InternalRos2Parser.g:6235:2: Type + { + before(grammarAccess.getParameterAccess().getTypeKeyword_4()); + match(input,Type,FOLLOW_2); + after(grammarAccess.getParameterAccess().getTypeKeyword_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" + // InternalRos2Parser.g:6244:1: rule__Parameter__Group__5 : rule__Parameter__Group__5__Impl rule__Parameter__Group__6 ; + public final void rule__Parameter__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6248:1: ( rule__Parameter__Group__5__Impl rule__Parameter__Group__6 ) + // InternalRos2Parser.g:6249:2: rule__Parameter__Group__5__Impl rule__Parameter__Group__6 + { + pushFollow(FOLLOW_21); + rule__Parameter__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__6(); + + 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" + // InternalRos2Parser.g:6256:1: rule__Parameter__Group__5__Impl : ( ( rule__Parameter__TypeAssignment_5 ) ) ; + public final void rule__Parameter__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6260:1: ( ( ( rule__Parameter__TypeAssignment_5 ) ) ) + // InternalRos2Parser.g:6261:1: ( ( rule__Parameter__TypeAssignment_5 ) ) + { + // InternalRos2Parser.g:6261:1: ( ( rule__Parameter__TypeAssignment_5 ) ) + // InternalRos2Parser.g:6262:2: ( rule__Parameter__TypeAssignment_5 ) + { + before(grammarAccess.getParameterAccess().getTypeAssignment_5()); + // InternalRos2Parser.g:6263:2: ( rule__Parameter__TypeAssignment_5 ) + // InternalRos2Parser.g:6263:3: rule__Parameter__TypeAssignment_5 + { + pushFollow(FOLLOW_2); + rule__Parameter__TypeAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAccess().getTypeAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__5__Impl" + + + // $ANTLR start "rule__Parameter__Group__6" + // InternalRos2Parser.g:6271:1: rule__Parameter__Group__6 : rule__Parameter__Group__6__Impl rule__Parameter__Group__7 ; + public final void rule__Parameter__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6275:1: ( rule__Parameter__Group__6__Impl rule__Parameter__Group__7 ) + // InternalRos2Parser.g:6276:2: rule__Parameter__Group__6__Impl rule__Parameter__Group__7 + { + pushFollow(FOLLOW_21); + rule__Parameter__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__6" + + + // $ANTLR start "rule__Parameter__Group__6__Impl" + // InternalRos2Parser.g:6283:1: rule__Parameter__Group__6__Impl : ( ( rule__Parameter__Group_6__0 )? ) ; + public final void rule__Parameter__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6287:1: ( ( ( rule__Parameter__Group_6__0 )? ) ) + // InternalRos2Parser.g:6288:1: ( ( rule__Parameter__Group_6__0 )? ) + { + // InternalRos2Parser.g:6288:1: ( ( rule__Parameter__Group_6__0 )? ) + // InternalRos2Parser.g:6289:2: ( rule__Parameter__Group_6__0 )? + { + before(grammarAccess.getParameterAccess().getGroup_6()); + // InternalRos2Parser.g:6290:2: ( rule__Parameter__Group_6__0 )? + int alt34=2; + int LA34_0 = input.LA(1); + + if ( (LA34_0==Ns) ) { + alt34=1; + } + switch (alt34) { + case 1 : + // InternalRos2Parser.g:6290:3: rule__Parameter__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Parameter__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__6__Impl" + + + // $ANTLR start "rule__Parameter__Group__7" + // InternalRos2Parser.g:6298:1: rule__Parameter__Group__7 : rule__Parameter__Group__7__Impl rule__Parameter__Group__8 ; + public final void rule__Parameter__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6302:1: ( rule__Parameter__Group__7__Impl rule__Parameter__Group__8 ) + // InternalRos2Parser.g:6303:2: rule__Parameter__Group__7__Impl rule__Parameter__Group__8 + { + pushFollow(FOLLOW_21); + rule__Parameter__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__7" + + + // $ANTLR start "rule__Parameter__Group__7__Impl" + // InternalRos2Parser.g:6310:1: rule__Parameter__Group__7__Impl : ( ( rule__Parameter__Group_7__0 )? ) ; + public final void rule__Parameter__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6314:1: ( ( ( rule__Parameter__Group_7__0 )? ) ) + // InternalRos2Parser.g:6315:1: ( ( rule__Parameter__Group_7__0 )? ) + { + // InternalRos2Parser.g:6315:1: ( ( rule__Parameter__Group_7__0 )? ) + // InternalRos2Parser.g:6316:2: ( rule__Parameter__Group_7__0 )? + { + before(grammarAccess.getParameterAccess().getGroup_7()); + // InternalRos2Parser.g:6317:2: ( rule__Parameter__Group_7__0 )? + int alt35=2; + int LA35_0 = input.LA(1); + + if ( (LA35_0==Qos) ) { + alt35=1; + } + switch (alt35) { + case 1 : + // InternalRos2Parser.g:6317:3: rule__Parameter__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__Parameter__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterAccess().getGroup_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__7__Impl" + + + // $ANTLR start "rule__Parameter__Group__8" + // InternalRos2Parser.g:6325:1: rule__Parameter__Group__8 : rule__Parameter__Group__8__Impl rule__Parameter__Group__9 ; + public final void rule__Parameter__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6329:1: ( rule__Parameter__Group__8__Impl rule__Parameter__Group__9 ) + // InternalRos2Parser.g:6330:2: rule__Parameter__Group__8__Impl rule__Parameter__Group__9 + { + pushFollow(FOLLOW_26); + rule__Parameter__Group__8__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__9(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__8" + + + // $ANTLR start "rule__Parameter__Group__8__Impl" + // InternalRos2Parser.g:6337:1: rule__Parameter__Group__8__Impl : ( RULE_END ) ; + public final void rule__Parameter__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6341:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:6342:1: ( RULE_END ) + { + // InternalRos2Parser.g:6342:1: ( RULE_END ) + // InternalRos2Parser.g:6343:2: RULE_END + { + before(grammarAccess.getParameterAccess().getENDTerminalRuleCall_8()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getParameterAccess().getENDTerminalRuleCall_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__8__Impl" + + + // $ANTLR start "rule__Parameter__Group__9" + // InternalRos2Parser.g:6352:1: rule__Parameter__Group__9 : rule__Parameter__Group__9__Impl ; + public final void rule__Parameter__Group__9() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6356:1: ( rule__Parameter__Group__9__Impl ) + // InternalRos2Parser.g:6357:2: rule__Parameter__Group__9__Impl + { + pushFollow(FOLLOW_2); + rule__Parameter__Group__9__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__9" + + + // $ANTLR start "rule__Parameter__Group__9__Impl" + // InternalRos2Parser.g:6363:1: rule__Parameter__Group__9__Impl : ( RightCurlyBracket ) ; + public final void rule__Parameter__Group__9__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6367:1: ( ( RightCurlyBracket ) ) + // InternalRos2Parser.g:6368:1: ( RightCurlyBracket ) + { + // InternalRos2Parser.g:6368:1: ( RightCurlyBracket ) + // InternalRos2Parser.g:6369:2: RightCurlyBracket + { + before(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_9()); + match(input,RightCurlyBracket,FOLLOW_2); + after(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_9()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__9__Impl" + + + // $ANTLR start "rule__Parameter__Group_6__0" + // InternalRos2Parser.g:6379:1: rule__Parameter__Group_6__0 : rule__Parameter__Group_6__0__Impl rule__Parameter__Group_6__1 ; + public final void rule__Parameter__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6383:1: ( rule__Parameter__Group_6__0__Impl rule__Parameter__Group_6__1 ) + // InternalRos2Parser.g:6384:2: rule__Parameter__Group_6__0__Impl rule__Parameter__Group_6__1 + { + pushFollow(FOLLOW_22); + rule__Parameter__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_6__0" + + + // $ANTLR start "rule__Parameter__Group_6__0__Impl" + // InternalRos2Parser.g:6391:1: rule__Parameter__Group_6__0__Impl : ( Ns ) ; + public final void rule__Parameter__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6395:1: ( ( Ns ) ) + // InternalRos2Parser.g:6396:1: ( Ns ) + { + // InternalRos2Parser.g:6396:1: ( Ns ) + // InternalRos2Parser.g:6397:2: Ns + { + before(grammarAccess.getParameterAccess().getNsKeyword_6_0()); + match(input,Ns,FOLLOW_2); + after(grammarAccess.getParameterAccess().getNsKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_6__0__Impl" + + + // $ANTLR start "rule__Parameter__Group_6__1" + // InternalRos2Parser.g:6406:1: rule__Parameter__Group_6__1 : rule__Parameter__Group_6__1__Impl ; + public final void rule__Parameter__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6410:1: ( rule__Parameter__Group_6__1__Impl ) + // InternalRos2Parser.g:6411:2: rule__Parameter__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__Parameter__Group_6__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_6__1" + + + // $ANTLR start "rule__Parameter__Group_6__1__Impl" + // InternalRos2Parser.g:6417:1: rule__Parameter__Group_6__1__Impl : ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) ; + public final void rule__Parameter__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6421:1: ( ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) ) + // InternalRos2Parser.g:6422:1: ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) + { + // InternalRos2Parser.g:6422:1: ( ( rule__Parameter__NamespaceAssignment_6_1 ) ) + // InternalRos2Parser.g:6423:2: ( rule__Parameter__NamespaceAssignment_6_1 ) + { + before(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); + // InternalRos2Parser.g:6424:2: ( rule__Parameter__NamespaceAssignment_6_1 ) + // InternalRos2Parser.g:6424:3: rule__Parameter__NamespaceAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__Parameter__NamespaceAssignment_6_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAccess().getNamespaceAssignment_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_6__1__Impl" + + + // $ANTLR start "rule__Parameter__Group_7__0" + // InternalRos2Parser.g:6433:1: rule__Parameter__Group_7__0 : rule__Parameter__Group_7__0__Impl rule__Parameter__Group_7__1 ; + public final void rule__Parameter__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6437:1: ( rule__Parameter__Group_7__0__Impl rule__Parameter__Group_7__1 ) + // InternalRos2Parser.g:6438:2: rule__Parameter__Group_7__0__Impl rule__Parameter__Group_7__1 + { + pushFollow(FOLLOW_14); + rule__Parameter__Group_7__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group_7__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_7__0" + + + // $ANTLR start "rule__Parameter__Group_7__0__Impl" + // InternalRos2Parser.g:6445:1: rule__Parameter__Group_7__0__Impl : ( Qos ) ; + public final void rule__Parameter__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6449:1: ( ( Qos ) ) + // InternalRos2Parser.g:6450:1: ( Qos ) + { + // InternalRos2Parser.g:6450:1: ( Qos ) + // InternalRos2Parser.g:6451:2: Qos + { + before(grammarAccess.getParameterAccess().getQosKeyword_7_0()); + match(input,Qos,FOLLOW_2); + after(grammarAccess.getParameterAccess().getQosKeyword_7_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_7__0__Impl" + + + // $ANTLR start "rule__Parameter__Group_7__1" + // InternalRos2Parser.g:6460:1: rule__Parameter__Group_7__1 : rule__Parameter__Group_7__1__Impl ; + public final void rule__Parameter__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6464:1: ( rule__Parameter__Group_7__1__Impl ) + // InternalRos2Parser.g:6465:2: rule__Parameter__Group_7__1__Impl + { + pushFollow(FOLLOW_2); + rule__Parameter__Group_7__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_7__1" + + + // $ANTLR start "rule__Parameter__Group_7__1__Impl" + // InternalRos2Parser.g:6471:1: rule__Parameter__Group_7__1__Impl : ( ( rule__Parameter__QosAssignment_7_1 ) ) ; + public final void rule__Parameter__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6475:1: ( ( ( rule__Parameter__QosAssignment_7_1 ) ) ) + // InternalRos2Parser.g:6476:1: ( ( rule__Parameter__QosAssignment_7_1 ) ) + { + // InternalRos2Parser.g:6476:1: ( ( rule__Parameter__QosAssignment_7_1 ) ) + // InternalRos2Parser.g:6477:2: ( rule__Parameter__QosAssignment_7_1 ) + { + before(grammarAccess.getParameterAccess().getQosAssignment_7_1()); + // InternalRos2Parser.g:6478:2: ( rule__Parameter__QosAssignment_7_1 ) + // InternalRos2Parser.g:6478:3: rule__Parameter__QosAssignment_7_1 + { + pushFollow(FOLLOW_2); + rule__Parameter__QosAssignment_7_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAccess().getQosAssignment_7_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group_7__1__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__0" + // InternalRos2Parser.g:6487:1: rule__Package_Impl__Group__0 : rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 ; + public final void rule__Package_Impl__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6491:1: ( rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 ) + // InternalRos2Parser.g:6492:2: rule__Package_Impl__Group__0__Impl rule__Package_Impl__Group__1 + { + pushFollow(FOLLOW_3); + rule__Package_Impl__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__0" + + + // $ANTLR start "rule__Package_Impl__Group__0__Impl" + // InternalRos2Parser.g:6499:1: rule__Package_Impl__Group__0__Impl : ( () ) ; + public final void rule__Package_Impl__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6503:1: ( ( () ) ) + // InternalRos2Parser.g:6504:1: ( () ) + { + // InternalRos2Parser.g:6504:1: ( () ) + // InternalRos2Parser.g:6505:2: () + { + before(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); + // InternalRos2Parser.g:6506:2: () + // InternalRos2Parser.g:6506:3: + { + } + + after(grammarAccess.getPackage_ImplAccess().getPackageAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__0__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__1" + // InternalRos2Parser.g:6514:1: rule__Package_Impl__Group__1 : rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 ; + public final void rule__Package_Impl__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6518:1: ( rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 ) + // InternalRos2Parser.g:6519:2: rule__Package_Impl__Group__1__Impl rule__Package_Impl__Group__2 + { + pushFollow(FOLLOW_4); + rule__Package_Impl__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__1" + + + // $ANTLR start "rule__Package_Impl__Group__1__Impl" + // InternalRos2Parser.g:6526:1: rule__Package_Impl__Group__1__Impl : ( ( rule__Package_Impl__NameAssignment_1 ) ) ; + public final void rule__Package_Impl__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6530:1: ( ( ( rule__Package_Impl__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:6531:1: ( ( rule__Package_Impl__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:6531:1: ( ( rule__Package_Impl__NameAssignment_1 ) ) + // InternalRos2Parser.g:6532:2: ( rule__Package_Impl__NameAssignment_1 ) + { + before(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); + // InternalRos2Parser.g:6533:2: ( rule__Package_Impl__NameAssignment_1 ) + // InternalRos2Parser.g:6533:3: rule__Package_Impl__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__1__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__2" + // InternalRos2Parser.g:6541:1: rule__Package_Impl__Group__2 : rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 ; + public final void rule__Package_Impl__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6545:1: ( rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 ) + // InternalRos2Parser.g:6546:2: rule__Package_Impl__Group__2__Impl rule__Package_Impl__Group__3 + { + pushFollow(FOLLOW_5); + rule__Package_Impl__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__2" + + + // $ANTLR start "rule__Package_Impl__Group__2__Impl" + // InternalRos2Parser.g:6553:1: rule__Package_Impl__Group__2__Impl : ( Colon ) ; + public final void rule__Package_Impl__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6557:1: ( ( Colon ) ) + // InternalRos2Parser.g:6558:1: ( Colon ) + { + // InternalRos2Parser.g:6558:1: ( Colon ) + // InternalRos2Parser.g:6559:2: Colon + { + before(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__2__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__3" + // InternalRos2Parser.g:6568:1: rule__Package_Impl__Group__3 : rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 ; + public final void rule__Package_Impl__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6572:1: ( rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 ) + // InternalRos2Parser.g:6573:2: rule__Package_Impl__Group__3__Impl rule__Package_Impl__Group__4 + { + pushFollow(FOLLOW_27); + rule__Package_Impl__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__3" + + + // $ANTLR start "rule__Package_Impl__Group__3__Impl" + // InternalRos2Parser.g:6580:1: rule__Package_Impl__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Package_Impl__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6584:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:6585:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:6585:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:6586:2: RULE_BEGIN + { + before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__3__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__4" + // InternalRos2Parser.g:6595:1: rule__Package_Impl__Group__4 : rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 ; + public final void rule__Package_Impl__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6599:1: ( rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 ) + // InternalRos2Parser.g:6600:2: rule__Package_Impl__Group__4__Impl rule__Package_Impl__Group__5 + { + pushFollow(FOLLOW_27); + rule__Package_Impl__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__4" + + + // $ANTLR start "rule__Package_Impl__Group__4__Impl" + // InternalRos2Parser.g:6607:1: rule__Package_Impl__Group__4__Impl : ( ( rule__Package_Impl__Group_4__0 )? ) ; + public final void rule__Package_Impl__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6611:1: ( ( ( rule__Package_Impl__Group_4__0 )? ) ) + // InternalRos2Parser.g:6612:1: ( ( rule__Package_Impl__Group_4__0 )? ) + { + // InternalRos2Parser.g:6612:1: ( ( rule__Package_Impl__Group_4__0 )? ) + // InternalRos2Parser.g:6613:2: ( rule__Package_Impl__Group_4__0 )? + { + before(grammarAccess.getPackage_ImplAccess().getGroup_4()); + // InternalRos2Parser.g:6614:2: ( rule__Package_Impl__Group_4__0 )? + int alt36=2; + int LA36_0 = input.LA(1); + + if ( (LA36_0==FromGitRepo) ) { + alt36=1; + } + switch (alt36) { + case 1 : + // InternalRos2Parser.g:6614:3: rule__Package_Impl__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_4__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPackage_ImplAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__4__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__5" + // InternalRos2Parser.g:6622:1: rule__Package_Impl__Group__5 : rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 ; + public final void rule__Package_Impl__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6626:1: ( rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 ) + // InternalRos2Parser.g:6627:2: rule__Package_Impl__Group__5__Impl rule__Package_Impl__Group__6 + { + pushFollow(FOLLOW_27); + rule__Package_Impl__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__5" + + + // $ANTLR start "rule__Package_Impl__Group__5__Impl" + // InternalRos2Parser.g:6634:1: rule__Package_Impl__Group__5__Impl : ( ( rule__Package_Impl__Group_5__0 )? ) ; + public final void rule__Package_Impl__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6638:1: ( ( ( rule__Package_Impl__Group_5__0 )? ) ) + // InternalRos2Parser.g:6639:1: ( ( rule__Package_Impl__Group_5__0 )? ) + { + // InternalRos2Parser.g:6639:1: ( ( rule__Package_Impl__Group_5__0 )? ) + // InternalRos2Parser.g:6640:2: ( rule__Package_Impl__Group_5__0 )? + { + before(grammarAccess.getPackage_ImplAccess().getGroup_5()); + // InternalRos2Parser.g:6641:2: ( rule__Package_Impl__Group_5__0 )? + int alt37=2; + int LA37_0 = input.LA(1); + + if ( (LA37_0==Specs) ) { + alt37=1; + } + switch (alt37) { + case 1 : + // InternalRos2Parser.g:6641:3: rule__Package_Impl__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPackage_ImplAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__5__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__6" + // InternalRos2Parser.g:6649:1: rule__Package_Impl__Group__6 : rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 ; + public final void rule__Package_Impl__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6653:1: ( rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 ) + // InternalRos2Parser.g:6654:2: rule__Package_Impl__Group__6__Impl rule__Package_Impl__Group__7 + { + pushFollow(FOLLOW_27); + rule__Package_Impl__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__6" + + + // $ANTLR start "rule__Package_Impl__Group__6__Impl" + // InternalRos2Parser.g:6661:1: rule__Package_Impl__Group__6__Impl : ( ( rule__Package_Impl__Group_6__0 )? ) ; + public final void rule__Package_Impl__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6665:1: ( ( ( rule__Package_Impl__Group_6__0 )? ) ) + // InternalRos2Parser.g:6666:1: ( ( rule__Package_Impl__Group_6__0 )? ) + { + // InternalRos2Parser.g:6666:1: ( ( rule__Package_Impl__Group_6__0 )? ) + // InternalRos2Parser.g:6667:2: ( rule__Package_Impl__Group_6__0 )? + { + before(grammarAccess.getPackage_ImplAccess().getGroup_6()); + // InternalRos2Parser.g:6668:2: ( rule__Package_Impl__Group_6__0 )? + int alt38=2; + int LA38_0 = input.LA(1); + + if ( (LA38_0==Dependencies) ) { + alt38=1; + } + switch (alt38) { + case 1 : + // InternalRos2Parser.g:6668:3: rule__Package_Impl__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPackage_ImplAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__6__Impl" + + + // $ANTLR start "rule__Package_Impl__Group__7" + // InternalRos2Parser.g:6676:1: rule__Package_Impl__Group__7 : rule__Package_Impl__Group__7__Impl ; + public final void rule__Package_Impl__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6680:1: ( rule__Package_Impl__Group__7__Impl ) + // InternalRos2Parser.g:6681:2: rule__Package_Impl__Group__7__Impl + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group__7__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__7" + + + // $ANTLR start "rule__Package_Impl__Group__7__Impl" + // InternalRos2Parser.g:6687:1: rule__Package_Impl__Group__7__Impl : ( RULE_END ) ; + public final void rule__Package_Impl__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6691:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:6692:1: ( RULE_END ) + { + // InternalRos2Parser.g:6692:1: ( RULE_END ) + // InternalRos2Parser.g:6693:2: RULE_END + { + before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group__7__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_4__0" + // InternalRos2Parser.g:6703:1: rule__Package_Impl__Group_4__0 : rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 ; + public final void rule__Package_Impl__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6707:1: ( rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 ) + // InternalRos2Parser.g:6708:2: rule__Package_Impl__Group_4__0__Impl rule__Package_Impl__Group_4__1 + { + pushFollow(FOLLOW_7); + rule__Package_Impl__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_4__0" + + + // $ANTLR start "rule__Package_Impl__Group_4__0__Impl" + // InternalRos2Parser.g:6715:1: rule__Package_Impl__Group_4__0__Impl : ( FromGitRepo ) ; + public final void rule__Package_Impl__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6719:1: ( ( FromGitRepo ) ) + // InternalRos2Parser.g:6720:1: ( FromGitRepo ) + { + // InternalRos2Parser.g:6720:1: ( FromGitRepo ) + // InternalRos2Parser.g:6721:2: FromGitRepo + { + before(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); + match(input,FromGitRepo,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_4__0__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_4__1" + // InternalRos2Parser.g:6730:1: rule__Package_Impl__Group_4__1 : rule__Package_Impl__Group_4__1__Impl ; + public final void rule__Package_Impl__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6734:1: ( rule__Package_Impl__Group_4__1__Impl ) + // InternalRos2Parser.g:6735:2: rule__Package_Impl__Group_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_4__1" + + + // $ANTLR start "rule__Package_Impl__Group_4__1__Impl" + // InternalRos2Parser.g:6741:1: rule__Package_Impl__Group_4__1__Impl : ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) ; + public final void rule__Package_Impl__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6745:1: ( ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) ) + // InternalRos2Parser.g:6746:1: ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) + { + // InternalRos2Parser.g:6746:1: ( ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) ) + // InternalRos2Parser.g:6747:2: ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) + { + before(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); + // InternalRos2Parser.g:6748:2: ( rule__Package_Impl__FromGitRepoAssignment_4_1 ) + // InternalRos2Parser.g:6748:3: rule__Package_Impl__FromGitRepoAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__FromGitRepoAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getFromGitRepoAssignment_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_4__1__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_5__0" + // InternalRos2Parser.g:6757:1: rule__Package_Impl__Group_5__0 : rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 ; + public final void rule__Package_Impl__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6761:1: ( rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 ) + // InternalRos2Parser.g:6762:2: rule__Package_Impl__Group_5__0__Impl rule__Package_Impl__Group_5__1 + { + pushFollow(FOLLOW_5); + rule__Package_Impl__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__0" + + + // $ANTLR start "rule__Package_Impl__Group_5__0__Impl" + // InternalRos2Parser.g:6769:1: rule__Package_Impl__Group_5__0__Impl : ( Specs ) ; + public final void rule__Package_Impl__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6773:1: ( ( Specs ) ) + // InternalRos2Parser.g:6774:1: ( Specs ) + { + // InternalRos2Parser.g:6774:1: ( Specs ) + // InternalRos2Parser.g:6775:2: Specs + { + before(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + match(input,Specs,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__0__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_5__1" + // InternalRos2Parser.g:6784:1: rule__Package_Impl__Group_5__1 : rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 ; + public final void rule__Package_Impl__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6788:1: ( rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 ) + // InternalRos2Parser.g:6789:2: rule__Package_Impl__Group_5__1__Impl rule__Package_Impl__Group_5__2 + { + pushFollow(FOLLOW_28); + rule__Package_Impl__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__1" + + + // $ANTLR start "rule__Package_Impl__Group_5__1__Impl" + // InternalRos2Parser.g:6796:1: rule__Package_Impl__Group_5__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Package_Impl__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6800:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:6801:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:6801:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:6802:2: RULE_BEGIN + { + before(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__1__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_5__2" + // InternalRos2Parser.g:6811:1: rule__Package_Impl__Group_5__2 : rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 ; + public final void rule__Package_Impl__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6815:1: ( rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 ) + // InternalRos2Parser.g:6816:2: rule__Package_Impl__Group_5__2__Impl rule__Package_Impl__Group_5__3 + { + pushFollow(FOLLOW_28); + rule__Package_Impl__Group_5__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_5__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__2" + + + // $ANTLR start "rule__Package_Impl__Group_5__2__Impl" + // InternalRos2Parser.g:6823:1: rule__Package_Impl__Group_5__2__Impl : ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) ; + public final void rule__Package_Impl__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6827:1: ( ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) ) + // InternalRos2Parser.g:6828:1: ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) + { + // InternalRos2Parser.g:6828:1: ( ( rule__Package_Impl__SpecAssignment_5_2 )* ) + // InternalRos2Parser.g:6829:2: ( rule__Package_Impl__SpecAssignment_5_2 )* + { + before(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); + // InternalRos2Parser.g:6830:2: ( rule__Package_Impl__SpecAssignment_5_2 )* + loop39: + do { + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0==Action_1||LA39_0==Msg||LA39_0==Srv) ) { + alt39=1; + } + + + switch (alt39) { + case 1 : + // InternalRos2Parser.g:6830:3: rule__Package_Impl__SpecAssignment_5_2 + { + pushFollow(FOLLOW_29); + rule__Package_Impl__SpecAssignment_5_2(); + + state._fsp--; + + + } + break; + + default : + break loop39; + } + } while (true); + + after(grammarAccess.getPackage_ImplAccess().getSpecAssignment_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__2__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_5__3" + // InternalRos2Parser.g:6838:1: rule__Package_Impl__Group_5__3 : rule__Package_Impl__Group_5__3__Impl ; + public final void rule__Package_Impl__Group_5__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6842:1: ( rule__Package_Impl__Group_5__3__Impl ) + // InternalRos2Parser.g:6843:2: rule__Package_Impl__Group_5__3__Impl + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_5__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__3" + + + // $ANTLR start "rule__Package_Impl__Group_5__3__Impl" + // InternalRos2Parser.g:6849:1: rule__Package_Impl__Group_5__3__Impl : ( RULE_END ) ; + public final void rule__Package_Impl__Group_5__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6853:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:6854:1: ( RULE_END ) + { + // InternalRos2Parser.g:6854:1: ( RULE_END ) + // InternalRos2Parser.g:6855:2: RULE_END + { + before(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_5__3__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6__0" + // InternalRos2Parser.g:6865:1: rule__Package_Impl__Group_6__0 : rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 ; + public final void rule__Package_Impl__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6869:1: ( rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 ) + // InternalRos2Parser.g:6870:2: rule__Package_Impl__Group_6__0__Impl rule__Package_Impl__Group_6__1 + { + pushFollow(FOLLOW_10); + rule__Package_Impl__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__0" + + + // $ANTLR start "rule__Package_Impl__Group_6__0__Impl" + // InternalRos2Parser.g:6877:1: rule__Package_Impl__Group_6__0__Impl : ( Dependencies ) ; + public final void rule__Package_Impl__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6881:1: ( ( Dependencies ) ) + // InternalRos2Parser.g:6882:1: ( Dependencies ) + { + // InternalRos2Parser.g:6882:1: ( Dependencies ) + // InternalRos2Parser.g:6883:2: Dependencies + { + before(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); + match(input,Dependencies,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__0__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6__1" + // InternalRos2Parser.g:6892:1: rule__Package_Impl__Group_6__1 : rule__Package_Impl__Group_6__1__Impl rule__Package_Impl__Group_6__2 ; + public final void rule__Package_Impl__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6896:1: ( rule__Package_Impl__Group_6__1__Impl rule__Package_Impl__Group_6__2 ) + // InternalRos2Parser.g:6897:2: rule__Package_Impl__Group_6__1__Impl rule__Package_Impl__Group_6__2 + { + pushFollow(FOLLOW_11); + rule__Package_Impl__Group_6__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__1" + + + // $ANTLR start "rule__Package_Impl__Group_6__1__Impl" + // InternalRos2Parser.g:6904:1: rule__Package_Impl__Group_6__1__Impl : ( LeftSquareBracket ) ; + public final void rule__Package_Impl__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6908:1: ( ( LeftSquareBracket ) ) + // InternalRos2Parser.g:6909:1: ( LeftSquareBracket ) + { + // InternalRos2Parser.g:6909:1: ( LeftSquareBracket ) + // InternalRos2Parser.g:6910:2: LeftSquareBracket + { + before(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__1__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6__2" + // InternalRos2Parser.g:6919:1: rule__Package_Impl__Group_6__2 : rule__Package_Impl__Group_6__2__Impl rule__Package_Impl__Group_6__3 ; + public final void rule__Package_Impl__Group_6__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6923:1: ( rule__Package_Impl__Group_6__2__Impl rule__Package_Impl__Group_6__3 ) + // InternalRos2Parser.g:6924:2: rule__Package_Impl__Group_6__2__Impl rule__Package_Impl__Group_6__3 + { + pushFollow(FOLLOW_12); + rule__Package_Impl__Group_6__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__2" + + + // $ANTLR start "rule__Package_Impl__Group_6__2__Impl" + // InternalRos2Parser.g:6931:1: rule__Package_Impl__Group_6__2__Impl : ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) ; + public final void rule__Package_Impl__Group_6__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6935:1: ( ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) ) + // InternalRos2Parser.g:6936:1: ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) + { + // InternalRos2Parser.g:6936:1: ( ( rule__Package_Impl__DependencyAssignment_6_2 ) ) + // InternalRos2Parser.g:6937:2: ( rule__Package_Impl__DependencyAssignment_6_2 ) + { + before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); + // InternalRos2Parser.g:6938:2: ( rule__Package_Impl__DependencyAssignment_6_2 ) + // InternalRos2Parser.g:6938:3: rule__Package_Impl__DependencyAssignment_6_2 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__DependencyAssignment_6_2(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__2__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6__3" + // InternalRos2Parser.g:6946:1: rule__Package_Impl__Group_6__3 : rule__Package_Impl__Group_6__3__Impl rule__Package_Impl__Group_6__4 ; + public final void rule__Package_Impl__Group_6__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6950:1: ( rule__Package_Impl__Group_6__3__Impl rule__Package_Impl__Group_6__4 ) + // InternalRos2Parser.g:6951:2: rule__Package_Impl__Group_6__3__Impl rule__Package_Impl__Group_6__4 + { + pushFollow(FOLLOW_12); + rule__Package_Impl__Group_6__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__3" + + + // $ANTLR start "rule__Package_Impl__Group_6__3__Impl" + // InternalRos2Parser.g:6958:1: rule__Package_Impl__Group_6__3__Impl : ( ( rule__Package_Impl__Group_6_3__0 )* ) ; + public final void rule__Package_Impl__Group_6__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6962:1: ( ( ( rule__Package_Impl__Group_6_3__0 )* ) ) + // InternalRos2Parser.g:6963:1: ( ( rule__Package_Impl__Group_6_3__0 )* ) + { + // InternalRos2Parser.g:6963:1: ( ( rule__Package_Impl__Group_6_3__0 )* ) + // InternalRos2Parser.g:6964:2: ( rule__Package_Impl__Group_6_3__0 )* + { + before(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); + // InternalRos2Parser.g:6965:2: ( rule__Package_Impl__Group_6_3__0 )* + loop40: + do { + int alt40=2; + int LA40_0 = input.LA(1); + + if ( (LA40_0==Comma) ) { + alt40=1; + } + + + switch (alt40) { + case 1 : + // InternalRos2Parser.g:6965:3: rule__Package_Impl__Group_6_3__0 + { + pushFollow(FOLLOW_13); + rule__Package_Impl__Group_6_3__0(); + + state._fsp--; + + + } + break; + + default : + break loop40; + } + } while (true); + + after(grammarAccess.getPackage_ImplAccess().getGroup_6_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__3__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6__4" + // InternalRos2Parser.g:6973:1: rule__Package_Impl__Group_6__4 : rule__Package_Impl__Group_6__4__Impl ; + public final void rule__Package_Impl__Group_6__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6977:1: ( rule__Package_Impl__Group_6__4__Impl ) + // InternalRos2Parser.g:6978:2: rule__Package_Impl__Group_6__4__Impl + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6__4__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__4" + + + // $ANTLR start "rule__Package_Impl__Group_6__4__Impl" + // InternalRos2Parser.g:6984:1: rule__Package_Impl__Group_6__4__Impl : ( RightSquareBracket ) ; + public final void rule__Package_Impl__Group_6__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:6988:1: ( ( RightSquareBracket ) ) + // InternalRos2Parser.g:6989:1: ( RightSquareBracket ) + { + // InternalRos2Parser.g:6989:1: ( RightSquareBracket ) + // InternalRos2Parser.g:6990:2: RightSquareBracket + { + before(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6__4__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6_3__0" + // InternalRos2Parser.g:7000:1: rule__Package_Impl__Group_6_3__0 : rule__Package_Impl__Group_6_3__0__Impl rule__Package_Impl__Group_6_3__1 ; + public final void rule__Package_Impl__Group_6_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7004:1: ( rule__Package_Impl__Group_6_3__0__Impl rule__Package_Impl__Group_6_3__1 ) + // InternalRos2Parser.g:7005:2: rule__Package_Impl__Group_6_3__0__Impl rule__Package_Impl__Group_6_3__1 + { + pushFollow(FOLLOW_11); + rule__Package_Impl__Group_6_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6_3__0" + + + // $ANTLR start "rule__Package_Impl__Group_6_3__0__Impl" + // InternalRos2Parser.g:7012:1: rule__Package_Impl__Group_6_3__0__Impl : ( Comma ) ; + public final void rule__Package_Impl__Group_6_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7016:1: ( ( Comma ) ) + // InternalRos2Parser.g:7017:1: ( Comma ) + { + // InternalRos2Parser.g:7017:1: ( Comma ) + // InternalRos2Parser.g:7018:2: Comma + { + before(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6_3__0__Impl" + + + // $ANTLR start "rule__Package_Impl__Group_6_3__1" + // InternalRos2Parser.g:7027:1: rule__Package_Impl__Group_6_3__1 : rule__Package_Impl__Group_6_3__1__Impl ; + public final void rule__Package_Impl__Group_6_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7031:1: ( rule__Package_Impl__Group_6_3__1__Impl ) + // InternalRos2Parser.g:7032:2: rule__Package_Impl__Group_6_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__Package_Impl__Group_6_3__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6_3__1" + + + // $ANTLR start "rule__Package_Impl__Group_6_3__1__Impl" + // InternalRos2Parser.g:7038:1: rule__Package_Impl__Group_6_3__1__Impl : ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) ; + public final void rule__Package_Impl__Group_6_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7042:1: ( ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) ) + // InternalRos2Parser.g:7043:1: ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) + { + // InternalRos2Parser.g:7043:1: ( ( rule__Package_Impl__DependencyAssignment_6_3_1 ) ) + // InternalRos2Parser.g:7044:2: ( rule__Package_Impl__DependencyAssignment_6_3_1 ) + { + before(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1()); + // InternalRos2Parser.g:7045:2: ( rule__Package_Impl__DependencyAssignment_6_3_1 ) + // InternalRos2Parser.g:7045:3: rule__Package_Impl__DependencyAssignment_6_3_1 + { + pushFollow(FOLLOW_2); + rule__Package_Impl__DependencyAssignment_6_3_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPackage_ImplAccess().getDependencyAssignment_6_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__Group_6_3__1__Impl" + + + // $ANTLR start "rule__Artifact__Group__0" + // InternalRos2Parser.g:7054: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 { + // InternalRos2Parser.g:7058:1: ( rule__Artifact__Group__0__Impl rule__Artifact__Group__1 ) + // InternalRos2Parser.g:7059: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" + // InternalRos2Parser.g:7066:1: rule__Artifact__Group__0__Impl : ( () ) ; + public final void rule__Artifact__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7070:1: ( ( () ) ) + // InternalRos2Parser.g:7071:1: ( () ) + { + // InternalRos2Parser.g:7071:1: ( () ) + // InternalRos2Parser.g:7072:2: () + { + before(grammarAccess.getArtifactAccess().getArtifactAction_0()); + // InternalRos2Parser.g:7073:2: () + // InternalRos2Parser.g:7073:3: + { + } + + after(grammarAccess.getArtifactAccess().getArtifactAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__0__Impl" + + + // $ANTLR start "rule__Artifact__Group__1" + // InternalRos2Parser.g:7081: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 { + // InternalRos2Parser.g:7085:1: ( rule__Artifact__Group__1__Impl rule__Artifact__Group__2 ) + // InternalRos2Parser.g:7086: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" + // InternalRos2Parser.g:7093:1: rule__Artifact__Group__1__Impl : ( ( rule__Artifact__NameAssignment_1 ) ) ; + public final void rule__Artifact__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7097:1: ( ( ( rule__Artifact__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:7098:1: ( ( rule__Artifact__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:7098:1: ( ( rule__Artifact__NameAssignment_1 ) ) + // InternalRos2Parser.g:7099:2: ( rule__Artifact__NameAssignment_1 ) + { + before(grammarAccess.getArtifactAccess().getNameAssignment_1()); + // InternalRos2Parser.g:7100:2: ( rule__Artifact__NameAssignment_1 ) + // InternalRos2Parser.g:7100: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" + // InternalRos2Parser.g:7108: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 { + // InternalRos2Parser.g:7112:1: ( rule__Artifact__Group__2__Impl rule__Artifact__Group__3 ) + // InternalRos2Parser.g:7113: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" + // InternalRos2Parser.g:7120:1: rule__Artifact__Group__2__Impl : ( Colon ) ; + public final void rule__Artifact__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7124:1: ( ( Colon ) ) + // InternalRos2Parser.g:7125:1: ( Colon ) + { + // InternalRos2Parser.g:7125:1: ( Colon ) + // InternalRos2Parser.g:7126: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" + // InternalRos2Parser.g:7135: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 { + // InternalRos2Parser.g:7139:1: ( rule__Artifact__Group__3__Impl rule__Artifact__Group__4 ) + // InternalRos2Parser.g:7140:2: rule__Artifact__Group__3__Impl rule__Artifact__Group__4 + { + pushFollow(FOLLOW_30); + 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" + // InternalRos2Parser.g:7147:1: rule__Artifact__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Artifact__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7151:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:7152:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:7152:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:7153: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" + // InternalRos2Parser.g:7162: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 { + // InternalRos2Parser.g:7166:1: ( rule__Artifact__Group__4__Impl rule__Artifact__Group__5 ) + // InternalRos2Parser.g:7167:2: rule__Artifact__Group__4__Impl rule__Artifact__Group__5 + { + pushFollow(FOLLOW_30); + 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" + // InternalRos2Parser.g:7174:1: rule__Artifact__Group__4__Impl : ( ( rule__Artifact__NodeAssignment_4 )? ) ; + public final void rule__Artifact__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7178:1: ( ( ( rule__Artifact__NodeAssignment_4 )? ) ) + // InternalRos2Parser.g:7179:1: ( ( rule__Artifact__NodeAssignment_4 )? ) + { + // InternalRos2Parser.g:7179:1: ( ( rule__Artifact__NodeAssignment_4 )? ) + // InternalRos2Parser.g:7180:2: ( rule__Artifact__NodeAssignment_4 )? + { + before(grammarAccess.getArtifactAccess().getNodeAssignment_4()); + // InternalRos2Parser.g:7181:2: ( rule__Artifact__NodeAssignment_4 )? + int alt41=2; + int LA41_0 = input.LA(1); + + if ( (LA41_0==Node_1) ) { + alt41=1; + } + switch (alt41) { + case 1 : + // InternalRos2Parser.g:7181: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" + // InternalRos2Parser.g:7189:1: rule__Artifact__Group__5 : rule__Artifact__Group__5__Impl ; + public final void rule__Artifact__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7193:1: ( rule__Artifact__Group__5__Impl ) + // InternalRos2Parser.g:7194: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" + // InternalRos2Parser.g:7200:1: rule__Artifact__Group__5__Impl : ( RULE_END ) ; + public final void rule__Artifact__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7204:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:7205:1: ( RULE_END ) + { + // InternalRos2Parser.g:7205:1: ( RULE_END ) + // InternalRos2Parser.g:7206: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" + // InternalRos2Parser.g:7216: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 { + // InternalRos2Parser.g:7220:1: ( rule__Node__Group__0__Impl rule__Node__Group__1 ) + // InternalRos2Parser.g:7221: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" + // InternalRos2Parser.g:7228:1: rule__Node__Group__0__Impl : ( Node_1 ) ; + public final void rule__Node__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7232:1: ( ( Node_1 ) ) + // InternalRos2Parser.g:7233:1: ( Node_1 ) + { + // InternalRos2Parser.g:7233:1: ( Node_1 ) + // InternalRos2Parser.g:7234: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" + // InternalRos2Parser.g:7243: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 { + // InternalRos2Parser.g:7247:1: ( rule__Node__Group__1__Impl rule__Node__Group__2 ) + // InternalRos2Parser.g:7248: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" + // InternalRos2Parser.g:7255:1: rule__Node__Group__1__Impl : ( ( rule__Node__NameAssignment_1 ) ) ; + public final void rule__Node__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7259:1: ( ( ( rule__Node__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:7260:1: ( ( rule__Node__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:7260:1: ( ( rule__Node__NameAssignment_1 ) ) + // InternalRos2Parser.g:7261:2: ( rule__Node__NameAssignment_1 ) + { + before(grammarAccess.getNodeAccess().getNameAssignment_1()); + // InternalRos2Parser.g:7262:2: ( rule__Node__NameAssignment_1 ) + // InternalRos2Parser.g:7262: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" + // InternalRos2Parser.g:7270: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 { + // InternalRos2Parser.g:7274:1: ( rule__Node__Group__2__Impl rule__Node__Group__3 ) + // InternalRos2Parser.g:7275:2: rule__Node__Group__2__Impl rule__Node__Group__3 + { + pushFollow(FOLLOW_31); + 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" + // InternalRos2Parser.g:7282:1: rule__Node__Group__2__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7286:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:7287:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:7287:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:7288: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" + // InternalRos2Parser.g:7297: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 { + // InternalRos2Parser.g:7301:1: ( rule__Node__Group__3__Impl rule__Node__Group__4 ) + // InternalRos2Parser.g:7302:2: rule__Node__Group__3__Impl rule__Node__Group__4 + { + pushFollow(FOLLOW_31); + 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" + // InternalRos2Parser.g:7309:1: rule__Node__Group__3__Impl : ( ( rule__Node__Alternatives_3 )* ) ; + public final void rule__Node__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7313:1: ( ( ( rule__Node__Alternatives_3 )* ) ) + // InternalRos2Parser.g:7314:1: ( ( rule__Node__Alternatives_3 )* ) + { + // InternalRos2Parser.g:7314:1: ( ( rule__Node__Alternatives_3 )* ) + // InternalRos2Parser.g:7315:2: ( rule__Node__Alternatives_3 )* + { + before(grammarAccess.getNodeAccess().getAlternatives_3()); + // InternalRos2Parser.g:7316:2: ( rule__Node__Alternatives_3 )* + loop42: + do { + int alt42=2; + int LA42_0 = input.LA(1); + + if ( ((LA42_0>=Serviceclient && LA42_0<=Actionserver)||LA42_0==Subscribers||(LA42_0>=Parameters && LA42_0<=Publishers)) ) { + alt42=1; + } + + + switch (alt42) { + case 1 : + // InternalRos2Parser.g:7316:3: rule__Node__Alternatives_3 + { + pushFollow(FOLLOW_32); + rule__Node__Alternatives_3(); + + state._fsp--; + + + } + break; + + default : + break loop42; + } + } while (true); + + after(grammarAccess.getNodeAccess().getAlternatives_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" + // InternalRos2Parser.g:7324:1: rule__Node__Group__4 : rule__Node__Group__4__Impl ; + public final void rule__Node__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7328:1: ( rule__Node__Group__4__Impl ) + // InternalRos2Parser.g:7329:2: rule__Node__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group__4__Impl(); + + 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" + // InternalRos2Parser.g:7335:1: rule__Node__Group__4__Impl : ( RULE_END ) ; + public final void rule__Node__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7339:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:7340:1: ( RULE_END ) + { + // InternalRos2Parser.g:7340:1: ( RULE_END ) + // InternalRos2Parser.g:7341:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_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_3_0__0" + // InternalRos2Parser.g:7351:1: rule__Node__Group_3_0__0 : rule__Node__Group_3_0__0__Impl rule__Node__Group_3_0__1 ; + public final void rule__Node__Group_3_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7355:1: ( rule__Node__Group_3_0__0__Impl rule__Node__Group_3_0__1 ) + // InternalRos2Parser.g:7356:2: rule__Node__Group_3_0__0__Impl rule__Node__Group_3_0__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_0__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_0__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__0" + + + // $ANTLR start "rule__Node__Group_3_0__0__Impl" + // InternalRos2Parser.g:7363:1: rule__Node__Group_3_0__0__Impl : ( Publishers ) ; + public final void rule__Node__Group_3_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7367:1: ( ( Publishers ) ) + // InternalRos2Parser.g:7368:1: ( Publishers ) + { + // InternalRos2Parser.g:7368:1: ( Publishers ) + // InternalRos2Parser.g:7369:2: Publishers + { + before(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); + match(input,Publishers,FOLLOW_2); + after(grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_0__1" + // InternalRos2Parser.g:7378:1: rule__Node__Group_3_0__1 : rule__Node__Group_3_0__1__Impl rule__Node__Group_3_0__2 ; + public final void rule__Node__Group_3_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7382:1: ( rule__Node__Group_3_0__1__Impl rule__Node__Group_3_0__2 ) + // InternalRos2Parser.g:7383:2: rule__Node__Group_3_0__1__Impl rule__Node__Group_3_0__2 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_0__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_0__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__1" + + + // $ANTLR start "rule__Node__Group_3_0__1__Impl" + // InternalRos2Parser.g:7390:1: rule__Node__Group_3_0__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7394:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:7395:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:7395:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:7396:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_0__2" + // InternalRos2Parser.g:7405:1: rule__Node__Group_3_0__2 : rule__Node__Group_3_0__2__Impl rule__Node__Group_3_0__3 ; + public final void rule__Node__Group_3_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7409:1: ( rule__Node__Group_3_0__2__Impl rule__Node__Group_3_0__3 ) + // InternalRos2Parser.g:7410:2: rule__Node__Group_3_0__2__Impl rule__Node__Group_3_0__3 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_0__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_0__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__2" + + + // $ANTLR start "rule__Node__Group_3_0__2__Impl" + // InternalRos2Parser.g:7417:1: rule__Node__Group_3_0__2__Impl : ( ( rule__Node__PublisherAssignment_3_0_2 )* ) ; + public final void rule__Node__Group_3_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7421:1: ( ( ( rule__Node__PublisherAssignment_3_0_2 )* ) ) + // InternalRos2Parser.g:7422:1: ( ( rule__Node__PublisherAssignment_3_0_2 )* ) + { + // InternalRos2Parser.g:7422:1: ( ( rule__Node__PublisherAssignment_3_0_2 )* ) + // InternalRos2Parser.g:7423:2: ( rule__Node__PublisherAssignment_3_0_2 )* + { + before(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); + // InternalRos2Parser.g:7424:2: ( rule__Node__PublisherAssignment_3_0_2 )* + loop43: + do { + int alt43=2; + int LA43_0 = input.LA(1); + + if ( (LA43_0==RULE_ID||LA43_0==RULE_STRING) ) { + alt43=1; + } + + + switch (alt43) { + case 1 : + // InternalRos2Parser.g:7424:3: rule__Node__PublisherAssignment_3_0_2 + { + pushFollow(FOLLOW_34); + rule__Node__PublisherAssignment_3_0_2(); + + state._fsp--; + + + } + break; + + default : + break loop43; + } + } while (true); + + after(grammarAccess.getNodeAccess().getPublisherAssignment_3_0_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_0__3" + // InternalRos2Parser.g:7432:1: rule__Node__Group_3_0__3 : rule__Node__Group_3_0__3__Impl ; + public final void rule__Node__Group_3_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7436:1: ( rule__Node__Group_3_0__3__Impl ) + // InternalRos2Parser.g:7437:2: rule__Node__Group_3_0__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_0__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__3" + + + // $ANTLR start "rule__Node__Group_3_0__3__Impl" + // InternalRos2Parser.g:7443:1: rule__Node__Group_3_0__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7447:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:7448:1: ( RULE_END ) + { + // InternalRos2Parser.g:7448:1: ( RULE_END ) + // InternalRos2Parser.g:7449:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_0__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_1__0" + // InternalRos2Parser.g:7459:1: rule__Node__Group_3_1__0 : rule__Node__Group_3_1__0__Impl rule__Node__Group_3_1__1 ; + public final void rule__Node__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7463:1: ( rule__Node__Group_3_1__0__Impl rule__Node__Group_3_1__1 ) + // InternalRos2Parser.g:7464:2: rule__Node__Group_3_1__0__Impl rule__Node__Group_3_1__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__0" + + + // $ANTLR start "rule__Node__Group_3_1__0__Impl" + // InternalRos2Parser.g:7471:1: rule__Node__Group_3_1__0__Impl : ( Subscribers ) ; + public final void rule__Node__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7475:1: ( ( Subscribers ) ) + // InternalRos2Parser.g:7476:1: ( Subscribers ) + { + // InternalRos2Parser.g:7476:1: ( Subscribers ) + // InternalRos2Parser.g:7477:2: Subscribers + { + before(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); + match(input,Subscribers,FOLLOW_2); + after(grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_1__1" + // InternalRos2Parser.g:7486:1: rule__Node__Group_3_1__1 : rule__Node__Group_3_1__1__Impl rule__Node__Group_3_1__2 ; + public final void rule__Node__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7490:1: ( rule__Node__Group_3_1__1__Impl rule__Node__Group_3_1__2 ) + // InternalRos2Parser.g:7491:2: rule__Node__Group_3_1__1__Impl rule__Node__Group_3_1__2 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_1__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_1__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__1" + + + // $ANTLR start "rule__Node__Group_3_1__1__Impl" + // InternalRos2Parser.g:7498:1: rule__Node__Group_3_1__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7502:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:7503:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:7503:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:7504:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_1__2" + // InternalRos2Parser.g:7513:1: rule__Node__Group_3_1__2 : rule__Node__Group_3_1__2__Impl rule__Node__Group_3_1__3 ; + public final void rule__Node__Group_3_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7517:1: ( rule__Node__Group_3_1__2__Impl rule__Node__Group_3_1__3 ) + // InternalRos2Parser.g:7518:2: rule__Node__Group_3_1__2__Impl rule__Node__Group_3_1__3 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_1__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_1__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__2" + + + // $ANTLR start "rule__Node__Group_3_1__2__Impl" + // InternalRos2Parser.g:7525:1: rule__Node__Group_3_1__2__Impl : ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) ; + public final void rule__Node__Group_3_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7529:1: ( ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) ) + // InternalRos2Parser.g:7530:1: ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) + { + // InternalRos2Parser.g:7530:1: ( ( rule__Node__SubscriberAssignment_3_1_2 )* ) + // InternalRos2Parser.g:7531:2: ( rule__Node__SubscriberAssignment_3_1_2 )* + { + before(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); + // InternalRos2Parser.g:7532:2: ( rule__Node__SubscriberAssignment_3_1_2 )* + loop44: + do { + int alt44=2; + int LA44_0 = input.LA(1); + + if ( (LA44_0==RULE_ID||LA44_0==RULE_STRING) ) { + alt44=1; + } + + + switch (alt44) { + case 1 : + // InternalRos2Parser.g:7532:3: rule__Node__SubscriberAssignment_3_1_2 + { + pushFollow(FOLLOW_34); + rule__Node__SubscriberAssignment_3_1_2(); + + state._fsp--; + + + } + break; + + default : + break loop44; + } + } while (true); + + after(grammarAccess.getNodeAccess().getSubscriberAssignment_3_1_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_1__3" + // InternalRos2Parser.g:7540:1: rule__Node__Group_3_1__3 : rule__Node__Group_3_1__3__Impl ; + public final void rule__Node__Group_3_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7544:1: ( rule__Node__Group_3_1__3__Impl ) + // InternalRos2Parser.g:7545:2: rule__Node__Group_3_1__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_1__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__3" + + + // $ANTLR start "rule__Node__Group_3_1__3__Impl" + // InternalRos2Parser.g:7551:1: rule__Node__Group_3_1__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7555:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:7556:1: ( RULE_END ) + { + // InternalRos2Parser.g:7556:1: ( RULE_END ) + // InternalRos2Parser.g:7557:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_1__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_2__0" + // InternalRos2Parser.g:7567:1: rule__Node__Group_3_2__0 : rule__Node__Group_3_2__0__Impl rule__Node__Group_3_2__1 ; + public final void rule__Node__Group_3_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7571:1: ( rule__Node__Group_3_2__0__Impl rule__Node__Group_3_2__1 ) + // InternalRos2Parser.g:7572:2: rule__Node__Group_3_2__0__Impl rule__Node__Group_3_2__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__0" + + + // $ANTLR start "rule__Node__Group_3_2__0__Impl" + // InternalRos2Parser.g:7579:1: rule__Node__Group_3_2__0__Impl : ( Serviceserver ) ; + public final void rule__Node__Group_3_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7583:1: ( ( Serviceserver ) ) + // InternalRos2Parser.g:7584:1: ( Serviceserver ) + { + // InternalRos2Parser.g:7584:1: ( Serviceserver ) + // InternalRos2Parser.g:7585:2: Serviceserver + { + before(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); + match(input,Serviceserver,FOLLOW_2); + after(grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_2__1" + // InternalRos2Parser.g:7594:1: rule__Node__Group_3_2__1 : rule__Node__Group_3_2__1__Impl rule__Node__Group_3_2__2 ; + public final void rule__Node__Group_3_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7598:1: ( rule__Node__Group_3_2__1__Impl rule__Node__Group_3_2__2 ) + // InternalRos2Parser.g:7599:2: rule__Node__Group_3_2__1__Impl rule__Node__Group_3_2__2 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_2__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_2__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__1" + + + // $ANTLR start "rule__Node__Group_3_2__1__Impl" + // InternalRos2Parser.g:7606:1: rule__Node__Group_3_2__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7610:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:7611:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:7611:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:7612:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_2__2" + // InternalRos2Parser.g:7621:1: rule__Node__Group_3_2__2 : rule__Node__Group_3_2__2__Impl rule__Node__Group_3_2__3 ; + public final void rule__Node__Group_3_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7625:1: ( rule__Node__Group_3_2__2__Impl rule__Node__Group_3_2__3 ) + // InternalRos2Parser.g:7626:2: rule__Node__Group_3_2__2__Impl rule__Node__Group_3_2__3 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_2__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_2__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__2" + + + // $ANTLR start "rule__Node__Group_3_2__2__Impl" + // InternalRos2Parser.g:7633:1: rule__Node__Group_3_2__2__Impl : ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) ; + public final void rule__Node__Group_3_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7637:1: ( ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) ) + // InternalRos2Parser.g:7638:1: ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) + { + // InternalRos2Parser.g:7638:1: ( ( rule__Node__ServiceserverAssignment_3_2_2 )* ) + // InternalRos2Parser.g:7639:2: ( rule__Node__ServiceserverAssignment_3_2_2 )* + { + before(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); + // InternalRos2Parser.g:7640:2: ( rule__Node__ServiceserverAssignment_3_2_2 )* + loop45: + do { + int alt45=2; + int LA45_0 = input.LA(1); + + if ( (LA45_0==RULE_ID||LA45_0==RULE_STRING) ) { + alt45=1; + } + + + switch (alt45) { + case 1 : + // InternalRos2Parser.g:7640:3: rule__Node__ServiceserverAssignment_3_2_2 + { + pushFollow(FOLLOW_34); + rule__Node__ServiceserverAssignment_3_2_2(); + + state._fsp--; + + + } + break; + + default : + break loop45; + } + } while (true); + + after(grammarAccess.getNodeAccess().getServiceserverAssignment_3_2_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_2__3" + // InternalRos2Parser.g:7648:1: rule__Node__Group_3_2__3 : rule__Node__Group_3_2__3__Impl ; + public final void rule__Node__Group_3_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7652:1: ( rule__Node__Group_3_2__3__Impl ) + // InternalRos2Parser.g:7653:2: rule__Node__Group_3_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_2__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__3" + + + // $ANTLR start "rule__Node__Group_3_2__3__Impl" + // InternalRos2Parser.g:7659:1: rule__Node__Group_3_2__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7663:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:7664:1: ( RULE_END ) + { + // InternalRos2Parser.g:7664:1: ( RULE_END ) + // InternalRos2Parser.g:7665:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_2__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_3__0" + // InternalRos2Parser.g:7675:1: rule__Node__Group_3_3__0 : rule__Node__Group_3_3__0__Impl rule__Node__Group_3_3__1 ; + public final void rule__Node__Group_3_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7679:1: ( rule__Node__Group_3_3__0__Impl rule__Node__Group_3_3__1 ) + // InternalRos2Parser.g:7680:2: rule__Node__Group_3_3__0__Impl rule__Node__Group_3_3__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__0" + + + // $ANTLR start "rule__Node__Group_3_3__0__Impl" + // InternalRos2Parser.g:7687:1: rule__Node__Group_3_3__0__Impl : ( Serviceclient ) ; + public final void rule__Node__Group_3_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7691:1: ( ( Serviceclient ) ) + // InternalRos2Parser.g:7692:1: ( Serviceclient ) + { + // InternalRos2Parser.g:7692:1: ( Serviceclient ) + // InternalRos2Parser.g:7693:2: Serviceclient + { + before(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); + match(input,Serviceclient,FOLLOW_2); + after(grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_3__1" + // InternalRos2Parser.g:7702:1: rule__Node__Group_3_3__1 : rule__Node__Group_3_3__1__Impl rule__Node__Group_3_3__2 ; + public final void rule__Node__Group_3_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7706:1: ( rule__Node__Group_3_3__1__Impl rule__Node__Group_3_3__2 ) + // InternalRos2Parser.g:7707:2: rule__Node__Group_3_3__1__Impl rule__Node__Group_3_3__2 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_3__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_3__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__1" + + + // $ANTLR start "rule__Node__Group_3_3__1__Impl" + // InternalRos2Parser.g:7714:1: rule__Node__Group_3_3__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7718:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:7719:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:7719:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:7720:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_3__2" + // InternalRos2Parser.g:7729:1: rule__Node__Group_3_3__2 : rule__Node__Group_3_3__2__Impl rule__Node__Group_3_3__3 ; + public final void rule__Node__Group_3_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7733:1: ( rule__Node__Group_3_3__2__Impl rule__Node__Group_3_3__3 ) + // InternalRos2Parser.g:7734:2: rule__Node__Group_3_3__2__Impl rule__Node__Group_3_3__3 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_3__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_3__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__2" + + + // $ANTLR start "rule__Node__Group_3_3__2__Impl" + // InternalRos2Parser.g:7741:1: rule__Node__Group_3_3__2__Impl : ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) ; + public final void rule__Node__Group_3_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7745:1: ( ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) ) + // InternalRos2Parser.g:7746:1: ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) + { + // InternalRos2Parser.g:7746:1: ( ( rule__Node__ServiceclientAssignment_3_3_2 )* ) + // InternalRos2Parser.g:7747:2: ( rule__Node__ServiceclientAssignment_3_3_2 )* + { + before(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); + // InternalRos2Parser.g:7748:2: ( rule__Node__ServiceclientAssignment_3_3_2 )* + loop46: + do { + int alt46=2; + int LA46_0 = input.LA(1); + + if ( (LA46_0==RULE_ID||LA46_0==RULE_STRING) ) { + alt46=1; + } + + + switch (alt46) { + case 1 : + // InternalRos2Parser.g:7748:3: rule__Node__ServiceclientAssignment_3_3_2 + { + pushFollow(FOLLOW_34); + rule__Node__ServiceclientAssignment_3_3_2(); + + state._fsp--; + + + } + break; + + default : + break loop46; + } + } while (true); + + after(grammarAccess.getNodeAccess().getServiceclientAssignment_3_3_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_3__3" + // InternalRos2Parser.g:7756:1: rule__Node__Group_3_3__3 : rule__Node__Group_3_3__3__Impl ; + public final void rule__Node__Group_3_3__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7760:1: ( rule__Node__Group_3_3__3__Impl ) + // InternalRos2Parser.g:7761:2: rule__Node__Group_3_3__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_3__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__3" + + + // $ANTLR start "rule__Node__Group_3_3__3__Impl" + // InternalRos2Parser.g:7767:1: rule__Node__Group_3_3__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_3__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7771:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:7772:1: ( RULE_END ) + { + // InternalRos2Parser.g:7772:1: ( RULE_END ) + // InternalRos2Parser.g:7773:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_3__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_4__0" + // InternalRos2Parser.g:7783:1: rule__Node__Group_3_4__0 : rule__Node__Group_3_4__0__Impl rule__Node__Group_3_4__1 ; + public final void rule__Node__Group_3_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7787:1: ( rule__Node__Group_3_4__0__Impl rule__Node__Group_3_4__1 ) + // InternalRos2Parser.g:7788:2: rule__Node__Group_3_4__0__Impl rule__Node__Group_3_4__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__0" + + + // $ANTLR start "rule__Node__Group_3_4__0__Impl" + // InternalRos2Parser.g:7795:1: rule__Node__Group_3_4__0__Impl : ( Actionserver ) ; + public final void rule__Node__Group_3_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7799:1: ( ( Actionserver ) ) + // InternalRos2Parser.g:7800:1: ( Actionserver ) + { + // InternalRos2Parser.g:7800:1: ( Actionserver ) + // InternalRos2Parser.g:7801:2: Actionserver + { + before(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); + match(input,Actionserver,FOLLOW_2); + after(grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_4__1" + // InternalRos2Parser.g:7810:1: rule__Node__Group_3_4__1 : rule__Node__Group_3_4__1__Impl rule__Node__Group_3_4__2 ; + public final void rule__Node__Group_3_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7814:1: ( rule__Node__Group_3_4__1__Impl rule__Node__Group_3_4__2 ) + // InternalRos2Parser.g:7815:2: rule__Node__Group_3_4__1__Impl rule__Node__Group_3_4__2 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_4__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_4__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__1" + + + // $ANTLR start "rule__Node__Group_3_4__1__Impl" + // InternalRos2Parser.g:7822:1: rule__Node__Group_3_4__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7826:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:7827:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:7827:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:7828:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_4__2" + // InternalRos2Parser.g:7837:1: rule__Node__Group_3_4__2 : rule__Node__Group_3_4__2__Impl rule__Node__Group_3_4__3 ; + public final void rule__Node__Group_3_4__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7841:1: ( rule__Node__Group_3_4__2__Impl rule__Node__Group_3_4__3 ) + // InternalRos2Parser.g:7842:2: rule__Node__Group_3_4__2__Impl rule__Node__Group_3_4__3 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_4__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_4__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__2" + + + // $ANTLR start "rule__Node__Group_3_4__2__Impl" + // InternalRos2Parser.g:7849:1: rule__Node__Group_3_4__2__Impl : ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) ; + public final void rule__Node__Group_3_4__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7853:1: ( ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) ) + // InternalRos2Parser.g:7854:1: ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) + { + // InternalRos2Parser.g:7854:1: ( ( rule__Node__ActionserverAssignment_3_4_2 )* ) + // InternalRos2Parser.g:7855:2: ( rule__Node__ActionserverAssignment_3_4_2 )* + { + before(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); + // InternalRos2Parser.g:7856:2: ( rule__Node__ActionserverAssignment_3_4_2 )* + loop47: + do { + int alt47=2; + int LA47_0 = input.LA(1); + + if ( (LA47_0==RULE_ID||LA47_0==RULE_STRING) ) { + alt47=1; + } + + + switch (alt47) { + case 1 : + // InternalRos2Parser.g:7856:3: rule__Node__ActionserverAssignment_3_4_2 + { + pushFollow(FOLLOW_34); + rule__Node__ActionserverAssignment_3_4_2(); + + state._fsp--; + + + } + break; + + default : + break loop47; + } + } while (true); + + after(grammarAccess.getNodeAccess().getActionserverAssignment_3_4_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_4__3" + // InternalRos2Parser.g:7864:1: rule__Node__Group_3_4__3 : rule__Node__Group_3_4__3__Impl ; + public final void rule__Node__Group_3_4__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7868:1: ( rule__Node__Group_3_4__3__Impl ) + // InternalRos2Parser.g:7869:2: rule__Node__Group_3_4__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_4__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__3" + + + // $ANTLR start "rule__Node__Group_3_4__3__Impl" + // InternalRos2Parser.g:7875:1: rule__Node__Group_3_4__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_4__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7879:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:7880:1: ( RULE_END ) + { + // InternalRos2Parser.g:7880:1: ( RULE_END ) + // InternalRos2Parser.g:7881:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_4__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_5__0" + // InternalRos2Parser.g:7891:1: rule__Node__Group_3_5__0 : rule__Node__Group_3_5__0__Impl rule__Node__Group_3_5__1 ; + public final void rule__Node__Group_3_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7895:1: ( rule__Node__Group_3_5__0__Impl rule__Node__Group_3_5__1 ) + // InternalRos2Parser.g:7896:2: rule__Node__Group_3_5__0__Impl rule__Node__Group_3_5__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__0" + + + // $ANTLR start "rule__Node__Group_3_5__0__Impl" + // InternalRos2Parser.g:7903:1: rule__Node__Group_3_5__0__Impl : ( Actionclient ) ; + public final void rule__Node__Group_3_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7907:1: ( ( Actionclient ) ) + // InternalRos2Parser.g:7908:1: ( Actionclient ) + { + // InternalRos2Parser.g:7908:1: ( Actionclient ) + // InternalRos2Parser.g:7909:2: Actionclient + { + before(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); + match(input,Actionclient,FOLLOW_2); + after(grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_5__1" + // InternalRos2Parser.g:7918:1: rule__Node__Group_3_5__1 : rule__Node__Group_3_5__1__Impl rule__Node__Group_3_5__2 ; + public final void rule__Node__Group_3_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7922:1: ( rule__Node__Group_3_5__1__Impl rule__Node__Group_3_5__2 ) + // InternalRos2Parser.g:7923:2: rule__Node__Group_3_5__1__Impl rule__Node__Group_3_5__2 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__1" + + + // $ANTLR start "rule__Node__Group_3_5__1__Impl" + // InternalRos2Parser.g:7930:1: rule__Node__Group_3_5__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7934:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:7935:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:7935:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:7936:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_5__2" + // InternalRos2Parser.g:7945:1: rule__Node__Group_3_5__2 : rule__Node__Group_3_5__2__Impl rule__Node__Group_3_5__3 ; + public final void rule__Node__Group_3_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7949:1: ( rule__Node__Group_3_5__2__Impl rule__Node__Group_3_5__3 ) + // InternalRos2Parser.g:7950:2: rule__Node__Group_3_5__2__Impl rule__Node__Group_3_5__3 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_5__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_5__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__2" + + + // $ANTLR start "rule__Node__Group_3_5__2__Impl" + // InternalRos2Parser.g:7957:1: rule__Node__Group_3_5__2__Impl : ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) ; + public final void rule__Node__Group_3_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7961:1: ( ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) ) + // InternalRos2Parser.g:7962:1: ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) + { + // InternalRos2Parser.g:7962:1: ( ( rule__Node__ActionclientAssignment_3_5_2 )* ) + // InternalRos2Parser.g:7963:2: ( rule__Node__ActionclientAssignment_3_5_2 )* + { + before(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); + // InternalRos2Parser.g:7964:2: ( rule__Node__ActionclientAssignment_3_5_2 )* + loop48: + do { + int alt48=2; + int LA48_0 = input.LA(1); + + if ( (LA48_0==RULE_ID||LA48_0==RULE_STRING) ) { + alt48=1; + } + + + switch (alt48) { + case 1 : + // InternalRos2Parser.g:7964:3: rule__Node__ActionclientAssignment_3_5_2 + { + pushFollow(FOLLOW_34); + rule__Node__ActionclientAssignment_3_5_2(); + + state._fsp--; + + + } + break; + + default : + break loop48; + } + } while (true); + + after(grammarAccess.getNodeAccess().getActionclientAssignment_3_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_5__3" + // InternalRos2Parser.g:7972:1: rule__Node__Group_3_5__3 : rule__Node__Group_3_5__3__Impl ; + public final void rule__Node__Group_3_5__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7976:1: ( rule__Node__Group_3_5__3__Impl ) + // InternalRos2Parser.g:7977:2: rule__Node__Group_3_5__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_5__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__3" + + + // $ANTLR start "rule__Node__Group_3_5__3__Impl" + // InternalRos2Parser.g:7983:1: rule__Node__Group_3_5__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_5__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:7987:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:7988:1: ( RULE_END ) + { + // InternalRos2Parser.g:7988:1: ( RULE_END ) + // InternalRos2Parser.g:7989:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_5__3__Impl" + + + // $ANTLR start "rule__Node__Group_3_6__0" + // InternalRos2Parser.g:7999:1: rule__Node__Group_3_6__0 : rule__Node__Group_3_6__0__Impl rule__Node__Group_3_6__1 ; + public final void rule__Node__Group_3_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8003:1: ( rule__Node__Group_3_6__0__Impl rule__Node__Group_3_6__1 ) + // InternalRos2Parser.g:8004:2: rule__Node__Group_3_6__0__Impl rule__Node__Group_3_6__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__0" + + + // $ANTLR start "rule__Node__Group_3_6__0__Impl" + // InternalRos2Parser.g:8011:1: rule__Node__Group_3_6__0__Impl : ( Parameters ) ; + public final void rule__Node__Group_3_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8015:1: ( ( Parameters ) ) + // InternalRos2Parser.g:8016:1: ( Parameters ) + { + // InternalRos2Parser.g:8016:1: ( Parameters ) + // InternalRos2Parser.g:8017:2: Parameters + { + before(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); + match(input,Parameters,FOLLOW_2); + after(grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__0__Impl" + + + // $ANTLR start "rule__Node__Group_3_6__1" + // InternalRos2Parser.g:8026:1: rule__Node__Group_3_6__1 : rule__Node__Group_3_6__1__Impl rule__Node__Group_3_6__2 ; + public final void rule__Node__Group_3_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8030:1: ( rule__Node__Group_3_6__1__Impl rule__Node__Group_3_6__2 ) + // InternalRos2Parser.g:8031:2: rule__Node__Group_3_6__1__Impl rule__Node__Group_3_6__2 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_6__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_6__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__1" + + + // $ANTLR start "rule__Node__Group_3_6__1__Impl" + // InternalRos2Parser.g:8038:1: rule__Node__Group_3_6__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8042:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:8043:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:8043:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:8044:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__1__Impl" + + + // $ANTLR start "rule__Node__Group_3_6__2" + // InternalRos2Parser.g:8053:1: rule__Node__Group_3_6__2 : rule__Node__Group_3_6__2__Impl rule__Node__Group_3_6__3 ; + public final void rule__Node__Group_3_6__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8057:1: ( rule__Node__Group_3_6__2__Impl rule__Node__Group_3_6__3 ) + // InternalRos2Parser.g:8058:2: rule__Node__Group_3_6__2__Impl rule__Node__Group_3_6__3 + { + pushFollow(FOLLOW_33); + rule__Node__Group_3_6__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3_6__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__2" + + + // $ANTLR start "rule__Node__Group_3_6__2__Impl" + // InternalRos2Parser.g:8065:1: rule__Node__Group_3_6__2__Impl : ( ( rule__Node__ParameterAssignment_3_6_2 )* ) ; + public final void rule__Node__Group_3_6__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8069:1: ( ( ( rule__Node__ParameterAssignment_3_6_2 )* ) ) + // InternalRos2Parser.g:8070:1: ( ( rule__Node__ParameterAssignment_3_6_2 )* ) + { + // InternalRos2Parser.g:8070:1: ( ( rule__Node__ParameterAssignment_3_6_2 )* ) + // InternalRos2Parser.g:8071:2: ( rule__Node__ParameterAssignment_3_6_2 )* + { + before(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); + // InternalRos2Parser.g:8072:2: ( rule__Node__ParameterAssignment_3_6_2 )* + loop49: + do { + int alt49=2; + int LA49_0 = input.LA(1); + + if ( (LA49_0==RULE_ID||LA49_0==RULE_STRING) ) { + alt49=1; + } + + + switch (alt49) { + case 1 : + // InternalRos2Parser.g:8072:3: rule__Node__ParameterAssignment_3_6_2 + { + pushFollow(FOLLOW_34); + rule__Node__ParameterAssignment_3_6_2(); + + state._fsp--; + + + } + break; + + default : + break loop49; + } + } while (true); + + after(grammarAccess.getNodeAccess().getParameterAssignment_3_6_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__2__Impl" + + + // $ANTLR start "rule__Node__Group_3_6__3" + // InternalRos2Parser.g:8080:1: rule__Node__Group_3_6__3 : rule__Node__Group_3_6__3__Impl ; + public final void rule__Node__Group_3_6__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8084:1: ( rule__Node__Group_3_6__3__Impl ) + // InternalRos2Parser.g:8085:2: rule__Node__Group_3_6__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3_6__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__3" + + + // $ANTLR start "rule__Node__Group_3_6__3__Impl" + // InternalRos2Parser.g:8091:1: rule__Node__Group_3_6__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3_6__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8095:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:8096:1: ( RULE_END ) + { + // InternalRos2Parser.g:8096:1: ( RULE_END ) + // InternalRos2Parser.g:8097:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3_6__3__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__0" + // InternalRos2Parser.g:8107:1: rule__TopicSpec__Group__0 : rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 ; + public final void rule__TopicSpec__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8111:1: ( rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 ) + // InternalRos2Parser.g:8112:2: rule__TopicSpec__Group__0__Impl rule__TopicSpec__Group__1 + { + pushFollow(FOLLOW_35); + rule__TopicSpec__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__0" + + + // $ANTLR start "rule__TopicSpec__Group__0__Impl" + // InternalRos2Parser.g:8119:1: rule__TopicSpec__Group__0__Impl : ( () ) ; + public final void rule__TopicSpec__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8123:1: ( ( () ) ) + // InternalRos2Parser.g:8124:1: ( () ) + { + // InternalRos2Parser.g:8124:1: ( () ) + // InternalRos2Parser.g:8125:2: () + { + before(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); + // InternalRos2Parser.g:8126:2: () + // InternalRos2Parser.g:8126:3: + { + } + + after(grammarAccess.getTopicSpecAccess().getTopicSpecAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__0__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__1" + // InternalRos2Parser.g:8134:1: rule__TopicSpec__Group__1 : rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 ; + public final void rule__TopicSpec__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8138:1: ( rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 ) + // InternalRos2Parser.g:8139:2: rule__TopicSpec__Group__1__Impl rule__TopicSpec__Group__2 + { + pushFollow(FOLLOW_36); + rule__TopicSpec__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__1" + + + // $ANTLR start "rule__TopicSpec__Group__1__Impl" + // InternalRos2Parser.g:8146:1: rule__TopicSpec__Group__1__Impl : ( Msg ) ; + public final void rule__TopicSpec__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8150:1: ( ( Msg ) ) + // InternalRos2Parser.g:8151:1: ( Msg ) + { + // InternalRos2Parser.g:8151:1: ( Msg ) + // InternalRos2Parser.g:8152:2: Msg + { + before(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); + match(input,Msg,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__1__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__2" + // InternalRos2Parser.g:8161:1: rule__TopicSpec__Group__2 : rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 ; + public final void rule__TopicSpec__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8165:1: ( rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 ) + // InternalRos2Parser.g:8166:2: rule__TopicSpec__Group__2__Impl rule__TopicSpec__Group__3 + { + pushFollow(FOLLOW_5); + rule__TopicSpec__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__2" + + + // $ANTLR start "rule__TopicSpec__Group__2__Impl" + // InternalRos2Parser.g:8173:1: rule__TopicSpec__Group__2__Impl : ( ( rule__TopicSpec__NameAssignment_2 ) ) ; + public final void rule__TopicSpec__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8177:1: ( ( ( rule__TopicSpec__NameAssignment_2 ) ) ) + // InternalRos2Parser.g:8178:1: ( ( rule__TopicSpec__NameAssignment_2 ) ) + { + // InternalRos2Parser.g:8178:1: ( ( rule__TopicSpec__NameAssignment_2 ) ) + // InternalRos2Parser.g:8179:2: ( rule__TopicSpec__NameAssignment_2 ) + { + before(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); + // InternalRos2Parser.g:8180:2: ( rule__TopicSpec__NameAssignment_2 ) + // InternalRos2Parser.g:8180:3: rule__TopicSpec__NameAssignment_2 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__NameAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getTopicSpecAccess().getNameAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__2__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__3" + // InternalRos2Parser.g:8188:1: rule__TopicSpec__Group__3 : rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 ; + public final void rule__TopicSpec__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8192:1: ( rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 ) + // InternalRos2Parser.g:8193:2: rule__TopicSpec__Group__3__Impl rule__TopicSpec__Group__4 + { + pushFollow(FOLLOW_37); + rule__TopicSpec__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__3" + + + // $ANTLR start "rule__TopicSpec__Group__3__Impl" + // InternalRos2Parser.g:8200:1: rule__TopicSpec__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__TopicSpec__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8204:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:8205:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:8205:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:8206:2: RULE_BEGIN + { + before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__3__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__4" + // InternalRos2Parser.g:8215:1: rule__TopicSpec__Group__4 : rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 ; + public final void rule__TopicSpec__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8219:1: ( rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 ) + // InternalRos2Parser.g:8220:2: rule__TopicSpec__Group__4__Impl rule__TopicSpec__Group__5 + { + pushFollow(FOLLOW_38); + rule__TopicSpec__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__4" + + + // $ANTLR start "rule__TopicSpec__Group__4__Impl" + // InternalRos2Parser.g:8227:1: rule__TopicSpec__Group__4__Impl : ( Message_1 ) ; + public final void rule__TopicSpec__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8231:1: ( ( Message_1 ) ) + // InternalRos2Parser.g:8232:1: ( Message_1 ) + { + // InternalRos2Parser.g:8232:1: ( Message_1 ) + // InternalRos2Parser.g:8233:2: Message_1 + { + before(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); + match(input,Message_1,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__4__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__5" + // InternalRos2Parser.g:8242:1: rule__TopicSpec__Group__5 : rule__TopicSpec__Group__5__Impl rule__TopicSpec__Group__6 ; + public final void rule__TopicSpec__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8246:1: ( rule__TopicSpec__Group__5__Impl rule__TopicSpec__Group__6 ) + // InternalRos2Parser.g:8247:2: rule__TopicSpec__Group__5__Impl rule__TopicSpec__Group__6 + { + pushFollow(FOLLOW_38); + rule__TopicSpec__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__5" + + + // $ANTLR start "rule__TopicSpec__Group__5__Impl" + // InternalRos2Parser.g:8254:1: rule__TopicSpec__Group__5__Impl : ( ( rule__TopicSpec__Group_5__0 )? ) ; + public final void rule__TopicSpec__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8258:1: ( ( ( rule__TopicSpec__Group_5__0 )? ) ) + // InternalRos2Parser.g:8259:1: ( ( rule__TopicSpec__Group_5__0 )? ) + { + // InternalRos2Parser.g:8259:1: ( ( rule__TopicSpec__Group_5__0 )? ) + // InternalRos2Parser.g:8260:2: ( rule__TopicSpec__Group_5__0 )? + { + before(grammarAccess.getTopicSpecAccess().getGroup_5()); + // InternalRos2Parser.g:8261:2: ( rule__TopicSpec__Group_5__0 )? + int alt50=2; + int LA50_0 = input.LA(1); + + if ( (LA50_0==RULE_BEGIN) ) { + alt50=1; + } + switch (alt50) { + case 1 : + // InternalRos2Parser.g:8261:3: rule__TopicSpec__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getTopicSpecAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__5__Impl" + + + // $ANTLR start "rule__TopicSpec__Group__6" + // InternalRos2Parser.g:8269:1: rule__TopicSpec__Group__6 : rule__TopicSpec__Group__6__Impl ; + public final void rule__TopicSpec__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8273:1: ( rule__TopicSpec__Group__6__Impl ) + // InternalRos2Parser.g:8274:2: rule__TopicSpec__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__TopicSpec__Group__6__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__6" + + + // $ANTLR start "rule__TopicSpec__Group__6__Impl" + // InternalRos2Parser.g:8280:1: rule__TopicSpec__Group__6__Impl : ( RULE_END ) ; + public final void rule__TopicSpec__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8284:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:8285:1: ( RULE_END ) + { + // InternalRos2Parser.g:8285:1: ( RULE_END ) + // InternalRos2Parser.g:8286:2: RULE_END + { + before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group__6__Impl" + + + // $ANTLR start "rule__TopicSpec__Group_5__0" + // InternalRos2Parser.g:8296:1: rule__TopicSpec__Group_5__0 : rule__TopicSpec__Group_5__0__Impl rule__TopicSpec__Group_5__1 ; + public final void rule__TopicSpec__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8300:1: ( rule__TopicSpec__Group_5__0__Impl rule__TopicSpec__Group_5__1 ) + // InternalRos2Parser.g:8301:2: rule__TopicSpec__Group_5__0__Impl rule__TopicSpec__Group_5__1 + { + pushFollow(FOLLOW_39); + rule__TopicSpec__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__0" + + + // $ANTLR start "rule__TopicSpec__Group_5__0__Impl" + // InternalRos2Parser.g:8308:1: rule__TopicSpec__Group_5__0__Impl : ( RULE_BEGIN ) ; + public final void rule__TopicSpec__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8312:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:8313:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:8313:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:8314:2: RULE_BEGIN + { + before(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__0__Impl" + + + // $ANTLR start "rule__TopicSpec__Group_5__1" + // InternalRos2Parser.g:8323:1: rule__TopicSpec__Group_5__1 : rule__TopicSpec__Group_5__1__Impl rule__TopicSpec__Group_5__2 ; + public final void rule__TopicSpec__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8327:1: ( rule__TopicSpec__Group_5__1__Impl rule__TopicSpec__Group_5__2 ) + // InternalRos2Parser.g:8328:2: rule__TopicSpec__Group_5__1__Impl rule__TopicSpec__Group_5__2 + { + pushFollow(FOLLOW_23); + rule__TopicSpec__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TopicSpec__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__1" + + + // $ANTLR start "rule__TopicSpec__Group_5__1__Impl" + // InternalRos2Parser.g:8335:1: rule__TopicSpec__Group_5__1__Impl : ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) ; + public final void rule__TopicSpec__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8339:1: ( ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) ) + // InternalRos2Parser.g:8340:1: ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) + { + // InternalRos2Parser.g:8340:1: ( ( rule__TopicSpec__MessageAssignment_5_1 ) ) + // InternalRos2Parser.g:8341:2: ( rule__TopicSpec__MessageAssignment_5_1 ) + { + before(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); + // InternalRos2Parser.g:8342:2: ( rule__TopicSpec__MessageAssignment_5_1 ) + // InternalRos2Parser.g:8342:3: rule__TopicSpec__MessageAssignment_5_1 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__MessageAssignment_5_1(); + + state._fsp--; + + + } + + after(grammarAccess.getTopicSpecAccess().getMessageAssignment_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__1__Impl" + + + // $ANTLR start "rule__TopicSpec__Group_5__2" + // InternalRos2Parser.g:8350:1: rule__TopicSpec__Group_5__2 : rule__TopicSpec__Group_5__2__Impl ; + public final void rule__TopicSpec__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8354:1: ( rule__TopicSpec__Group_5__2__Impl ) + // InternalRos2Parser.g:8355:2: rule__TopicSpec__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__TopicSpec__Group_5__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__2" + + + // $ANTLR start "rule__TopicSpec__Group_5__2__Impl" + // InternalRos2Parser.g:8361:1: rule__TopicSpec__Group_5__2__Impl : ( RULE_END ) ; + public final void rule__TopicSpec__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8365:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:8366:1: ( RULE_END ) + { + // InternalRos2Parser.g:8366:1: ( RULE_END ) + // InternalRos2Parser.g:8367:2: RULE_END + { + before(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__Group_5__2__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__0" + // InternalRos2Parser.g:8377:1: rule__ServiceSpec__Group__0 : rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 ; + public final void rule__ServiceSpec__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8381:1: ( rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 ) + // InternalRos2Parser.g:8382:2: rule__ServiceSpec__Group__0__Impl rule__ServiceSpec__Group__1 + { + pushFollow(FOLLOW_40); + rule__ServiceSpec__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__0" + + + // $ANTLR start "rule__ServiceSpec__Group__0__Impl" + // InternalRos2Parser.g:8389:1: rule__ServiceSpec__Group__0__Impl : ( () ) ; + public final void rule__ServiceSpec__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8393:1: ( ( () ) ) + // InternalRos2Parser.g:8394:1: ( () ) + { + // InternalRos2Parser.g:8394:1: ( () ) + // InternalRos2Parser.g:8395:2: () + { + before(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); + // InternalRos2Parser.g:8396:2: () + // InternalRos2Parser.g:8396:3: + { + } + + after(grammarAccess.getServiceSpecAccess().getServiceSpecAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__0__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__1" + // InternalRos2Parser.g:8404:1: rule__ServiceSpec__Group__1 : rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 ; + public final void rule__ServiceSpec__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8408:1: ( rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 ) + // InternalRos2Parser.g:8409:2: rule__ServiceSpec__Group__1__Impl rule__ServiceSpec__Group__2 + { + pushFollow(FOLLOW_7); + rule__ServiceSpec__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__1" + + + // $ANTLR start "rule__ServiceSpec__Group__1__Impl" + // InternalRos2Parser.g:8416:1: rule__ServiceSpec__Group__1__Impl : ( Srv ) ; + public final void rule__ServiceSpec__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8420:1: ( ( Srv ) ) + // InternalRos2Parser.g:8421:1: ( Srv ) + { + // InternalRos2Parser.g:8421:1: ( Srv ) + // InternalRos2Parser.g:8422:2: Srv + { + before(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); + match(input,Srv,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__1__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__2" + // InternalRos2Parser.g:8431:1: rule__ServiceSpec__Group__2 : rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 ; + public final void rule__ServiceSpec__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8435:1: ( rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 ) + // InternalRos2Parser.g:8436:2: rule__ServiceSpec__Group__2__Impl rule__ServiceSpec__Group__3 + { + pushFollow(FOLLOW_5); + rule__ServiceSpec__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__2" + + + // $ANTLR start "rule__ServiceSpec__Group__2__Impl" + // InternalRos2Parser.g:8443:1: rule__ServiceSpec__Group__2__Impl : ( ( rule__ServiceSpec__NameAssignment_2 ) ) ; + public final void rule__ServiceSpec__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8447:1: ( ( ( rule__ServiceSpec__NameAssignment_2 ) ) ) + // InternalRos2Parser.g:8448:1: ( ( rule__ServiceSpec__NameAssignment_2 ) ) + { + // InternalRos2Parser.g:8448:1: ( ( rule__ServiceSpec__NameAssignment_2 ) ) + // InternalRos2Parser.g:8449:2: ( rule__ServiceSpec__NameAssignment_2 ) + { + before(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); + // InternalRos2Parser.g:8450:2: ( rule__ServiceSpec__NameAssignment_2 ) + // InternalRos2Parser.g:8450:3: rule__ServiceSpec__NameAssignment_2 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__NameAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceSpecAccess().getNameAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__2__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__3" + // InternalRos2Parser.g:8458:1: rule__ServiceSpec__Group__3 : rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 ; + public final void rule__ServiceSpec__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8462:1: ( rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 ) + // InternalRos2Parser.g:8463:2: rule__ServiceSpec__Group__3__Impl rule__ServiceSpec__Group__4 + { + pushFollow(FOLLOW_41); + rule__ServiceSpec__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__3" + + + // $ANTLR start "rule__ServiceSpec__Group__3__Impl" + // InternalRos2Parser.g:8470:1: rule__ServiceSpec__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceSpec__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8474:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:8475:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:8475:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:8476:2: RULE_BEGIN + { + before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__3__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__4" + // InternalRos2Parser.g:8485:1: rule__ServiceSpec__Group__4 : rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 ; + public final void rule__ServiceSpec__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8489:1: ( rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 ) + // InternalRos2Parser.g:8490:2: rule__ServiceSpec__Group__4__Impl rule__ServiceSpec__Group__5 + { + pushFollow(FOLLOW_42); + rule__ServiceSpec__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__4" + + + // $ANTLR start "rule__ServiceSpec__Group__4__Impl" + // InternalRos2Parser.g:8497:1: rule__ServiceSpec__Group__4__Impl : ( Request ) ; + public final void rule__ServiceSpec__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8501:1: ( ( Request ) ) + // InternalRos2Parser.g:8502:1: ( Request ) + { + // InternalRos2Parser.g:8502:1: ( Request ) + // InternalRos2Parser.g:8503:2: Request + { + before(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); + match(input,Request,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__4__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__5" + // InternalRos2Parser.g:8512:1: rule__ServiceSpec__Group__5 : rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 ; + public final void rule__ServiceSpec__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8516:1: ( rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 ) + // InternalRos2Parser.g:8517:2: rule__ServiceSpec__Group__5__Impl rule__ServiceSpec__Group__6 + { + pushFollow(FOLLOW_42); + rule__ServiceSpec__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__5" + + + // $ANTLR start "rule__ServiceSpec__Group__5__Impl" + // InternalRos2Parser.g:8524:1: rule__ServiceSpec__Group__5__Impl : ( ( rule__ServiceSpec__Group_5__0 )? ) ; + public final void rule__ServiceSpec__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8528:1: ( ( ( rule__ServiceSpec__Group_5__0 )? ) ) + // InternalRos2Parser.g:8529:1: ( ( rule__ServiceSpec__Group_5__0 )? ) + { + // InternalRos2Parser.g:8529:1: ( ( rule__ServiceSpec__Group_5__0 )? ) + // InternalRos2Parser.g:8530:2: ( rule__ServiceSpec__Group_5__0 )? + { + before(grammarAccess.getServiceSpecAccess().getGroup_5()); + // InternalRos2Parser.g:8531:2: ( rule__ServiceSpec__Group_5__0 )? + int alt51=2; + int LA51_0 = input.LA(1); + + if ( (LA51_0==RULE_BEGIN) ) { + alt51=1; + } + switch (alt51) { + case 1 : + // InternalRos2Parser.g:8531:3: rule__ServiceSpec__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceSpecAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__5__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__6" + // InternalRos2Parser.g:8539:1: rule__ServiceSpec__Group__6 : rule__ServiceSpec__Group__6__Impl rule__ServiceSpec__Group__7 ; + public final void rule__ServiceSpec__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8543:1: ( rule__ServiceSpec__Group__6__Impl rule__ServiceSpec__Group__7 ) + // InternalRos2Parser.g:8544:2: rule__ServiceSpec__Group__6__Impl rule__ServiceSpec__Group__7 + { + pushFollow(FOLLOW_38); + rule__ServiceSpec__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__6" + + + // $ANTLR start "rule__ServiceSpec__Group__6__Impl" + // InternalRos2Parser.g:8551:1: rule__ServiceSpec__Group__6__Impl : ( Response ) ; + public final void rule__ServiceSpec__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8555:1: ( ( Response ) ) + // InternalRos2Parser.g:8556:1: ( Response ) + { + // InternalRos2Parser.g:8556:1: ( Response ) + // InternalRos2Parser.g:8557:2: Response + { + before(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); + match(input,Response,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__6__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__7" + // InternalRos2Parser.g:8566:1: rule__ServiceSpec__Group__7 : rule__ServiceSpec__Group__7__Impl rule__ServiceSpec__Group__8 ; + public final void rule__ServiceSpec__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8570:1: ( rule__ServiceSpec__Group__7__Impl rule__ServiceSpec__Group__8 ) + // InternalRos2Parser.g:8571:2: rule__ServiceSpec__Group__7__Impl rule__ServiceSpec__Group__8 + { + pushFollow(FOLLOW_38); + rule__ServiceSpec__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__7" + + + // $ANTLR start "rule__ServiceSpec__Group__7__Impl" + // InternalRos2Parser.g:8578:1: rule__ServiceSpec__Group__7__Impl : ( ( rule__ServiceSpec__Group_7__0 )? ) ; + public final void rule__ServiceSpec__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8582:1: ( ( ( rule__ServiceSpec__Group_7__0 )? ) ) + // InternalRos2Parser.g:8583:1: ( ( rule__ServiceSpec__Group_7__0 )? ) + { + // InternalRos2Parser.g:8583:1: ( ( rule__ServiceSpec__Group_7__0 )? ) + // InternalRos2Parser.g:8584:2: ( rule__ServiceSpec__Group_7__0 )? + { + before(grammarAccess.getServiceSpecAccess().getGroup_7()); + // InternalRos2Parser.g:8585:2: ( rule__ServiceSpec__Group_7__0 )? + int alt52=2; + int LA52_0 = input.LA(1); + + if ( (LA52_0==RULE_BEGIN) ) { + alt52=1; + } + switch (alt52) { + case 1 : + // InternalRos2Parser.g:8585:3: rule__ServiceSpec__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getServiceSpecAccess().getGroup_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__7__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group__8" + // InternalRos2Parser.g:8593:1: rule__ServiceSpec__Group__8 : rule__ServiceSpec__Group__8__Impl ; + public final void rule__ServiceSpec__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8597:1: ( rule__ServiceSpec__Group__8__Impl ) + // InternalRos2Parser.g:8598:2: rule__ServiceSpec__Group__8__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group__8__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__8" + + + // $ANTLR start "rule__ServiceSpec__Group__8__Impl" + // InternalRos2Parser.g:8604:1: rule__ServiceSpec__Group__8__Impl : ( RULE_END ) ; + public final void rule__ServiceSpec__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8608:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:8609:1: ( RULE_END ) + { + // InternalRos2Parser.g:8609:1: ( RULE_END ) + // InternalRos2Parser.g:8610:2: RULE_END + { + before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group__8__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_5__0" + // InternalRos2Parser.g:8620:1: rule__ServiceSpec__Group_5__0 : rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 ; + public final void rule__ServiceSpec__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8624:1: ( rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 ) + // InternalRos2Parser.g:8625:2: rule__ServiceSpec__Group_5__0__Impl rule__ServiceSpec__Group_5__1 + { + pushFollow(FOLLOW_39); + rule__ServiceSpec__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__0" + + + // $ANTLR start "rule__ServiceSpec__Group_5__0__Impl" + // InternalRos2Parser.g:8632:1: rule__ServiceSpec__Group_5__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceSpec__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8636:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:8637:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:8637:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:8638:2: RULE_BEGIN + { + before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__0__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_5__1" + // InternalRos2Parser.g:8647:1: rule__ServiceSpec__Group_5__1 : rule__ServiceSpec__Group_5__1__Impl rule__ServiceSpec__Group_5__2 ; + public final void rule__ServiceSpec__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8651:1: ( rule__ServiceSpec__Group_5__1__Impl rule__ServiceSpec__Group_5__2 ) + // InternalRos2Parser.g:8652:2: rule__ServiceSpec__Group_5__1__Impl rule__ServiceSpec__Group_5__2 + { + pushFollow(FOLLOW_23); + rule__ServiceSpec__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__1" + + + // $ANTLR start "rule__ServiceSpec__Group_5__1__Impl" + // InternalRos2Parser.g:8659:1: rule__ServiceSpec__Group_5__1__Impl : ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) ; + public final void rule__ServiceSpec__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8663:1: ( ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) ) + // InternalRos2Parser.g:8664:1: ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) + { + // InternalRos2Parser.g:8664:1: ( ( rule__ServiceSpec__RequestAssignment_5_1 ) ) + // InternalRos2Parser.g:8665:2: ( rule__ServiceSpec__RequestAssignment_5_1 ) + { + before(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); + // InternalRos2Parser.g:8666:2: ( rule__ServiceSpec__RequestAssignment_5_1 ) + // InternalRos2Parser.g:8666:3: rule__ServiceSpec__RequestAssignment_5_1 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__RequestAssignment_5_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceSpecAccess().getRequestAssignment_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__1__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_5__2" + // InternalRos2Parser.g:8674:1: rule__ServiceSpec__Group_5__2 : rule__ServiceSpec__Group_5__2__Impl ; + public final void rule__ServiceSpec__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8678:1: ( rule__ServiceSpec__Group_5__2__Impl ) + // InternalRos2Parser.g:8679:2: rule__ServiceSpec__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_5__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__2" + + + // $ANTLR start "rule__ServiceSpec__Group_5__2__Impl" + // InternalRos2Parser.g:8685:1: rule__ServiceSpec__Group_5__2__Impl : ( RULE_END ) ; + public final void rule__ServiceSpec__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8689:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:8690:1: ( RULE_END ) + { + // InternalRos2Parser.g:8690:1: ( RULE_END ) + // InternalRos2Parser.g:8691:2: RULE_END + { + before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_5__2__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_7__0" + // InternalRos2Parser.g:8701:1: rule__ServiceSpec__Group_7__0 : rule__ServiceSpec__Group_7__0__Impl rule__ServiceSpec__Group_7__1 ; + public final void rule__ServiceSpec__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8705:1: ( rule__ServiceSpec__Group_7__0__Impl rule__ServiceSpec__Group_7__1 ) + // InternalRos2Parser.g:8706:2: rule__ServiceSpec__Group_7__0__Impl rule__ServiceSpec__Group_7__1 + { + pushFollow(FOLLOW_39); + rule__ServiceSpec__Group_7__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_7__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__0" + + + // $ANTLR start "rule__ServiceSpec__Group_7__0__Impl" + // InternalRos2Parser.g:8713:1: rule__ServiceSpec__Group_7__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ServiceSpec__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8717:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:8718:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:8718:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:8719:2: RULE_BEGIN + { + before(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__0__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_7__1" + // InternalRos2Parser.g:8728:1: rule__ServiceSpec__Group_7__1 : rule__ServiceSpec__Group_7__1__Impl rule__ServiceSpec__Group_7__2 ; + public final void rule__ServiceSpec__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8732:1: ( rule__ServiceSpec__Group_7__1__Impl rule__ServiceSpec__Group_7__2 ) + // InternalRos2Parser.g:8733:2: rule__ServiceSpec__Group_7__1__Impl rule__ServiceSpec__Group_7__2 + { + pushFollow(FOLLOW_23); + rule__ServiceSpec__Group_7__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_7__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__1" + + + // $ANTLR start "rule__ServiceSpec__Group_7__1__Impl" + // InternalRos2Parser.g:8740:1: rule__ServiceSpec__Group_7__1__Impl : ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) ; + public final void rule__ServiceSpec__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8744:1: ( ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) ) + // InternalRos2Parser.g:8745:1: ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) + { + // InternalRos2Parser.g:8745:1: ( ( rule__ServiceSpec__ResponseAssignment_7_1 ) ) + // InternalRos2Parser.g:8746:2: ( rule__ServiceSpec__ResponseAssignment_7_1 ) + { + before(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); + // InternalRos2Parser.g:8747:2: ( rule__ServiceSpec__ResponseAssignment_7_1 ) + // InternalRos2Parser.g:8747:3: rule__ServiceSpec__ResponseAssignment_7_1 + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__ResponseAssignment_7_1(); + + state._fsp--; + + + } + + after(grammarAccess.getServiceSpecAccess().getResponseAssignment_7_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__1__Impl" + + + // $ANTLR start "rule__ServiceSpec__Group_7__2" + // InternalRos2Parser.g:8755:1: rule__ServiceSpec__Group_7__2 : rule__ServiceSpec__Group_7__2__Impl ; + public final void rule__ServiceSpec__Group_7__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8759:1: ( rule__ServiceSpec__Group_7__2__Impl ) + // InternalRos2Parser.g:8760:2: rule__ServiceSpec__Group_7__2__Impl + { + pushFollow(FOLLOW_2); + rule__ServiceSpec__Group_7__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__2" + + + // $ANTLR start "rule__ServiceSpec__Group_7__2__Impl" + // InternalRos2Parser.g:8766:1: rule__ServiceSpec__Group_7__2__Impl : ( RULE_END ) ; + public final void rule__ServiceSpec__Group_7__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8770:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:8771:1: ( RULE_END ) + { + // InternalRos2Parser.g:8771:1: ( RULE_END ) + // InternalRos2Parser.g:8772:2: RULE_END + { + before(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__Group_7__2__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__0" + // InternalRos2Parser.g:8782:1: rule__ActionSpec__Group__0 : rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 ; + public final void rule__ActionSpec__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8786:1: ( rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 ) + // InternalRos2Parser.g:8787:2: rule__ActionSpec__Group__0__Impl rule__ActionSpec__Group__1 + { + pushFollow(FOLLOW_43); + rule__ActionSpec__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__0" + + + // $ANTLR start "rule__ActionSpec__Group__0__Impl" + // InternalRos2Parser.g:8794:1: rule__ActionSpec__Group__0__Impl : ( () ) ; + public final void rule__ActionSpec__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8798:1: ( ( () ) ) + // InternalRos2Parser.g:8799:1: ( () ) + { + // InternalRos2Parser.g:8799:1: ( () ) + // InternalRos2Parser.g:8800:2: () + { + before(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); + // InternalRos2Parser.g:8801:2: () + // InternalRos2Parser.g:8801:3: + { + } + + after(grammarAccess.getActionSpecAccess().getActionSpecAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__0__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__1" + // InternalRos2Parser.g:8809:1: rule__ActionSpec__Group__1 : rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 ; + public final void rule__ActionSpec__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8813:1: ( rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 ) + // InternalRos2Parser.g:8814:2: rule__ActionSpec__Group__1__Impl rule__ActionSpec__Group__2 + { + pushFollow(FOLLOW_7); + rule__ActionSpec__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__1" + + + // $ANTLR start "rule__ActionSpec__Group__1__Impl" + // InternalRos2Parser.g:8821:1: rule__ActionSpec__Group__1__Impl : ( Action_1 ) ; + public final void rule__ActionSpec__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8825:1: ( ( Action_1 ) ) + // InternalRos2Parser.g:8826:1: ( Action_1 ) + { + // InternalRos2Parser.g:8826:1: ( Action_1 ) + // InternalRos2Parser.g:8827:2: Action_1 + { + before(grammarAccess.getActionSpecAccess().getActionKeyword_1()); + match(input,Action_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getActionKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__1__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__2" + // InternalRos2Parser.g:8836:1: rule__ActionSpec__Group__2 : rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 ; + public final void rule__ActionSpec__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8840:1: ( rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 ) + // InternalRos2Parser.g:8841:2: rule__ActionSpec__Group__2__Impl rule__ActionSpec__Group__3 + { + pushFollow(FOLLOW_5); + rule__ActionSpec__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__2" + + + // $ANTLR start "rule__ActionSpec__Group__2__Impl" + // InternalRos2Parser.g:8848:1: rule__ActionSpec__Group__2__Impl : ( ( rule__ActionSpec__NameAssignment_2 ) ) ; + public final void rule__ActionSpec__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8852:1: ( ( ( rule__ActionSpec__NameAssignment_2 ) ) ) + // InternalRos2Parser.g:8853:1: ( ( rule__ActionSpec__NameAssignment_2 ) ) + { + // InternalRos2Parser.g:8853:1: ( ( rule__ActionSpec__NameAssignment_2 ) ) + // InternalRos2Parser.g:8854:2: ( rule__ActionSpec__NameAssignment_2 ) + { + before(grammarAccess.getActionSpecAccess().getNameAssignment_2()); + // InternalRos2Parser.g:8855:2: ( rule__ActionSpec__NameAssignment_2 ) + // InternalRos2Parser.g:8855:3: rule__ActionSpec__NameAssignment_2 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__NameAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getActionSpecAccess().getNameAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__2__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__3" + // InternalRos2Parser.g:8863:1: rule__ActionSpec__Group__3 : rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 ; + public final void rule__ActionSpec__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8867:1: ( rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 ) + // InternalRos2Parser.g:8868:2: rule__ActionSpec__Group__3__Impl rule__ActionSpec__Group__4 + { + pushFollow(FOLLOW_44); + rule__ActionSpec__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__3" + + + // $ANTLR start "rule__ActionSpec__Group__3__Impl" + // InternalRos2Parser.g:8875:1: rule__ActionSpec__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8879:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:8880:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:8880:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:8881:2: RULE_BEGIN + { + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__3__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__4" + // InternalRos2Parser.g:8890:1: rule__ActionSpec__Group__4 : rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 ; + public final void rule__ActionSpec__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8894:1: ( rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 ) + // InternalRos2Parser.g:8895:2: rule__ActionSpec__Group__4__Impl rule__ActionSpec__Group__5 + { + pushFollow(FOLLOW_45); + rule__ActionSpec__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__4" + + + // $ANTLR start "rule__ActionSpec__Group__4__Impl" + // InternalRos2Parser.g:8902:1: rule__ActionSpec__Group__4__Impl : ( Goal_1 ) ; + public final void rule__ActionSpec__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8906:1: ( ( Goal_1 ) ) + // InternalRos2Parser.g:8907:1: ( Goal_1 ) + { + // InternalRos2Parser.g:8907:1: ( Goal_1 ) + // InternalRos2Parser.g:8908:2: Goal_1 + { + before(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); + match(input,Goal_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getGoalKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__4__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__5" + // InternalRos2Parser.g:8917:1: rule__ActionSpec__Group__5 : rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 ; + public final void rule__ActionSpec__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8921:1: ( rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 ) + // InternalRos2Parser.g:8922:2: rule__ActionSpec__Group__5__Impl rule__ActionSpec__Group__6 + { + pushFollow(FOLLOW_45); + rule__ActionSpec__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__5" + + + // $ANTLR start "rule__ActionSpec__Group__5__Impl" + // InternalRos2Parser.g:8929:1: rule__ActionSpec__Group__5__Impl : ( ( rule__ActionSpec__Group_5__0 )? ) ; + public final void rule__ActionSpec__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8933:1: ( ( ( rule__ActionSpec__Group_5__0 )? ) ) + // InternalRos2Parser.g:8934:1: ( ( rule__ActionSpec__Group_5__0 )? ) + { + // InternalRos2Parser.g:8934:1: ( ( rule__ActionSpec__Group_5__0 )? ) + // InternalRos2Parser.g:8935:2: ( rule__ActionSpec__Group_5__0 )? + { + before(grammarAccess.getActionSpecAccess().getGroup_5()); + // InternalRos2Parser.g:8936:2: ( rule__ActionSpec__Group_5__0 )? + int alt53=2; + int LA53_0 = input.LA(1); + + if ( (LA53_0==RULE_BEGIN) ) { + alt53=1; + } + switch (alt53) { + case 1 : + // InternalRos2Parser.g:8936:3: rule__ActionSpec__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionSpecAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__5__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__6" + // InternalRos2Parser.g:8944:1: rule__ActionSpec__Group__6 : rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 ; + public final void rule__ActionSpec__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8948:1: ( rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 ) + // InternalRos2Parser.g:8949:2: rule__ActionSpec__Group__6__Impl rule__ActionSpec__Group__7 + { + pushFollow(FOLLOW_46); + rule__ActionSpec__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__6" + + + // $ANTLR start "rule__ActionSpec__Group__6__Impl" + // InternalRos2Parser.g:8956:1: rule__ActionSpec__Group__6__Impl : ( Result_1 ) ; + public final void rule__ActionSpec__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8960:1: ( ( Result_1 ) ) + // InternalRos2Parser.g:8961:1: ( Result_1 ) + { + // InternalRos2Parser.g:8961:1: ( Result_1 ) + // InternalRos2Parser.g:8962:2: Result_1 + { + before(grammarAccess.getActionSpecAccess().getResultKeyword_6()); + match(input,Result_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getResultKeyword_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__6__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__7" + // InternalRos2Parser.g:8971:1: rule__ActionSpec__Group__7 : rule__ActionSpec__Group__7__Impl rule__ActionSpec__Group__8 ; + public final void rule__ActionSpec__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8975:1: ( rule__ActionSpec__Group__7__Impl rule__ActionSpec__Group__8 ) + // InternalRos2Parser.g:8976:2: rule__ActionSpec__Group__7__Impl rule__ActionSpec__Group__8 + { + pushFollow(FOLLOW_46); + rule__ActionSpec__Group__7__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__8(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__7" + + + // $ANTLR start "rule__ActionSpec__Group__7__Impl" + // InternalRos2Parser.g:8983:1: rule__ActionSpec__Group__7__Impl : ( ( rule__ActionSpec__Group_7__0 )? ) ; + public final void rule__ActionSpec__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:8987:1: ( ( ( rule__ActionSpec__Group_7__0 )? ) ) + // InternalRos2Parser.g:8988:1: ( ( rule__ActionSpec__Group_7__0 )? ) + { + // InternalRos2Parser.g:8988:1: ( ( rule__ActionSpec__Group_7__0 )? ) + // InternalRos2Parser.g:8989:2: ( rule__ActionSpec__Group_7__0 )? + { + before(grammarAccess.getActionSpecAccess().getGroup_7()); + // InternalRos2Parser.g:8990:2: ( rule__ActionSpec__Group_7__0 )? + int alt54=2; + int LA54_0 = input.LA(1); + + if ( (LA54_0==RULE_BEGIN) ) { + alt54=1; + } + switch (alt54) { + case 1 : + // InternalRos2Parser.g:8990:3: rule__ActionSpec__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_7__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionSpecAccess().getGroup_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__7__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__8" + // InternalRos2Parser.g:8998:1: rule__ActionSpec__Group__8 : rule__ActionSpec__Group__8__Impl rule__ActionSpec__Group__9 ; + public final void rule__ActionSpec__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9002:1: ( rule__ActionSpec__Group__8__Impl rule__ActionSpec__Group__9 ) + // InternalRos2Parser.g:9003:2: rule__ActionSpec__Group__8__Impl rule__ActionSpec__Group__9 + { + pushFollow(FOLLOW_38); + rule__ActionSpec__Group__8__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__9(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__8" + + + // $ANTLR start "rule__ActionSpec__Group__8__Impl" + // InternalRos2Parser.g:9010:1: rule__ActionSpec__Group__8__Impl : ( Feedback_1 ) ; + public final void rule__ActionSpec__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9014:1: ( ( Feedback_1 ) ) + // InternalRos2Parser.g:9015:1: ( Feedback_1 ) + { + // InternalRos2Parser.g:9015:1: ( Feedback_1 ) + // InternalRos2Parser.g:9016:2: Feedback_1 + { + before(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + match(input,Feedback_1,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__8__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__9" + // InternalRos2Parser.g:9025:1: rule__ActionSpec__Group__9 : rule__ActionSpec__Group__9__Impl rule__ActionSpec__Group__10 ; + public final void rule__ActionSpec__Group__9() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9029:1: ( rule__ActionSpec__Group__9__Impl rule__ActionSpec__Group__10 ) + // InternalRos2Parser.g:9030:2: rule__ActionSpec__Group__9__Impl rule__ActionSpec__Group__10 + { + pushFollow(FOLLOW_38); + rule__ActionSpec__Group__9__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__10(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__9" + + + // $ANTLR start "rule__ActionSpec__Group__9__Impl" + // InternalRos2Parser.g:9037:1: rule__ActionSpec__Group__9__Impl : ( ( rule__ActionSpec__Group_9__0 )? ) ; + public final void rule__ActionSpec__Group__9__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9041:1: ( ( ( rule__ActionSpec__Group_9__0 )? ) ) + // InternalRos2Parser.g:9042:1: ( ( rule__ActionSpec__Group_9__0 )? ) + { + // InternalRos2Parser.g:9042:1: ( ( rule__ActionSpec__Group_9__0 )? ) + // InternalRos2Parser.g:9043:2: ( rule__ActionSpec__Group_9__0 )? + { + before(grammarAccess.getActionSpecAccess().getGroup_9()); + // InternalRos2Parser.g:9044:2: ( rule__ActionSpec__Group_9__0 )? + int alt55=2; + int LA55_0 = input.LA(1); + + if ( (LA55_0==RULE_BEGIN) ) { + alt55=1; + } + switch (alt55) { + case 1 : + // InternalRos2Parser.g:9044:3: rule__ActionSpec__Group_9__0 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_9__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getActionSpecAccess().getGroup_9()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__9__Impl" + + + // $ANTLR start "rule__ActionSpec__Group__10" + // InternalRos2Parser.g:9052:1: rule__ActionSpec__Group__10 : rule__ActionSpec__Group__10__Impl ; + public final void rule__ActionSpec__Group__10() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9056:1: ( rule__ActionSpec__Group__10__Impl ) + // InternalRos2Parser.g:9057:2: rule__ActionSpec__Group__10__Impl + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group__10__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__10" + + + // $ANTLR start "rule__ActionSpec__Group__10__Impl" + // InternalRos2Parser.g:9063:1: rule__ActionSpec__Group__10__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group__10__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9067:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:9068:1: ( RULE_END ) + { + // InternalRos2Parser.g:9068:1: ( RULE_END ) + // InternalRos2Parser.g:9069:2: RULE_END + { + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group__10__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_5__0" + // InternalRos2Parser.g:9079:1: rule__ActionSpec__Group_5__0 : rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 ; + public final void rule__ActionSpec__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9083:1: ( rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 ) + // InternalRos2Parser.g:9084:2: rule__ActionSpec__Group_5__0__Impl rule__ActionSpec__Group_5__1 + { + pushFollow(FOLLOW_39); + rule__ActionSpec__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__0" + + + // $ANTLR start "rule__ActionSpec__Group_5__0__Impl" + // InternalRos2Parser.g:9091:1: rule__ActionSpec__Group_5__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9095:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:9096:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:9096:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:9097:2: RULE_BEGIN + { + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__0__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_5__1" + // InternalRos2Parser.g:9106:1: rule__ActionSpec__Group_5__1 : rule__ActionSpec__Group_5__1__Impl rule__ActionSpec__Group_5__2 ; + public final void rule__ActionSpec__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9110:1: ( rule__ActionSpec__Group_5__1__Impl rule__ActionSpec__Group_5__2 ) + // InternalRos2Parser.g:9111:2: rule__ActionSpec__Group_5__1__Impl rule__ActionSpec__Group_5__2 + { + pushFollow(FOLLOW_23); + rule__ActionSpec__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__1" + + + // $ANTLR start "rule__ActionSpec__Group_5__1__Impl" + // InternalRos2Parser.g:9118:1: rule__ActionSpec__Group_5__1__Impl : ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) ; + public final void rule__ActionSpec__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9122:1: ( ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) ) + // InternalRos2Parser.g:9123:1: ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) + { + // InternalRos2Parser.g:9123:1: ( ( rule__ActionSpec__GoalAssignment_5_1 ) ) + // InternalRos2Parser.g:9124:2: ( rule__ActionSpec__GoalAssignment_5_1 ) + { + before(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); + // InternalRos2Parser.g:9125:2: ( rule__ActionSpec__GoalAssignment_5_1 ) + // InternalRos2Parser.g:9125:3: rule__ActionSpec__GoalAssignment_5_1 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__GoalAssignment_5_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionSpecAccess().getGoalAssignment_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__1__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_5__2" + // InternalRos2Parser.g:9133:1: rule__ActionSpec__Group_5__2 : rule__ActionSpec__Group_5__2__Impl ; + public final void rule__ActionSpec__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9137:1: ( rule__ActionSpec__Group_5__2__Impl ) + // InternalRos2Parser.g:9138:2: rule__ActionSpec__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_5__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__2" + + + // $ANTLR start "rule__ActionSpec__Group_5__2__Impl" + // InternalRos2Parser.g:9144:1: rule__ActionSpec__Group_5__2__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9148:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:9149:1: ( RULE_END ) + { + // InternalRos2Parser.g:9149:1: ( RULE_END ) + // InternalRos2Parser.g:9150:2: RULE_END + { + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_5__2__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_7__0" + // InternalRos2Parser.g:9160:1: rule__ActionSpec__Group_7__0 : rule__ActionSpec__Group_7__0__Impl rule__ActionSpec__Group_7__1 ; + public final void rule__ActionSpec__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9164:1: ( rule__ActionSpec__Group_7__0__Impl rule__ActionSpec__Group_7__1 ) + // InternalRos2Parser.g:9165:2: rule__ActionSpec__Group_7__0__Impl rule__ActionSpec__Group_7__1 + { + pushFollow(FOLLOW_39); + rule__ActionSpec__Group_7__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_7__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__0" + + + // $ANTLR start "rule__ActionSpec__Group_7__0__Impl" + // InternalRos2Parser.g:9172:1: rule__ActionSpec__Group_7__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9176:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:9177:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:9177:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:9178:2: RULE_BEGIN + { + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__0__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_7__1" + // InternalRos2Parser.g:9187:1: rule__ActionSpec__Group_7__1 : rule__ActionSpec__Group_7__1__Impl rule__ActionSpec__Group_7__2 ; + public final void rule__ActionSpec__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9191:1: ( rule__ActionSpec__Group_7__1__Impl rule__ActionSpec__Group_7__2 ) + // InternalRos2Parser.g:9192:2: rule__ActionSpec__Group_7__1__Impl rule__ActionSpec__Group_7__2 + { + pushFollow(FOLLOW_23); + rule__ActionSpec__Group_7__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_7__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__1" + + + // $ANTLR start "rule__ActionSpec__Group_7__1__Impl" + // InternalRos2Parser.g:9199:1: rule__ActionSpec__Group_7__1__Impl : ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) ; + public final void rule__ActionSpec__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9203:1: ( ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) ) + // InternalRos2Parser.g:9204:1: ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) + { + // InternalRos2Parser.g:9204:1: ( ( rule__ActionSpec__ResultAssignment_7_1 ) ) + // InternalRos2Parser.g:9205:2: ( rule__ActionSpec__ResultAssignment_7_1 ) + { + before(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); + // InternalRos2Parser.g:9206:2: ( rule__ActionSpec__ResultAssignment_7_1 ) + // InternalRos2Parser.g:9206:3: rule__ActionSpec__ResultAssignment_7_1 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__ResultAssignment_7_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionSpecAccess().getResultAssignment_7_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__1__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_7__2" + // InternalRos2Parser.g:9214:1: rule__ActionSpec__Group_7__2 : rule__ActionSpec__Group_7__2__Impl ; + public final void rule__ActionSpec__Group_7__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9218:1: ( rule__ActionSpec__Group_7__2__Impl ) + // InternalRos2Parser.g:9219:2: rule__ActionSpec__Group_7__2__Impl + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_7__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__2" + + + // $ANTLR start "rule__ActionSpec__Group_7__2__Impl" + // InternalRos2Parser.g:9225:1: rule__ActionSpec__Group_7__2__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group_7__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9229:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:9230:1: ( RULE_END ) + { + // InternalRos2Parser.g:9230:1: ( RULE_END ) + // InternalRos2Parser.g:9231:2: RULE_END + { + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_7__2__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_9__0" + // InternalRos2Parser.g:9241:1: rule__ActionSpec__Group_9__0 : rule__ActionSpec__Group_9__0__Impl rule__ActionSpec__Group_9__1 ; + public final void rule__ActionSpec__Group_9__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9245:1: ( rule__ActionSpec__Group_9__0__Impl rule__ActionSpec__Group_9__1 ) + // InternalRos2Parser.g:9246:2: rule__ActionSpec__Group_9__0__Impl rule__ActionSpec__Group_9__1 + { + pushFollow(FOLLOW_39); + rule__ActionSpec__Group_9__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_9__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__0" + + + // $ANTLR start "rule__ActionSpec__Group_9__0__Impl" + // InternalRos2Parser.g:9253:1: rule__ActionSpec__Group_9__0__Impl : ( RULE_BEGIN ) ; + public final void rule__ActionSpec__Group_9__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9257:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:9258:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:9258:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:9259:2: RULE_BEGIN + { + before(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__0__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_9__1" + // InternalRos2Parser.g:9268:1: rule__ActionSpec__Group_9__1 : rule__ActionSpec__Group_9__1__Impl rule__ActionSpec__Group_9__2 ; + public final void rule__ActionSpec__Group_9__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9272:1: ( rule__ActionSpec__Group_9__1__Impl rule__ActionSpec__Group_9__2 ) + // InternalRos2Parser.g:9273:2: rule__ActionSpec__Group_9__1__Impl rule__ActionSpec__Group_9__2 + { + pushFollow(FOLLOW_23); + rule__ActionSpec__Group_9__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_9__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__1" + + + // $ANTLR start "rule__ActionSpec__Group_9__1__Impl" + // InternalRos2Parser.g:9280:1: rule__ActionSpec__Group_9__1__Impl : ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) ; + public final void rule__ActionSpec__Group_9__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9284:1: ( ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) ) + // InternalRos2Parser.g:9285:1: ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) + { + // InternalRos2Parser.g:9285:1: ( ( rule__ActionSpec__FeedbackAssignment_9_1 ) ) + // InternalRos2Parser.g:9286:2: ( rule__ActionSpec__FeedbackAssignment_9_1 ) + { + before(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); + // InternalRos2Parser.g:9287:2: ( rule__ActionSpec__FeedbackAssignment_9_1 ) + // InternalRos2Parser.g:9287:3: rule__ActionSpec__FeedbackAssignment_9_1 + { + pushFollow(FOLLOW_2); + rule__ActionSpec__FeedbackAssignment_9_1(); + + state._fsp--; + + + } + + after(grammarAccess.getActionSpecAccess().getFeedbackAssignment_9_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__1__Impl" + + + // $ANTLR start "rule__ActionSpec__Group_9__2" + // InternalRos2Parser.g:9295:1: rule__ActionSpec__Group_9__2 : rule__ActionSpec__Group_9__2__Impl ; + public final void rule__ActionSpec__Group_9__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9299:1: ( rule__ActionSpec__Group_9__2__Impl ) + // InternalRos2Parser.g:9300:2: rule__ActionSpec__Group_9__2__Impl + { + pushFollow(FOLLOW_2); + rule__ActionSpec__Group_9__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__2" + + + // $ANTLR start "rule__ActionSpec__Group_9__2__Impl" + // InternalRos2Parser.g:9306:1: rule__ActionSpec__Group_9__2__Impl : ( RULE_END ) ; + public final void rule__ActionSpec__Group_9__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9310:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:9311:1: ( RULE_END ) + { + // InternalRos2Parser.g:9311:1: ( RULE_END ) + // InternalRos2Parser.g:9312:2: RULE_END + { + before(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__Group_9__2__Impl" + + + // $ANTLR start "rule__MessageDefinition__Group__0" + // InternalRos2Parser.g:9322:1: rule__MessageDefinition__Group__0 : rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 ; + public final void rule__MessageDefinition__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9326:1: ( rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 ) + // InternalRos2Parser.g:9327:2: rule__MessageDefinition__Group__0__Impl rule__MessageDefinition__Group__1 + { + pushFollow(FOLLOW_39); + rule__MessageDefinition__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__MessageDefinition__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessageDefinition__Group__0" + + + // $ANTLR start "rule__MessageDefinition__Group__0__Impl" + // InternalRos2Parser.g:9334:1: rule__MessageDefinition__Group__0__Impl : ( () ) ; + public final void rule__MessageDefinition__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9338:1: ( ( () ) ) + // InternalRos2Parser.g:9339:1: ( () ) + { + // InternalRos2Parser.g:9339:1: ( () ) + // InternalRos2Parser.g:9340:2: () + { + before(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); + // InternalRos2Parser.g:9341:2: () + // InternalRos2Parser.g:9341:3: + { + } + + after(grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessageDefinition__Group__0__Impl" + + + // $ANTLR start "rule__MessageDefinition__Group__1" + // InternalRos2Parser.g:9349:1: rule__MessageDefinition__Group__1 : rule__MessageDefinition__Group__1__Impl ; + public final void rule__MessageDefinition__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9353:1: ( rule__MessageDefinition__Group__1__Impl ) + // InternalRos2Parser.g:9354:2: rule__MessageDefinition__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__MessageDefinition__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessageDefinition__Group__1" + + + // $ANTLR start "rule__MessageDefinition__Group__1__Impl" + // InternalRos2Parser.g:9360:1: rule__MessageDefinition__Group__1__Impl : ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) ; + public final void rule__MessageDefinition__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9364:1: ( ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) ) + // InternalRos2Parser.g:9365:1: ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) + { + // InternalRos2Parser.g:9365:1: ( ( rule__MessageDefinition__MessagePartAssignment_1 )* ) + // InternalRos2Parser.g:9366:2: ( rule__MessageDefinition__MessagePartAssignment_1 )* + { + before(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); + // InternalRos2Parser.g:9367:2: ( rule__MessageDefinition__MessagePartAssignment_1 )* + loop56: + do { + int alt56=2; + int LA56_0 = input.LA(1); + + if ( ((LA56_0>=Float32_1 && LA56_0<=Float64_1)||LA56_0==Duration||(LA56_0>=String_2 && LA56_0<=Uint64_1)||(LA56_0>=Float32 && LA56_0<=Int64_1)||LA56_0==Uint8_1||LA56_0==Header||(LA56_0>=Bool_1 && LA56_0<=Byte_1)||LA56_0==Int8_1||(LA56_0>=String_1 && LA56_0<=Uint64)||(LA56_0>=Int16 && LA56_0<=Int64)||LA56_0==Uint8||(LA56_0>=Bool && LA56_0<=Byte)||LA56_0==Int8||LA56_0==Time||LA56_0==RULE_ID||LA56_0==RULE_STRING) ) { + alt56=1; + } + + + switch (alt56) { + case 1 : + // InternalRos2Parser.g:9367:3: rule__MessageDefinition__MessagePartAssignment_1 + { + pushFollow(FOLLOW_47); + rule__MessageDefinition__MessagePartAssignment_1(); + + state._fsp--; + + + } + break; + + default : + break loop56; + } + } while (true); + + after(grammarAccess.getMessageDefinitionAccess().getMessagePartAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessageDefinition__Group__1__Impl" + + + // $ANTLR start "rule__ExternalDependency__Group__0" + // InternalRos2Parser.g:9376: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 { + // InternalRos2Parser.g:9380:1: ( rule__ExternalDependency__Group__0__Impl rule__ExternalDependency__Group__1 ) + // InternalRos2Parser.g:9381: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" + // InternalRos2Parser.g:9388:1: rule__ExternalDependency__Group__0__Impl : ( () ) ; + public final void rule__ExternalDependency__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9392:1: ( ( () ) ) + // InternalRos2Parser.g:9393:1: ( () ) + { + // InternalRos2Parser.g:9393:1: ( () ) + // InternalRos2Parser.g:9394:2: () + { + before(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); + // InternalRos2Parser.g:9395:2: () + // InternalRos2Parser.g:9395:3: + { + } + + after(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExternalDependency__Group__0__Impl" + + + // $ANTLR start "rule__ExternalDependency__Group__1" + // InternalRos2Parser.g:9403: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 { + // InternalRos2Parser.g:9407:1: ( rule__ExternalDependency__Group__1__Impl rule__ExternalDependency__Group__2 ) + // InternalRos2Parser.g:9408: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" + // InternalRos2Parser.g:9415:1: rule__ExternalDependency__Group__1__Impl : ( ExternalDependency ) ; + public final void rule__ExternalDependency__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9419:1: ( ( ExternalDependency ) ) + // InternalRos2Parser.g:9420:1: ( ExternalDependency ) + { + // InternalRos2Parser.g:9420:1: ( ExternalDependency ) + // InternalRos2Parser.g:9421: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" + // InternalRos2Parser.g:9430:1: rule__ExternalDependency__Group__2 : rule__ExternalDependency__Group__2__Impl ; + public final void rule__ExternalDependency__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9434:1: ( rule__ExternalDependency__Group__2__Impl ) + // InternalRos2Parser.g:9435: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" + // InternalRos2Parser.g:9441:1: rule__ExternalDependency__Group__2__Impl : ( ( rule__ExternalDependency__NameAssignment_2 ) ) ; + public final void rule__ExternalDependency__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9445:1: ( ( ( rule__ExternalDependency__NameAssignment_2 ) ) ) + // InternalRos2Parser.g:9446:1: ( ( rule__ExternalDependency__NameAssignment_2 ) ) + { + // InternalRos2Parser.g:9446:1: ( ( rule__ExternalDependency__NameAssignment_2 ) ) + // InternalRos2Parser.g:9447:2: ( rule__ExternalDependency__NameAssignment_2 ) + { + before(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); + // InternalRos2Parser.g:9448:2: ( rule__ExternalDependency__NameAssignment_2 ) + // InternalRos2Parser.g:9448: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__GlobalNamespace__Group__0" + // InternalRos2Parser.g:9457:1: rule__GlobalNamespace__Group__0 : rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 ; + public final void rule__GlobalNamespace__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9461:1: ( rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 ) + // InternalRos2Parser.g:9462:2: rule__GlobalNamespace__Group__0__Impl rule__GlobalNamespace__Group__1 + { + pushFollow(FOLLOW_48); + rule__GlobalNamespace__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__0" + + + // $ANTLR start "rule__GlobalNamespace__Group__0__Impl" + // InternalRos2Parser.g:9469:1: rule__GlobalNamespace__Group__0__Impl : ( () ) ; + public final void rule__GlobalNamespace__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9473:1: ( ( () ) ) + // InternalRos2Parser.g:9474:1: ( () ) + { + // InternalRos2Parser.g:9474:1: ( () ) + // InternalRos2Parser.g:9475:2: () + { + before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); + // InternalRos2Parser.g:9476:2: () + // InternalRos2Parser.g:9476:3: + { + } + + after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__0__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group__1" + // InternalRos2Parser.g:9484:1: rule__GlobalNamespace__Group__1 : rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 ; + public final void rule__GlobalNamespace__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9488:1: ( rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 ) + // InternalRos2Parser.g:9489:2: rule__GlobalNamespace__Group__1__Impl rule__GlobalNamespace__Group__2 + { + pushFollow(FOLLOW_10); + rule__GlobalNamespace__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__1" + + + // $ANTLR start "rule__GlobalNamespace__Group__1__Impl" + // InternalRos2Parser.g:9496:1: rule__GlobalNamespace__Group__1__Impl : ( GlobalNamespace ) ; + public final void rule__GlobalNamespace__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9500:1: ( ( GlobalNamespace ) ) + // InternalRos2Parser.g:9501:1: ( GlobalNamespace ) + { + // InternalRos2Parser.g:9501:1: ( GlobalNamespace ) + // InternalRos2Parser.g:9502:2: GlobalNamespace + { + before(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); + match(input,GlobalNamespace,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__1__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group__2" + // InternalRos2Parser.g:9511:1: rule__GlobalNamespace__Group__2 : rule__GlobalNamespace__Group__2__Impl ; + public final void rule__GlobalNamespace__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9515:1: ( rule__GlobalNamespace__Group__2__Impl ) + // InternalRos2Parser.g:9516:2: rule__GlobalNamespace__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__2" + + + // $ANTLR start "rule__GlobalNamespace__Group__2__Impl" + // InternalRos2Parser.g:9522:1: rule__GlobalNamespace__Group__2__Impl : ( ( rule__GlobalNamespace__Group_2__0 )? ) ; + public final void rule__GlobalNamespace__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9526:1: ( ( ( rule__GlobalNamespace__Group_2__0 )? ) ) + // InternalRos2Parser.g:9527:1: ( ( rule__GlobalNamespace__Group_2__0 )? ) + { + // InternalRos2Parser.g:9527:1: ( ( rule__GlobalNamespace__Group_2__0 )? ) + // InternalRos2Parser.g:9528:2: ( rule__GlobalNamespace__Group_2__0 )? + { + before(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); + // InternalRos2Parser.g:9529:2: ( rule__GlobalNamespace__Group_2__0 )? + int alt57=2; + int LA57_0 = input.LA(1); + + if ( (LA57_0==LeftSquareBracket) ) { + alt57=1; + } + switch (alt57) { + case 1 : + // InternalRos2Parser.g:9529:3: rule__GlobalNamespace__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getGlobalNamespaceAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group__2__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__0" + // InternalRos2Parser.g:9538:1: rule__GlobalNamespace__Group_2__0 : rule__GlobalNamespace__Group_2__0__Impl rule__GlobalNamespace__Group_2__1 ; + public final void rule__GlobalNamespace__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9542:1: ( rule__GlobalNamespace__Group_2__0__Impl rule__GlobalNamespace__Group_2__1 ) + // InternalRos2Parser.g:9543:2: rule__GlobalNamespace__Group_2__0__Impl rule__GlobalNamespace__Group_2__1 + { + pushFollow(FOLLOW_49); + rule__GlobalNamespace__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__0" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__0__Impl" + // InternalRos2Parser.g:9550:1: rule__GlobalNamespace__Group_2__0__Impl : ( LeftSquareBracket ) ; + public final void rule__GlobalNamespace__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9554:1: ( ( LeftSquareBracket ) ) + // InternalRos2Parser.g:9555:1: ( LeftSquareBracket ) + { + // InternalRos2Parser.g:9555:1: ( LeftSquareBracket ) + // InternalRos2Parser.g:9556:2: LeftSquareBracket + { + before(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__0__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__1" + // InternalRos2Parser.g:9565:1: rule__GlobalNamespace__Group_2__1 : rule__GlobalNamespace__Group_2__1__Impl rule__GlobalNamespace__Group_2__2 ; + public final void rule__GlobalNamespace__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9569:1: ( rule__GlobalNamespace__Group_2__1__Impl rule__GlobalNamespace__Group_2__2 ) + // InternalRos2Parser.g:9570:2: rule__GlobalNamespace__Group_2__1__Impl rule__GlobalNamespace__Group_2__2 + { + pushFollow(FOLLOW_12); + rule__GlobalNamespace__Group_2__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__1" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__1__Impl" + // InternalRos2Parser.g:9577:1: rule__GlobalNamespace__Group_2__1__Impl : ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) ; + public final void rule__GlobalNamespace__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9581:1: ( ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) ) + // InternalRos2Parser.g:9582:1: ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) + { + // InternalRos2Parser.g:9582:1: ( ( rule__GlobalNamespace__PartsAssignment_2_1 ) ) + // InternalRos2Parser.g:9583:2: ( rule__GlobalNamespace__PartsAssignment_2_1 ) + { + before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); + // InternalRos2Parser.g:9584:2: ( rule__GlobalNamespace__PartsAssignment_2_1 ) + // InternalRos2Parser.g:9584:3: rule__GlobalNamespace__PartsAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__PartsAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__1__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__2" + // InternalRos2Parser.g:9592:1: rule__GlobalNamespace__Group_2__2 : rule__GlobalNamespace__Group_2__2__Impl rule__GlobalNamespace__Group_2__3 ; + public final void rule__GlobalNamespace__Group_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9596:1: ( rule__GlobalNamespace__Group_2__2__Impl rule__GlobalNamespace__Group_2__3 ) + // InternalRos2Parser.g:9597:2: rule__GlobalNamespace__Group_2__2__Impl rule__GlobalNamespace__Group_2__3 + { + pushFollow(FOLLOW_12); + rule__GlobalNamespace__Group_2__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__2" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__2__Impl" + // InternalRos2Parser.g:9604:1: rule__GlobalNamespace__Group_2__2__Impl : ( ( rule__GlobalNamespace__Group_2_2__0 )* ) ; + public final void rule__GlobalNamespace__Group_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9608:1: ( ( ( rule__GlobalNamespace__Group_2_2__0 )* ) ) + // InternalRos2Parser.g:9609:1: ( ( rule__GlobalNamespace__Group_2_2__0 )* ) + { + // InternalRos2Parser.g:9609:1: ( ( rule__GlobalNamespace__Group_2_2__0 )* ) + // InternalRos2Parser.g:9610:2: ( rule__GlobalNamespace__Group_2_2__0 )* + { + before(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); + // InternalRos2Parser.g:9611:2: ( rule__GlobalNamespace__Group_2_2__0 )* + loop58: + do { + int alt58=2; + int LA58_0 = input.LA(1); + + if ( (LA58_0==Comma) ) { + alt58=1; + } + + + switch (alt58) { + case 1 : + // InternalRos2Parser.g:9611:3: rule__GlobalNamespace__Group_2_2__0 + { + pushFollow(FOLLOW_13); + rule__GlobalNamespace__Group_2_2__0(); + + state._fsp--; + + + } + break; + + default : + break loop58; + } + } while (true); + + after(grammarAccess.getGlobalNamespaceAccess().getGroup_2_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__2__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__3" + // InternalRos2Parser.g:9619:1: rule__GlobalNamespace__Group_2__3 : rule__GlobalNamespace__Group_2__3__Impl ; + public final void rule__GlobalNamespace__Group_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9623:1: ( rule__GlobalNamespace__Group_2__3__Impl ) + // InternalRos2Parser.g:9624:2: rule__GlobalNamespace__Group_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__3" + + + // $ANTLR start "rule__GlobalNamespace__Group_2__3__Impl" + // InternalRos2Parser.g:9630:1: rule__GlobalNamespace__Group_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__GlobalNamespace__Group_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9634:1: ( ( RightSquareBracket ) ) + // InternalRos2Parser.g:9635:1: ( RightSquareBracket ) + { + // InternalRos2Parser.g:9635:1: ( RightSquareBracket ) + // InternalRos2Parser.g:9636:2: RightSquareBracket + { + before(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2__3__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2_2__0" + // InternalRos2Parser.g:9646:1: rule__GlobalNamespace__Group_2_2__0 : rule__GlobalNamespace__Group_2_2__0__Impl rule__GlobalNamespace__Group_2_2__1 ; + public final void rule__GlobalNamespace__Group_2_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9650:1: ( rule__GlobalNamespace__Group_2_2__0__Impl rule__GlobalNamespace__Group_2_2__1 ) + // InternalRos2Parser.g:9651:2: rule__GlobalNamespace__Group_2_2__0__Impl rule__GlobalNamespace__Group_2_2__1 + { + pushFollow(FOLLOW_49); + rule__GlobalNamespace__Group_2_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2_2__0" + + + // $ANTLR start "rule__GlobalNamespace__Group_2_2__0__Impl" + // InternalRos2Parser.g:9658:1: rule__GlobalNamespace__Group_2_2__0__Impl : ( Comma ) ; + public final void rule__GlobalNamespace__Group_2_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9662:1: ( ( Comma ) ) + // InternalRos2Parser.g:9663:1: ( Comma ) + { + // InternalRos2Parser.g:9663:1: ( Comma ) + // InternalRos2Parser.g:9664:2: Comma + { + before(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2_2__0__Impl" + + + // $ANTLR start "rule__GlobalNamespace__Group_2_2__1" + // InternalRos2Parser.g:9673:1: rule__GlobalNamespace__Group_2_2__1 : rule__GlobalNamespace__Group_2_2__1__Impl ; + public final void rule__GlobalNamespace__Group_2_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9677:1: ( rule__GlobalNamespace__Group_2_2__1__Impl ) + // InternalRos2Parser.g:9678:2: rule__GlobalNamespace__Group_2_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__Group_2_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2_2__1" + + + // $ANTLR start "rule__GlobalNamespace__Group_2_2__1__Impl" + // InternalRos2Parser.g:9684:1: rule__GlobalNamespace__Group_2_2__1__Impl : ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) ; + public final void rule__GlobalNamespace__Group_2_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9688:1: ( ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) ) + // InternalRos2Parser.g:9689:1: ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) + { + // InternalRos2Parser.g:9689:1: ( ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) ) + // InternalRos2Parser.g:9690:2: ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) + { + before(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); + // InternalRos2Parser.g:9691:2: ( rule__GlobalNamespace__PartsAssignment_2_2_1 ) + // InternalRos2Parser.g:9691:3: rule__GlobalNamespace__PartsAssignment_2_2_1 + { + pushFollow(FOLLOW_2); + rule__GlobalNamespace__PartsAssignment_2_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getGlobalNamespaceAccess().getPartsAssignment_2_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__Group_2_2__1__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__0" + // InternalRos2Parser.g:9700:1: rule__RelativeNamespace_Impl__Group__0 : rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 ; + public final void rule__RelativeNamespace_Impl__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9704:1: ( rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 ) + // InternalRos2Parser.g:9705:2: rule__RelativeNamespace_Impl__Group__0__Impl rule__RelativeNamespace_Impl__Group__1 + { + pushFollow(FOLLOW_50); + rule__RelativeNamespace_Impl__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__0" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__0__Impl" + // InternalRos2Parser.g:9712:1: rule__RelativeNamespace_Impl__Group__0__Impl : ( () ) ; + public final void rule__RelativeNamespace_Impl__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9716:1: ( ( () ) ) + // InternalRos2Parser.g:9717:1: ( () ) + { + // InternalRos2Parser.g:9717:1: ( () ) + // InternalRos2Parser.g:9718:2: () + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); + // InternalRos2Parser.g:9719:2: () + // InternalRos2Parser.g:9719:3: + { + } + + after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__0__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__1" + // InternalRos2Parser.g:9727:1: rule__RelativeNamespace_Impl__Group__1 : rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 ; + public final void rule__RelativeNamespace_Impl__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9731:1: ( rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 ) + // InternalRos2Parser.g:9732:2: rule__RelativeNamespace_Impl__Group__1__Impl rule__RelativeNamespace_Impl__Group__2 + { + pushFollow(FOLLOW_10); + rule__RelativeNamespace_Impl__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__1" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__1__Impl" + // InternalRos2Parser.g:9739:1: rule__RelativeNamespace_Impl__Group__1__Impl : ( RelativeNamespace ) ; + public final void rule__RelativeNamespace_Impl__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9743:1: ( ( RelativeNamespace ) ) + // InternalRos2Parser.g:9744:1: ( RelativeNamespace ) + { + // InternalRos2Parser.g:9744:1: ( RelativeNamespace ) + // InternalRos2Parser.g:9745:2: RelativeNamespace + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); + match(input,RelativeNamespace,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__1__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__2" + // InternalRos2Parser.g:9754:1: rule__RelativeNamespace_Impl__Group__2 : rule__RelativeNamespace_Impl__Group__2__Impl ; + public final void rule__RelativeNamespace_Impl__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9758:1: ( rule__RelativeNamespace_Impl__Group__2__Impl ) + // InternalRos2Parser.g:9759:2: rule__RelativeNamespace_Impl__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__2" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group__2__Impl" + // InternalRos2Parser.g:9765:1: rule__RelativeNamespace_Impl__Group__2__Impl : ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) ; + public final void rule__RelativeNamespace_Impl__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9769:1: ( ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) ) + // InternalRos2Parser.g:9770:1: ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) + { + // InternalRos2Parser.g:9770:1: ( ( rule__RelativeNamespace_Impl__Group_2__0 )? ) + // InternalRos2Parser.g:9771:2: ( rule__RelativeNamespace_Impl__Group_2__0 )? + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); + // InternalRos2Parser.g:9772:2: ( rule__RelativeNamespace_Impl__Group_2__0 )? + int alt59=2; + int LA59_0 = input.LA(1); + + if ( (LA59_0==LeftSquareBracket) ) { + alt59=1; + } + switch (alt59) { + case 1 : + // InternalRos2Parser.g:9772:3: rule__RelativeNamespace_Impl__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group__2__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__0" + // InternalRos2Parser.g:9781:1: rule__RelativeNamespace_Impl__Group_2__0 : rule__RelativeNamespace_Impl__Group_2__0__Impl rule__RelativeNamespace_Impl__Group_2__1 ; + public final void rule__RelativeNamespace_Impl__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9785:1: ( rule__RelativeNamespace_Impl__Group_2__0__Impl rule__RelativeNamespace_Impl__Group_2__1 ) + // InternalRos2Parser.g:9786:2: rule__RelativeNamespace_Impl__Group_2__0__Impl rule__RelativeNamespace_Impl__Group_2__1 + { + pushFollow(FOLLOW_49); + rule__RelativeNamespace_Impl__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__0" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__0__Impl" + // InternalRos2Parser.g:9793:1: rule__RelativeNamespace_Impl__Group_2__0__Impl : ( LeftSquareBracket ) ; + public final void rule__RelativeNamespace_Impl__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9797:1: ( ( LeftSquareBracket ) ) + // InternalRos2Parser.g:9798:1: ( LeftSquareBracket ) + { + // InternalRos2Parser.g:9798:1: ( LeftSquareBracket ) + // InternalRos2Parser.g:9799:2: LeftSquareBracket + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__0__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__1" + // InternalRos2Parser.g:9808:1: rule__RelativeNamespace_Impl__Group_2__1 : rule__RelativeNamespace_Impl__Group_2__1__Impl rule__RelativeNamespace_Impl__Group_2__2 ; + public final void rule__RelativeNamespace_Impl__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9812:1: ( rule__RelativeNamespace_Impl__Group_2__1__Impl rule__RelativeNamespace_Impl__Group_2__2 ) + // InternalRos2Parser.g:9813:2: rule__RelativeNamespace_Impl__Group_2__1__Impl rule__RelativeNamespace_Impl__Group_2__2 + { + pushFollow(FOLLOW_12); + rule__RelativeNamespace_Impl__Group_2__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__1" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__1__Impl" + // InternalRos2Parser.g:9820:1: rule__RelativeNamespace_Impl__Group_2__1__Impl : ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) ; + public final void rule__RelativeNamespace_Impl__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9824:1: ( ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) ) + // InternalRos2Parser.g:9825:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) + { + // InternalRos2Parser.g:9825:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) ) + // InternalRos2Parser.g:9826:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); + // InternalRos2Parser.g:9827:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_1 ) + // InternalRos2Parser.g:9827:3: rule__RelativeNamespace_Impl__PartsAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__PartsAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__1__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__2" + // InternalRos2Parser.g:9835:1: rule__RelativeNamespace_Impl__Group_2__2 : rule__RelativeNamespace_Impl__Group_2__2__Impl rule__RelativeNamespace_Impl__Group_2__3 ; + public final void rule__RelativeNamespace_Impl__Group_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9839:1: ( rule__RelativeNamespace_Impl__Group_2__2__Impl rule__RelativeNamespace_Impl__Group_2__3 ) + // InternalRos2Parser.g:9840:2: rule__RelativeNamespace_Impl__Group_2__2__Impl rule__RelativeNamespace_Impl__Group_2__3 + { + pushFollow(FOLLOW_12); + rule__RelativeNamespace_Impl__Group_2__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__2" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__2__Impl" + // InternalRos2Parser.g:9847:1: rule__RelativeNamespace_Impl__Group_2__2__Impl : ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) ; + public final void rule__RelativeNamespace_Impl__Group_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9851:1: ( ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) ) + // InternalRos2Parser.g:9852:1: ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) + { + // InternalRos2Parser.g:9852:1: ( ( rule__RelativeNamespace_Impl__Group_2_2__0 )* ) + // InternalRos2Parser.g:9853:2: ( rule__RelativeNamespace_Impl__Group_2_2__0 )* + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); + // InternalRos2Parser.g:9854:2: ( rule__RelativeNamespace_Impl__Group_2_2__0 )* + loop60: + do { + int alt60=2; + int LA60_0 = input.LA(1); + + if ( (LA60_0==Comma) ) { + alt60=1; + } + + + switch (alt60) { + case 1 : + // InternalRos2Parser.g:9854:3: rule__RelativeNamespace_Impl__Group_2_2__0 + { + pushFollow(FOLLOW_13); + rule__RelativeNamespace_Impl__Group_2_2__0(); + + state._fsp--; + + + } + break; + + default : + break loop60; + } + } while (true); + + after(grammarAccess.getRelativeNamespace_ImplAccess().getGroup_2_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__2__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__3" + // InternalRos2Parser.g:9862:1: rule__RelativeNamespace_Impl__Group_2__3 : rule__RelativeNamespace_Impl__Group_2__3__Impl ; + public final void rule__RelativeNamespace_Impl__Group_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9866:1: ( rule__RelativeNamespace_Impl__Group_2__3__Impl ) + // InternalRos2Parser.g:9867:2: rule__RelativeNamespace_Impl__Group_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__3" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2__3__Impl" + // InternalRos2Parser.g:9873:1: rule__RelativeNamespace_Impl__Group_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__RelativeNamespace_Impl__Group_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9877:1: ( ( RightSquareBracket ) ) + // InternalRos2Parser.g:9878:1: ( RightSquareBracket ) + { + // InternalRos2Parser.g:9878:1: ( RightSquareBracket ) + // InternalRos2Parser.g:9879:2: RightSquareBracket + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2__3__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__0" + // InternalRos2Parser.g:9889:1: rule__RelativeNamespace_Impl__Group_2_2__0 : rule__RelativeNamespace_Impl__Group_2_2__0__Impl rule__RelativeNamespace_Impl__Group_2_2__1 ; + public final void rule__RelativeNamespace_Impl__Group_2_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9893:1: ( rule__RelativeNamespace_Impl__Group_2_2__0__Impl rule__RelativeNamespace_Impl__Group_2_2__1 ) + // InternalRos2Parser.g:9894:2: rule__RelativeNamespace_Impl__Group_2_2__0__Impl rule__RelativeNamespace_Impl__Group_2_2__1 + { + pushFollow(FOLLOW_49); + rule__RelativeNamespace_Impl__Group_2_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__0" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__0__Impl" + // InternalRos2Parser.g:9901:1: rule__RelativeNamespace_Impl__Group_2_2__0__Impl : ( Comma ) ; + public final void rule__RelativeNamespace_Impl__Group_2_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9905:1: ( ( Comma ) ) + // InternalRos2Parser.g:9906:1: ( Comma ) + { + // InternalRos2Parser.g:9906:1: ( Comma ) + // InternalRos2Parser.g:9907:2: Comma + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__0__Impl" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__1" + // InternalRos2Parser.g:9916:1: rule__RelativeNamespace_Impl__Group_2_2__1 : rule__RelativeNamespace_Impl__Group_2_2__1__Impl ; + public final void rule__RelativeNamespace_Impl__Group_2_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9920:1: ( rule__RelativeNamespace_Impl__Group_2_2__1__Impl ) + // InternalRos2Parser.g:9921:2: rule__RelativeNamespace_Impl__Group_2_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__Group_2_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__1" + + + // $ANTLR start "rule__RelativeNamespace_Impl__Group_2_2__1__Impl" + // InternalRos2Parser.g:9927:1: rule__RelativeNamespace_Impl__Group_2_2__1__Impl : ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) ; + public final void rule__RelativeNamespace_Impl__Group_2_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9931:1: ( ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) ) + // InternalRos2Parser.g:9932:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) + { + // InternalRos2Parser.g:9932:1: ( ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) ) + // InternalRos2Parser.g:9933:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); + // InternalRos2Parser.g:9934:2: ( rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 ) + // InternalRos2Parser.g:9934:3: rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 + { + pushFollow(FOLLOW_2); + rule__RelativeNamespace_Impl__PartsAssignment_2_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsAssignment_2_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__Group_2_2__1__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group__0" + // InternalRos2Parser.g:9943:1: rule__PrivateNamespace__Group__0 : rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 ; + public final void rule__PrivateNamespace__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9947:1: ( rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 ) + // InternalRos2Parser.g:9948:2: rule__PrivateNamespace__Group__0__Impl rule__PrivateNamespace__Group__1 + { + pushFollow(FOLLOW_22); + rule__PrivateNamespace__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__0" + + + // $ANTLR start "rule__PrivateNamespace__Group__0__Impl" + // InternalRos2Parser.g:9955:1: rule__PrivateNamespace__Group__0__Impl : ( () ) ; + public final void rule__PrivateNamespace__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9959:1: ( ( () ) ) + // InternalRos2Parser.g:9960:1: ( () ) + { + // InternalRos2Parser.g:9960:1: ( () ) + // InternalRos2Parser.g:9961:2: () + { + before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); + // InternalRos2Parser.g:9962:2: () + // InternalRos2Parser.g:9962:3: + { + } + + after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__0__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group__1" + // InternalRos2Parser.g:9970:1: rule__PrivateNamespace__Group__1 : rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 ; + public final void rule__PrivateNamespace__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9974:1: ( rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 ) + // InternalRos2Parser.g:9975:2: rule__PrivateNamespace__Group__1__Impl rule__PrivateNamespace__Group__2 + { + pushFollow(FOLLOW_10); + rule__PrivateNamespace__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__1" + + + // $ANTLR start "rule__PrivateNamespace__Group__1__Impl" + // InternalRos2Parser.g:9982:1: rule__PrivateNamespace__Group__1__Impl : ( PrivateNamespace ) ; + public final void rule__PrivateNamespace__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:9986:1: ( ( PrivateNamespace ) ) + // InternalRos2Parser.g:9987:1: ( PrivateNamespace ) + { + // InternalRos2Parser.g:9987:1: ( PrivateNamespace ) + // InternalRos2Parser.g:9988:2: PrivateNamespace + { + before(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); + match(input,PrivateNamespace,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__1__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group__2" + // InternalRos2Parser.g:9997:1: rule__PrivateNamespace__Group__2 : rule__PrivateNamespace__Group__2__Impl ; + public final void rule__PrivateNamespace__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10001:1: ( rule__PrivateNamespace__Group__2__Impl ) + // InternalRos2Parser.g:10002:2: rule__PrivateNamespace__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__2" + + + // $ANTLR start "rule__PrivateNamespace__Group__2__Impl" + // InternalRos2Parser.g:10008:1: rule__PrivateNamespace__Group__2__Impl : ( ( rule__PrivateNamespace__Group_2__0 )? ) ; + public final void rule__PrivateNamespace__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10012:1: ( ( ( rule__PrivateNamespace__Group_2__0 )? ) ) + // InternalRos2Parser.g:10013:1: ( ( rule__PrivateNamespace__Group_2__0 )? ) + { + // InternalRos2Parser.g:10013:1: ( ( rule__PrivateNamespace__Group_2__0 )? ) + // InternalRos2Parser.g:10014:2: ( rule__PrivateNamespace__Group_2__0 )? + { + before(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); + // InternalRos2Parser.g:10015:2: ( rule__PrivateNamespace__Group_2__0 )? + int alt61=2; + int LA61_0 = input.LA(1); + + if ( (LA61_0==LeftSquareBracket) ) { + alt61=1; + } + switch (alt61) { + case 1 : + // InternalRos2Parser.g:10015:3: rule__PrivateNamespace__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPrivateNamespaceAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group__2__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__0" + // InternalRos2Parser.g:10024:1: rule__PrivateNamespace__Group_2__0 : rule__PrivateNamespace__Group_2__0__Impl rule__PrivateNamespace__Group_2__1 ; + public final void rule__PrivateNamespace__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10028:1: ( rule__PrivateNamespace__Group_2__0__Impl rule__PrivateNamespace__Group_2__1 ) + // InternalRos2Parser.g:10029:2: rule__PrivateNamespace__Group_2__0__Impl rule__PrivateNamespace__Group_2__1 + { + pushFollow(FOLLOW_49); + rule__PrivateNamespace__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__0" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__0__Impl" + // InternalRos2Parser.g:10036:1: rule__PrivateNamespace__Group_2__0__Impl : ( LeftSquareBracket ) ; + public final void rule__PrivateNamespace__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10040:1: ( ( LeftSquareBracket ) ) + // InternalRos2Parser.g:10041:1: ( LeftSquareBracket ) + { + // InternalRos2Parser.g:10041:1: ( LeftSquareBracket ) + // InternalRos2Parser.g:10042:2: LeftSquareBracket + { + before(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__0__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__1" + // InternalRos2Parser.g:10051:1: rule__PrivateNamespace__Group_2__1 : rule__PrivateNamespace__Group_2__1__Impl rule__PrivateNamespace__Group_2__2 ; + public final void rule__PrivateNamespace__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10055:1: ( rule__PrivateNamespace__Group_2__1__Impl rule__PrivateNamespace__Group_2__2 ) + // InternalRos2Parser.g:10056:2: rule__PrivateNamespace__Group_2__1__Impl rule__PrivateNamespace__Group_2__2 + { + pushFollow(FOLLOW_12); + rule__PrivateNamespace__Group_2__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__1" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__1__Impl" + // InternalRos2Parser.g:10063:1: rule__PrivateNamespace__Group_2__1__Impl : ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) ; + public final void rule__PrivateNamespace__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10067:1: ( ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) ) + // InternalRos2Parser.g:10068:1: ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) + { + // InternalRos2Parser.g:10068:1: ( ( rule__PrivateNamespace__PartsAssignment_2_1 ) ) + // InternalRos2Parser.g:10069:2: ( rule__PrivateNamespace__PartsAssignment_2_1 ) + { + before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); + // InternalRos2Parser.g:10070:2: ( rule__PrivateNamespace__PartsAssignment_2_1 ) + // InternalRos2Parser.g:10070:3: rule__PrivateNamespace__PartsAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__PartsAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__1__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__2" + // InternalRos2Parser.g:10078:1: rule__PrivateNamespace__Group_2__2 : rule__PrivateNamespace__Group_2__2__Impl rule__PrivateNamespace__Group_2__3 ; + public final void rule__PrivateNamespace__Group_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10082:1: ( rule__PrivateNamespace__Group_2__2__Impl rule__PrivateNamespace__Group_2__3 ) + // InternalRos2Parser.g:10083:2: rule__PrivateNamespace__Group_2__2__Impl rule__PrivateNamespace__Group_2__3 + { + pushFollow(FOLLOW_12); + rule__PrivateNamespace__Group_2__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__2" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__2__Impl" + // InternalRos2Parser.g:10090:1: rule__PrivateNamespace__Group_2__2__Impl : ( ( rule__PrivateNamespace__Group_2_2__0 )* ) ; + public final void rule__PrivateNamespace__Group_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10094:1: ( ( ( rule__PrivateNamespace__Group_2_2__0 )* ) ) + // InternalRos2Parser.g:10095:1: ( ( rule__PrivateNamespace__Group_2_2__0 )* ) + { + // InternalRos2Parser.g:10095:1: ( ( rule__PrivateNamespace__Group_2_2__0 )* ) + // InternalRos2Parser.g:10096:2: ( rule__PrivateNamespace__Group_2_2__0 )* + { + before(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); + // InternalRos2Parser.g:10097:2: ( rule__PrivateNamespace__Group_2_2__0 )* + loop62: + do { + int alt62=2; + int LA62_0 = input.LA(1); + + if ( (LA62_0==Comma) ) { + alt62=1; + } + + + switch (alt62) { + case 1 : + // InternalRos2Parser.g:10097:3: rule__PrivateNamespace__Group_2_2__0 + { + pushFollow(FOLLOW_13); + rule__PrivateNamespace__Group_2_2__0(); + + state._fsp--; + + + } + break; + + default : + break loop62; + } + } while (true); + + after(grammarAccess.getPrivateNamespaceAccess().getGroup_2_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__2__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__3" + // InternalRos2Parser.g:10105:1: rule__PrivateNamespace__Group_2__3 : rule__PrivateNamespace__Group_2__3__Impl ; + public final void rule__PrivateNamespace__Group_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10109:1: ( rule__PrivateNamespace__Group_2__3__Impl ) + // InternalRos2Parser.g:10110:2: rule__PrivateNamespace__Group_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__3" + + + // $ANTLR start "rule__PrivateNamespace__Group_2__3__Impl" + // InternalRos2Parser.g:10116:1: rule__PrivateNamespace__Group_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__PrivateNamespace__Group_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10120:1: ( ( RightSquareBracket ) ) + // InternalRos2Parser.g:10121:1: ( RightSquareBracket ) + { + // InternalRos2Parser.g:10121:1: ( RightSquareBracket ) + // InternalRos2Parser.g:10122:2: RightSquareBracket + { + before(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2__3__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2_2__0" + // InternalRos2Parser.g:10132:1: rule__PrivateNamespace__Group_2_2__0 : rule__PrivateNamespace__Group_2_2__0__Impl rule__PrivateNamespace__Group_2_2__1 ; + public final void rule__PrivateNamespace__Group_2_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10136:1: ( rule__PrivateNamespace__Group_2_2__0__Impl rule__PrivateNamespace__Group_2_2__1 ) + // InternalRos2Parser.g:10137:2: rule__PrivateNamespace__Group_2_2__0__Impl rule__PrivateNamespace__Group_2_2__1 + { + pushFollow(FOLLOW_49); + rule__PrivateNamespace__Group_2_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2_2__0" + + + // $ANTLR start "rule__PrivateNamespace__Group_2_2__0__Impl" + // InternalRos2Parser.g:10144:1: rule__PrivateNamespace__Group_2_2__0__Impl : ( Comma ) ; + public final void rule__PrivateNamespace__Group_2_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10148:1: ( ( Comma ) ) + // InternalRos2Parser.g:10149:1: ( Comma ) + { + // InternalRos2Parser.g:10149:1: ( Comma ) + // InternalRos2Parser.g:10150:2: Comma + { + before(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2_2__0__Impl" + + + // $ANTLR start "rule__PrivateNamespace__Group_2_2__1" + // InternalRos2Parser.g:10159:1: rule__PrivateNamespace__Group_2_2__1 : rule__PrivateNamespace__Group_2_2__1__Impl ; + public final void rule__PrivateNamespace__Group_2_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10163:1: ( rule__PrivateNamespace__Group_2_2__1__Impl ) + // InternalRos2Parser.g:10164:2: rule__PrivateNamespace__Group_2_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__Group_2_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2_2__1" + + + // $ANTLR start "rule__PrivateNamespace__Group_2_2__1__Impl" + // InternalRos2Parser.g:10170:1: rule__PrivateNamespace__Group_2_2__1__Impl : ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) ; + public final void rule__PrivateNamespace__Group_2_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10174:1: ( ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) ) + // InternalRos2Parser.g:10175:1: ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) + { + // InternalRos2Parser.g:10175:1: ( ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) ) + // InternalRos2Parser.g:10176:2: ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) + { + before(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); + // InternalRos2Parser.g:10177:2: ( rule__PrivateNamespace__PartsAssignment_2_2_1 ) + // InternalRos2Parser.g:10177:3: rule__PrivateNamespace__PartsAssignment_2_2_1 + { + pushFollow(FOLLOW_2); + rule__PrivateNamespace__PartsAssignment_2_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPrivateNamespaceAccess().getPartsAssignment_2_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__Group_2_2__1__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__0" + // InternalRos2Parser.g:10186:1: rule__ParameterListType__Group__0 : rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 ; + public final void rule__ParameterListType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10190:1: ( rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 ) + // InternalRos2Parser.g:10191:2: rule__ParameterListType__Group__0__Impl rule__ParameterListType__Group__1 + { + pushFollow(FOLLOW_51); + rule__ParameterListType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__0" + + + // $ANTLR start "rule__ParameterListType__Group__0__Impl" + // InternalRos2Parser.g:10198:1: rule__ParameterListType__Group__0__Impl : ( () ) ; + public final void rule__ParameterListType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10202:1: ( ( () ) ) + // InternalRos2Parser.g:10203:1: ( () ) + { + // InternalRos2Parser.g:10203:1: ( () ) + // InternalRos2Parser.g:10204:2: () + { + before(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); + // InternalRos2Parser.g:10205:2: () + // InternalRos2Parser.g:10205:3: + { + } + + after(grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__1" + // InternalRos2Parser.g:10213:1: rule__ParameterListType__Group__1 : rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 ; + public final void rule__ParameterListType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10217:1: ( rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 ) + // InternalRos2Parser.g:10218:2: rule__ParameterListType__Group__1__Impl rule__ParameterListType__Group__2 + { + pushFollow(FOLLOW_10); + rule__ParameterListType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__1" + + + // $ANTLR start "rule__ParameterListType__Group__1__Impl" + // InternalRos2Parser.g:10225:1: rule__ParameterListType__Group__1__Impl : ( List ) ; + public final void rule__ParameterListType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10229:1: ( ( List ) ) + // InternalRos2Parser.g:10230:1: ( List ) + { + // InternalRos2Parser.g:10230:1: ( List ) + // InternalRos2Parser.g:10231:2: List + { + before(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); + match(input,List,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getListKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__2" + // InternalRos2Parser.g:10240:1: rule__ParameterListType__Group__2 : rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 ; + public final void rule__ParameterListType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10244:1: ( rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 ) + // InternalRos2Parser.g:10245:2: rule__ParameterListType__Group__2__Impl rule__ParameterListType__Group__3 + { + pushFollow(FOLLOW_25); + rule__ParameterListType__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__2" + + + // $ANTLR start "rule__ParameterListType__Group__2__Impl" + // InternalRos2Parser.g:10252:1: rule__ParameterListType__Group__2__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterListType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10256:1: ( ( LeftSquareBracket ) ) + // InternalRos2Parser.g:10257:1: ( LeftSquareBracket ) + { + // InternalRos2Parser.g:10257:1: ( LeftSquareBracket ) + // InternalRos2Parser.g:10258:2: LeftSquareBracket + { + before(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__3" + // InternalRos2Parser.g:10267:1: rule__ParameterListType__Group__3 : rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 ; + public final void rule__ParameterListType__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10271:1: ( rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 ) + // InternalRos2Parser.g:10272:2: rule__ParameterListType__Group__3__Impl rule__ParameterListType__Group__4 + { + pushFollow(FOLLOW_12); + rule__ParameterListType__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__3" + + + // $ANTLR start "rule__ParameterListType__Group__3__Impl" + // InternalRos2Parser.g:10279:1: rule__ParameterListType__Group__3__Impl : ( ( rule__ParameterListType__SequenceAssignment_3 ) ) ; + public final void rule__ParameterListType__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10283:1: ( ( ( rule__ParameterListType__SequenceAssignment_3 ) ) ) + // InternalRos2Parser.g:10284:1: ( ( rule__ParameterListType__SequenceAssignment_3 ) ) + { + // InternalRos2Parser.g:10284:1: ( ( rule__ParameterListType__SequenceAssignment_3 ) ) + // InternalRos2Parser.g:10285:2: ( rule__ParameterListType__SequenceAssignment_3 ) + { + before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); + // InternalRos2Parser.g:10286:2: ( rule__ParameterListType__SequenceAssignment_3 ) + // InternalRos2Parser.g:10286:3: rule__ParameterListType__SequenceAssignment_3 + { + pushFollow(FOLLOW_2); + rule__ParameterListType__SequenceAssignment_3(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__3__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__4" + // InternalRos2Parser.g:10294:1: rule__ParameterListType__Group__4 : rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 ; + public final void rule__ParameterListType__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10298:1: ( rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 ) + // InternalRos2Parser.g:10299:2: rule__ParameterListType__Group__4__Impl rule__ParameterListType__Group__5 + { + pushFollow(FOLLOW_12); + rule__ParameterListType__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__4" + + + // $ANTLR start "rule__ParameterListType__Group__4__Impl" + // InternalRos2Parser.g:10306:1: rule__ParameterListType__Group__4__Impl : ( ( rule__ParameterListType__Group_4__0 )* ) ; + public final void rule__ParameterListType__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10310:1: ( ( ( rule__ParameterListType__Group_4__0 )* ) ) + // InternalRos2Parser.g:10311:1: ( ( rule__ParameterListType__Group_4__0 )* ) + { + // InternalRos2Parser.g:10311:1: ( ( rule__ParameterListType__Group_4__0 )* ) + // InternalRos2Parser.g:10312:2: ( rule__ParameterListType__Group_4__0 )* + { + before(grammarAccess.getParameterListTypeAccess().getGroup_4()); + // InternalRos2Parser.g:10313:2: ( rule__ParameterListType__Group_4__0 )* + loop63: + do { + int alt63=2; + int LA63_0 = input.LA(1); + + if ( (LA63_0==Comma) ) { + alt63=1; + } + + + switch (alt63) { + case 1 : + // InternalRos2Parser.g:10313:3: rule__ParameterListType__Group_4__0 + { + pushFollow(FOLLOW_13); + rule__ParameterListType__Group_4__0(); + + state._fsp--; + + + } + break; + + default : + break loop63; + } + } while (true); + + after(grammarAccess.getParameterListTypeAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__4__Impl" + + + // $ANTLR start "rule__ParameterListType__Group__5" + // InternalRos2Parser.g:10321:1: rule__ParameterListType__Group__5 : rule__ParameterListType__Group__5__Impl ; + public final void rule__ParameterListType__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10325:1: ( rule__ParameterListType__Group__5__Impl ) + // InternalRos2Parser.g:10326:2: rule__ParameterListType__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterListType__Group__5__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__5" + + + // $ANTLR start "rule__ParameterListType__Group__5__Impl" + // InternalRos2Parser.g:10332:1: rule__ParameterListType__Group__5__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterListType__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10336:1: ( ( RightSquareBracket ) ) + // InternalRos2Parser.g:10337:1: ( RightSquareBracket ) + { + // InternalRos2Parser.g:10337:1: ( RightSquareBracket ) + // InternalRos2Parser.g:10338:2: RightSquareBracket + { + before(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group__5__Impl" + + + // $ANTLR start "rule__ParameterListType__Group_4__0" + // InternalRos2Parser.g:10348:1: rule__ParameterListType__Group_4__0 : rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 ; + public final void rule__ParameterListType__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10352:1: ( rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 ) + // InternalRos2Parser.g:10353:2: rule__ParameterListType__Group_4__0__Impl rule__ParameterListType__Group_4__1 + { + pushFollow(FOLLOW_25); + rule__ParameterListType__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterListType__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group_4__0" + + + // $ANTLR start "rule__ParameterListType__Group_4__0__Impl" + // InternalRos2Parser.g:10360:1: rule__ParameterListType__Group_4__0__Impl : ( Comma ) ; + public final void rule__ParameterListType__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10364:1: ( ( Comma ) ) + // InternalRos2Parser.g:10365:1: ( Comma ) + { + // InternalRos2Parser.g:10365:1: ( Comma ) + // InternalRos2Parser.g:10366:2: Comma + { + before(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group_4__0__Impl" + + + // $ANTLR start "rule__ParameterListType__Group_4__1" + // InternalRos2Parser.g:10375:1: rule__ParameterListType__Group_4__1 : rule__ParameterListType__Group_4__1__Impl ; + public final void rule__ParameterListType__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10379:1: ( rule__ParameterListType__Group_4__1__Impl ) + // InternalRos2Parser.g:10380:2: rule__ParameterListType__Group_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterListType__Group_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group_4__1" + + + // $ANTLR start "rule__ParameterListType__Group_4__1__Impl" + // InternalRos2Parser.g:10386:1: rule__ParameterListType__Group_4__1__Impl : ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) ; + public final void rule__ParameterListType__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10390:1: ( ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) ) + // InternalRos2Parser.g:10391:1: ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) + { + // InternalRos2Parser.g:10391:1: ( ( rule__ParameterListType__SequenceAssignment_4_1 ) ) + // InternalRos2Parser.g:10392:2: ( rule__ParameterListType__SequenceAssignment_4_1 ) + { + before(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); + // InternalRos2Parser.g:10393:2: ( rule__ParameterListType__SequenceAssignment_4_1 ) + // InternalRos2Parser.g:10393:3: rule__ParameterListType__SequenceAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__ParameterListType__SequenceAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListTypeAccess().getSequenceAssignment_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__Group_4__1__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__0" + // InternalRos2Parser.g:10402:1: rule__ParameterStructType__Group__0 : rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 ; + public final void rule__ParameterStructType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10406:1: ( rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 ) + // InternalRos2Parser.g:10407:2: rule__ParameterStructType__Group__0__Impl rule__ParameterStructType__Group__1 + { + pushFollow(FOLLOW_52); + rule__ParameterStructType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__0" + + + // $ANTLR start "rule__ParameterStructType__Group__0__Impl" + // InternalRos2Parser.g:10414:1: rule__ParameterStructType__Group__0__Impl : ( () ) ; + public final void rule__ParameterStructType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10418:1: ( ( () ) ) + // InternalRos2Parser.g:10419:1: ( () ) + { + // InternalRos2Parser.g:10419:1: ( () ) + // InternalRos2Parser.g:10420:2: () + { + before(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); + // InternalRos2Parser.g:10421:2: () + // InternalRos2Parser.g:10421:3: + { + } + + after(grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__1" + // InternalRos2Parser.g:10429:1: rule__ParameterStructType__Group__1 : rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 ; + public final void rule__ParameterStructType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10433:1: ( rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 ) + // InternalRos2Parser.g:10434:2: rule__ParameterStructType__Group__1__Impl rule__ParameterStructType__Group__2 + { + pushFollow(FOLLOW_10); + rule__ParameterStructType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__1" + + + // $ANTLR start "rule__ParameterStructType__Group__1__Impl" + // InternalRos2Parser.g:10441:1: rule__ParameterStructType__Group__1__Impl : ( Struct ) ; + public final void rule__ParameterStructType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10445:1: ( ( Struct ) ) + // InternalRos2Parser.g:10446:1: ( Struct ) + { + // InternalRos2Parser.g:10446:1: ( Struct ) + // InternalRos2Parser.g:10447:2: Struct + { + before(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); + match(input,Struct,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__2" + // InternalRos2Parser.g:10456:1: rule__ParameterStructType__Group__2 : rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 ; + public final void rule__ParameterStructType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10460:1: ( rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 ) + // InternalRos2Parser.g:10461:2: rule__ParameterStructType__Group__2__Impl rule__ParameterStructType__Group__3 + { + pushFollow(FOLLOW_7); + rule__ParameterStructType__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__2" + + + // $ANTLR start "rule__ParameterStructType__Group__2__Impl" + // InternalRos2Parser.g:10468:1: rule__ParameterStructType__Group__2__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterStructType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10472:1: ( ( LeftSquareBracket ) ) + // InternalRos2Parser.g:10473:1: ( LeftSquareBracket ) + { + // InternalRos2Parser.g:10473:1: ( LeftSquareBracket ) + // InternalRos2Parser.g:10474:2: LeftSquareBracket + { + before(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__3" + // InternalRos2Parser.g:10483:1: rule__ParameterStructType__Group__3 : rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 ; + public final void rule__ParameterStructType__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10487:1: ( rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 ) + // InternalRos2Parser.g:10488:2: rule__ParameterStructType__Group__3__Impl rule__ParameterStructType__Group__4 + { + pushFollow(FOLLOW_12); + rule__ParameterStructType__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__3" + + + // $ANTLR start "rule__ParameterStructType__Group__3__Impl" + // InternalRos2Parser.g:10495:1: rule__ParameterStructType__Group__3__Impl : ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) ; + public final void rule__ParameterStructType__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10499:1: ( ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) ) + // InternalRos2Parser.g:10500:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) + { + // InternalRos2Parser.g:10500:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) ) + // InternalRos2Parser.g:10501:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) + { + before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); + // InternalRos2Parser.g:10502:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_3 ) + // InternalRos2Parser.g:10502:3: rule__ParameterStructType__ParameterstructypetmemberAssignment_3 + { + pushFollow(FOLLOW_2); + rule__ParameterStructType__ParameterstructypetmemberAssignment_3(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__3__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__4" + // InternalRos2Parser.g:10510:1: rule__ParameterStructType__Group__4 : rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 ; + public final void rule__ParameterStructType__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10514:1: ( rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 ) + // InternalRos2Parser.g:10515:2: rule__ParameterStructType__Group__4__Impl rule__ParameterStructType__Group__5 + { + pushFollow(FOLLOW_12); + rule__ParameterStructType__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__4" + + + // $ANTLR start "rule__ParameterStructType__Group__4__Impl" + // InternalRos2Parser.g:10522:1: rule__ParameterStructType__Group__4__Impl : ( ( rule__ParameterStructType__Group_4__0 )* ) ; + public final void rule__ParameterStructType__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10526:1: ( ( ( rule__ParameterStructType__Group_4__0 )* ) ) + // InternalRos2Parser.g:10527:1: ( ( rule__ParameterStructType__Group_4__0 )* ) + { + // InternalRos2Parser.g:10527:1: ( ( rule__ParameterStructType__Group_4__0 )* ) + // InternalRos2Parser.g:10528:2: ( rule__ParameterStructType__Group_4__0 )* + { + before(grammarAccess.getParameterStructTypeAccess().getGroup_4()); + // InternalRos2Parser.g:10529:2: ( rule__ParameterStructType__Group_4__0 )* + loop64: + do { + int alt64=2; + int LA64_0 = input.LA(1); + + if ( (LA64_0==Comma) ) { + alt64=1; + } + + + switch (alt64) { + case 1 : + // InternalRos2Parser.g:10529:3: rule__ParameterStructType__Group_4__0 + { + pushFollow(FOLLOW_13); + rule__ParameterStructType__Group_4__0(); + + state._fsp--; + + + } + break; + + default : + break loop64; + } + } while (true); + + after(grammarAccess.getParameterStructTypeAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__4__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group__5" + // InternalRos2Parser.g:10537:1: rule__ParameterStructType__Group__5 : rule__ParameterStructType__Group__5__Impl ; + public final void rule__ParameterStructType__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10541:1: ( rule__ParameterStructType__Group__5__Impl ) + // InternalRos2Parser.g:10542:2: rule__ParameterStructType__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group__5__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__5" + + + // $ANTLR start "rule__ParameterStructType__Group__5__Impl" + // InternalRos2Parser.g:10548:1: rule__ParameterStructType__Group__5__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterStructType__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10552:1: ( ( RightSquareBracket ) ) + // InternalRos2Parser.g:10553:1: ( RightSquareBracket ) + { + // InternalRos2Parser.g:10553:1: ( RightSquareBracket ) + // InternalRos2Parser.g:10554:2: RightSquareBracket + { + before(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group__5__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group_4__0" + // InternalRos2Parser.g:10564:1: rule__ParameterStructType__Group_4__0 : rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 ; + public final void rule__ParameterStructType__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10568:1: ( rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 ) + // InternalRos2Parser.g:10569:2: rule__ParameterStructType__Group_4__0__Impl rule__ParameterStructType__Group_4__1 + { + pushFollow(FOLLOW_7); + rule__ParameterStructType__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group_4__0" + + + // $ANTLR start "rule__ParameterStructType__Group_4__0__Impl" + // InternalRos2Parser.g:10576:1: rule__ParameterStructType__Group_4__0__Impl : ( Comma ) ; + public final void rule__ParameterStructType__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10580:1: ( ( Comma ) ) + // InternalRos2Parser.g:10581:1: ( Comma ) + { + // InternalRos2Parser.g:10581:1: ( Comma ) + // InternalRos2Parser.g:10582:2: Comma + { + before(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group_4__0__Impl" + + + // $ANTLR start "rule__ParameterStructType__Group_4__1" + // InternalRos2Parser.g:10591:1: rule__ParameterStructType__Group_4__1 : rule__ParameterStructType__Group_4__1__Impl ; + public final void rule__ParameterStructType__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10595:1: ( rule__ParameterStructType__Group_4__1__Impl ) + // InternalRos2Parser.g:10596:2: rule__ParameterStructType__Group_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStructType__Group_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group_4__1" + + + // $ANTLR start "rule__ParameterStructType__Group_4__1__Impl" + // InternalRos2Parser.g:10602:1: rule__ParameterStructType__Group_4__1__Impl : ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) ; + public final void rule__ParameterStructType__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10606:1: ( ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) ) + // InternalRos2Parser.g:10607:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) + { + // InternalRos2Parser.g:10607:1: ( ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) ) + // InternalRos2Parser.g:10608:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) + { + before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); + // InternalRos2Parser.g:10609:2: ( rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 ) + // InternalRos2Parser.g:10609:3: rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberAssignment_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__Group_4__1__Impl" + + + // $ANTLR start "rule__ParameterIntegerType__Group__0" + // InternalRos2Parser.g:10618:1: rule__ParameterIntegerType__Group__0 : rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 ; + public final void rule__ParameterIntegerType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10622:1: ( rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 ) + // InternalRos2Parser.g:10623:2: rule__ParameterIntegerType__Group__0__Impl rule__ParameterIntegerType__Group__1 + { + pushFollow(FOLLOW_53); + rule__ParameterIntegerType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__0" + + + // $ANTLR start "rule__ParameterIntegerType__Group__0__Impl" + // InternalRos2Parser.g:10630:1: rule__ParameterIntegerType__Group__0__Impl : ( () ) ; + public final void rule__ParameterIntegerType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10634:1: ( ( () ) ) + // InternalRos2Parser.g:10635:1: ( () ) + { + // InternalRos2Parser.g:10635:1: ( () ) + // InternalRos2Parser.g:10636:2: () + { + before(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); + // InternalRos2Parser.g:10637:2: () + // InternalRos2Parser.g:10637:3: + { + } + + after(grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterIntegerType__Group__1" + // InternalRos2Parser.g:10645:1: rule__ParameterIntegerType__Group__1 : rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 ; + public final void rule__ParameterIntegerType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10649:1: ( rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 ) + // InternalRos2Parser.g:10650:2: rule__ParameterIntegerType__Group__1__Impl rule__ParameterIntegerType__Group__2 + { + pushFollow(FOLLOW_54); + rule__ParameterIntegerType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__1" + + + // $ANTLR start "rule__ParameterIntegerType__Group__1__Impl" + // InternalRos2Parser.g:10657:1: rule__ParameterIntegerType__Group__1__Impl : ( Integer ) ; + public final void rule__ParameterIntegerType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10661:1: ( ( Integer ) ) + // InternalRos2Parser.g:10662:1: ( Integer ) + { + // InternalRos2Parser.g:10662:1: ( Integer ) + // InternalRos2Parser.g:10663:2: Integer + { + before(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); + match(input,Integer,FOLLOW_2); + after(grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterIntegerType__Group__2" + // InternalRos2Parser.g:10672:1: rule__ParameterIntegerType__Group__2 : rule__ParameterIntegerType__Group__2__Impl ; + public final void rule__ParameterIntegerType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10676:1: ( rule__ParameterIntegerType__Group__2__Impl ) + // InternalRos2Parser.g:10677:2: rule__ParameterIntegerType__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__2" + + + // $ANTLR start "rule__ParameterIntegerType__Group__2__Impl" + // InternalRos2Parser.g:10683:1: rule__ParameterIntegerType__Group__2__Impl : ( ( rule__ParameterIntegerType__Group_2__0 )? ) ; + public final void rule__ParameterIntegerType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10687:1: ( ( ( rule__ParameterIntegerType__Group_2__0 )? ) ) + // InternalRos2Parser.g:10688:1: ( ( rule__ParameterIntegerType__Group_2__0 )? ) + { + // InternalRos2Parser.g:10688:1: ( ( rule__ParameterIntegerType__Group_2__0 )? ) + // InternalRos2Parser.g:10689:2: ( rule__ParameterIntegerType__Group_2__0 )? + { + before(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); + // InternalRos2Parser.g:10690:2: ( rule__ParameterIntegerType__Group_2__0 )? + int alt65=2; + int LA65_0 = input.LA(1); + + if ( (LA65_0==Default) ) { + int LA65_1 = input.LA(2); + + if ( (LA65_1==RULE_DECINT) ) { + alt65=1; + } + } + switch (alt65) { + case 1 : + // InternalRos2Parser.g:10690:3: rule__ParameterIntegerType__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterIntegerTypeAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterIntegerType__Group_2__0" + // InternalRos2Parser.g:10699:1: rule__ParameterIntegerType__Group_2__0 : rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 ; + public final void rule__ParameterIntegerType__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10703:1: ( rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 ) + // InternalRos2Parser.g:10704:2: rule__ParameterIntegerType__Group_2__0__Impl rule__ParameterIntegerType__Group_2__1 + { + pushFollow(FOLLOW_17); + rule__ParameterIntegerType__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group_2__0" + + + // $ANTLR start "rule__ParameterIntegerType__Group_2__0__Impl" + // InternalRos2Parser.g:10711:1: rule__ParameterIntegerType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterIntegerType__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10715:1: ( ( Default ) ) + // InternalRos2Parser.g:10716:1: ( Default ) + { + // InternalRos2Parser.g:10716:1: ( Default ) + // InternalRos2Parser.g:10717:2: Default + { + before(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterIntegerType__Group_2__1" + // InternalRos2Parser.g:10726:1: rule__ParameterIntegerType__Group_2__1 : rule__ParameterIntegerType__Group_2__1__Impl ; + public final void rule__ParameterIntegerType__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10730:1: ( rule__ParameterIntegerType__Group_2__1__Impl ) + // InternalRos2Parser.g:10731:2: rule__ParameterIntegerType__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group_2__1" + + + // $ANTLR start "rule__ParameterIntegerType__Group_2__1__Impl" + // InternalRos2Parser.g:10737:1: rule__ParameterIntegerType__Group_2__1__Impl : ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterIntegerType__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10741:1: ( ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) ) + // InternalRos2Parser.g:10742:1: ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) + { + // InternalRos2Parser.g:10742:1: ( ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) ) + // InternalRos2Parser.g:10743:2: ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) + { + before(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); + // InternalRos2Parser.g:10744:2: ( rule__ParameterIntegerType__DefaultAssignment_2_1 ) + // InternalRos2Parser.g:10744:3: rule__ParameterIntegerType__DefaultAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterIntegerType__DefaultAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterIntegerTypeAccess().getDefaultAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterStringType__Group__0" + // InternalRos2Parser.g:10753:1: rule__ParameterStringType__Group__0 : rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 ; + public final void rule__ParameterStringType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10757:1: ( rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 ) + // InternalRos2Parser.g:10758:2: rule__ParameterStringType__Group__0__Impl rule__ParameterStringType__Group__1 + { + pushFollow(FOLLOW_55); + rule__ParameterStringType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__0" + + + // $ANTLR start "rule__ParameterStringType__Group__0__Impl" + // InternalRos2Parser.g:10765:1: rule__ParameterStringType__Group__0__Impl : ( () ) ; + public final void rule__ParameterStringType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10769:1: ( ( () ) ) + // InternalRos2Parser.g:10770:1: ( () ) + { + // InternalRos2Parser.g:10770:1: ( () ) + // InternalRos2Parser.g:10771:2: () + { + before(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); + // InternalRos2Parser.g:10772:2: () + // InternalRos2Parser.g:10772:3: + { + } + + after(grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterStringType__Group__1" + // InternalRos2Parser.g:10780:1: rule__ParameterStringType__Group__1 : rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 ; + public final void rule__ParameterStringType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10784:1: ( rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 ) + // InternalRos2Parser.g:10785:2: rule__ParameterStringType__Group__1__Impl rule__ParameterStringType__Group__2 + { + pushFollow(FOLLOW_54); + rule__ParameterStringType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__1" + + + // $ANTLR start "rule__ParameterStringType__Group__1__Impl" + // InternalRos2Parser.g:10792:1: rule__ParameterStringType__Group__1__Impl : ( String ) ; + public final void rule__ParameterStringType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10796:1: ( ( String ) ) + // InternalRos2Parser.g:10797:1: ( String ) + { + // InternalRos2Parser.g:10797:1: ( String ) + // InternalRos2Parser.g:10798:2: String + { + before(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); + match(input,String,FOLLOW_2); + after(grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterStringType__Group__2" + // InternalRos2Parser.g:10807:1: rule__ParameterStringType__Group__2 : rule__ParameterStringType__Group__2__Impl ; + public final void rule__ParameterStringType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10811:1: ( rule__ParameterStringType__Group__2__Impl ) + // InternalRos2Parser.g:10812:2: rule__ParameterStringType__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__2" + + + // $ANTLR start "rule__ParameterStringType__Group__2__Impl" + // InternalRos2Parser.g:10818:1: rule__ParameterStringType__Group__2__Impl : ( ( rule__ParameterStringType__Group_2__0 )? ) ; + public final void rule__ParameterStringType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10822:1: ( ( ( rule__ParameterStringType__Group_2__0 )? ) ) + // InternalRos2Parser.g:10823:1: ( ( rule__ParameterStringType__Group_2__0 )? ) + { + // InternalRos2Parser.g:10823:1: ( ( rule__ParameterStringType__Group_2__0 )? ) + // InternalRos2Parser.g:10824:2: ( rule__ParameterStringType__Group_2__0 )? + { + before(grammarAccess.getParameterStringTypeAccess().getGroup_2()); + // InternalRos2Parser.g:10825:2: ( rule__ParameterStringType__Group_2__0 )? + int alt66=2; + int LA66_0 = input.LA(1); + + if ( (LA66_0==Default) ) { + int LA66_1 = input.LA(2); + + if ( (LA66_1==RULE_ID||LA66_1==RULE_STRING) ) { + alt66=1; + } + } + switch (alt66) { + case 1 : + // InternalRos2Parser.g:10825:3: rule__ParameterStringType__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterStringTypeAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterStringType__Group_2__0" + // InternalRos2Parser.g:10834:1: rule__ParameterStringType__Group_2__0 : rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 ; + public final void rule__ParameterStringType__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10838:1: ( rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 ) + // InternalRos2Parser.g:10839:2: rule__ParameterStringType__Group_2__0__Impl rule__ParameterStringType__Group_2__1 + { + pushFollow(FOLLOW_7); + rule__ParameterStringType__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group_2__0" + + + // $ANTLR start "rule__ParameterStringType__Group_2__0__Impl" + // InternalRos2Parser.g:10846:1: rule__ParameterStringType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterStringType__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10850:1: ( ( Default ) ) + // InternalRos2Parser.g:10851:1: ( Default ) + { + // InternalRos2Parser.g:10851:1: ( Default ) + // InternalRos2Parser.g:10852:2: Default + { + before(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterStringType__Group_2__1" + // InternalRos2Parser.g:10861:1: rule__ParameterStringType__Group_2__1 : rule__ParameterStringType__Group_2__1__Impl ; + public final void rule__ParameterStringType__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10865:1: ( rule__ParameterStringType__Group_2__1__Impl ) + // InternalRos2Parser.g:10866:2: rule__ParameterStringType__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStringType__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group_2__1" + + + // $ANTLR start "rule__ParameterStringType__Group_2__1__Impl" + // InternalRos2Parser.g:10872:1: rule__ParameterStringType__Group_2__1__Impl : ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterStringType__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10876:1: ( ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) ) + // InternalRos2Parser.g:10877:1: ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) + { + // InternalRos2Parser.g:10877:1: ( ( rule__ParameterStringType__DefaultAssignment_2_1 ) ) + // InternalRos2Parser.g:10878:2: ( rule__ParameterStringType__DefaultAssignment_2_1 ) + { + before(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); + // InternalRos2Parser.g:10879:2: ( rule__ParameterStringType__DefaultAssignment_2_1 ) + // InternalRos2Parser.g:10879:3: rule__ParameterStringType__DefaultAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStringType__DefaultAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStringTypeAccess().getDefaultAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterDoubleType__Group__0" + // InternalRos2Parser.g:10888:1: rule__ParameterDoubleType__Group__0 : rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 ; + public final void rule__ParameterDoubleType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10892:1: ( rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 ) + // InternalRos2Parser.g:10893:2: rule__ParameterDoubleType__Group__0__Impl rule__ParameterDoubleType__Group__1 + { + pushFollow(FOLLOW_56); + rule__ParameterDoubleType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__0" + + + // $ANTLR start "rule__ParameterDoubleType__Group__0__Impl" + // InternalRos2Parser.g:10900:1: rule__ParameterDoubleType__Group__0__Impl : ( () ) ; + public final void rule__ParameterDoubleType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10904:1: ( ( () ) ) + // InternalRos2Parser.g:10905:1: ( () ) + { + // InternalRos2Parser.g:10905:1: ( () ) + // InternalRos2Parser.g:10906:2: () + { + before(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); + // InternalRos2Parser.g:10907:2: () + // InternalRos2Parser.g:10907:3: + { + } + + after(grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterDoubleType__Group__1" + // InternalRos2Parser.g:10915:1: rule__ParameterDoubleType__Group__1 : rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 ; + public final void rule__ParameterDoubleType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10919:1: ( rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 ) + // InternalRos2Parser.g:10920:2: rule__ParameterDoubleType__Group__1__Impl rule__ParameterDoubleType__Group__2 + { + pushFollow(FOLLOW_54); + rule__ParameterDoubleType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__1" + + + // $ANTLR start "rule__ParameterDoubleType__Group__1__Impl" + // InternalRos2Parser.g:10927:1: rule__ParameterDoubleType__Group__1__Impl : ( Double ) ; + public final void rule__ParameterDoubleType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10931:1: ( ( Double ) ) + // InternalRos2Parser.g:10932:1: ( Double ) + { + // InternalRos2Parser.g:10932:1: ( Double ) + // InternalRos2Parser.g:10933:2: Double + { + before(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); + match(input,Double,FOLLOW_2); + after(grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterDoubleType__Group__2" + // InternalRos2Parser.g:10942:1: rule__ParameterDoubleType__Group__2 : rule__ParameterDoubleType__Group__2__Impl ; + public final void rule__ParameterDoubleType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10946:1: ( rule__ParameterDoubleType__Group__2__Impl ) + // InternalRos2Parser.g:10947:2: rule__ParameterDoubleType__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__2" + + + // $ANTLR start "rule__ParameterDoubleType__Group__2__Impl" + // InternalRos2Parser.g:10953:1: rule__ParameterDoubleType__Group__2__Impl : ( ( rule__ParameterDoubleType__Group_2__0 )? ) ; + public final void rule__ParameterDoubleType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10957:1: ( ( ( rule__ParameterDoubleType__Group_2__0 )? ) ) + // InternalRos2Parser.g:10958:1: ( ( rule__ParameterDoubleType__Group_2__0 )? ) + { + // InternalRos2Parser.g:10958:1: ( ( rule__ParameterDoubleType__Group_2__0 )? ) + // InternalRos2Parser.g:10959:2: ( rule__ParameterDoubleType__Group_2__0 )? + { + before(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); + // InternalRos2Parser.g:10960:2: ( rule__ParameterDoubleType__Group_2__0 )? + int alt67=2; + int LA67_0 = input.LA(1); + + if ( (LA67_0==Default) ) { + int LA67_1 = input.LA(2); + + if ( (LA67_1==RULE_DOUBLE) ) { + alt67=1; + } + } + switch (alt67) { + case 1 : + // InternalRos2Parser.g:10960:3: rule__ParameterDoubleType__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterDoubleTypeAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterDoubleType__Group_2__0" + // InternalRos2Parser.g:10969:1: rule__ParameterDoubleType__Group_2__0 : rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 ; + public final void rule__ParameterDoubleType__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10973:1: ( rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 ) + // InternalRos2Parser.g:10974:2: rule__ParameterDoubleType__Group_2__0__Impl rule__ParameterDoubleType__Group_2__1 + { + pushFollow(FOLLOW_57); + rule__ParameterDoubleType__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group_2__0" + + + // $ANTLR start "rule__ParameterDoubleType__Group_2__0__Impl" + // InternalRos2Parser.g:10981:1: rule__ParameterDoubleType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterDoubleType__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:10985:1: ( ( Default ) ) + // InternalRos2Parser.g:10986:1: ( Default ) + { + // InternalRos2Parser.g:10986:1: ( Default ) + // InternalRos2Parser.g:10987:2: Default + { + before(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterDoubleType__Group_2__1" + // InternalRos2Parser.g:10996:1: rule__ParameterDoubleType__Group_2__1 : rule__ParameterDoubleType__Group_2__1__Impl ; + public final void rule__ParameterDoubleType__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11000:1: ( rule__ParameterDoubleType__Group_2__1__Impl ) + // InternalRos2Parser.g:11001:2: rule__ParameterDoubleType__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group_2__1" + + + // $ANTLR start "rule__ParameterDoubleType__Group_2__1__Impl" + // InternalRos2Parser.g:11007:1: rule__ParameterDoubleType__Group_2__1__Impl : ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterDoubleType__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11011:1: ( ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) ) + // InternalRos2Parser.g:11012:1: ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) + { + // InternalRos2Parser.g:11012:1: ( ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) ) + // InternalRos2Parser.g:11013:2: ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) + { + before(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); + // InternalRos2Parser.g:11014:2: ( rule__ParameterDoubleType__DefaultAssignment_2_1 ) + // InternalRos2Parser.g:11014:3: rule__ParameterDoubleType__DefaultAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterDoubleType__DefaultAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterDoubleTypeAccess().getDefaultAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterBooleanType__Group__0" + // InternalRos2Parser.g:11023:1: rule__ParameterBooleanType__Group__0 : rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 ; + public final void rule__ParameterBooleanType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11027:1: ( rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 ) + // InternalRos2Parser.g:11028:2: rule__ParameterBooleanType__Group__0__Impl rule__ParameterBooleanType__Group__1 + { + pushFollow(FOLLOW_58); + rule__ParameterBooleanType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__0" + + + // $ANTLR start "rule__ParameterBooleanType__Group__0__Impl" + // InternalRos2Parser.g:11035:1: rule__ParameterBooleanType__Group__0__Impl : ( () ) ; + public final void rule__ParameterBooleanType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11039:1: ( ( () ) ) + // InternalRos2Parser.g:11040:1: ( () ) + { + // InternalRos2Parser.g:11040:1: ( () ) + // InternalRos2Parser.g:11041:2: () + { + before(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); + // InternalRos2Parser.g:11042:2: () + // InternalRos2Parser.g:11042:3: + { + } + + after(grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterBooleanType__Group__1" + // InternalRos2Parser.g:11050:1: rule__ParameterBooleanType__Group__1 : rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 ; + public final void rule__ParameterBooleanType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11054:1: ( rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 ) + // InternalRos2Parser.g:11055:2: rule__ParameterBooleanType__Group__1__Impl rule__ParameterBooleanType__Group__2 + { + pushFollow(FOLLOW_54); + rule__ParameterBooleanType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__1" + + + // $ANTLR start "rule__ParameterBooleanType__Group__1__Impl" + // InternalRos2Parser.g:11062:1: rule__ParameterBooleanType__Group__1__Impl : ( Boolean ) ; + public final void rule__ParameterBooleanType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11066:1: ( ( Boolean ) ) + // InternalRos2Parser.g:11067:1: ( Boolean ) + { + // InternalRos2Parser.g:11067:1: ( Boolean ) + // InternalRos2Parser.g:11068:2: Boolean + { + before(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); + match(input,Boolean,FOLLOW_2); + after(grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterBooleanType__Group__2" + // InternalRos2Parser.g:11077:1: rule__ParameterBooleanType__Group__2 : rule__ParameterBooleanType__Group__2__Impl ; + public final void rule__ParameterBooleanType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11081:1: ( rule__ParameterBooleanType__Group__2__Impl ) + // InternalRos2Parser.g:11082:2: rule__ParameterBooleanType__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__2" + + + // $ANTLR start "rule__ParameterBooleanType__Group__2__Impl" + // InternalRos2Parser.g:11088:1: rule__ParameterBooleanType__Group__2__Impl : ( ( rule__ParameterBooleanType__Group_2__0 )? ) ; + public final void rule__ParameterBooleanType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11092:1: ( ( ( rule__ParameterBooleanType__Group_2__0 )? ) ) + // InternalRos2Parser.g:11093:1: ( ( rule__ParameterBooleanType__Group_2__0 )? ) + { + // InternalRos2Parser.g:11093:1: ( ( rule__ParameterBooleanType__Group_2__0 )? ) + // InternalRos2Parser.g:11094:2: ( rule__ParameterBooleanType__Group_2__0 )? + { + before(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); + // InternalRos2Parser.g:11095:2: ( rule__ParameterBooleanType__Group_2__0 )? + int alt68=2; + int LA68_0 = input.LA(1); + + if ( (LA68_0==Default) ) { + int LA68_1 = input.LA(2); + + if ( (LA68_1==RULE_BOOLEAN) ) { + alt68=1; + } + } + switch (alt68) { + case 1 : + // InternalRos2Parser.g:11095:3: rule__ParameterBooleanType__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterBooleanTypeAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterBooleanType__Group_2__0" + // InternalRos2Parser.g:11104:1: rule__ParameterBooleanType__Group_2__0 : rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 ; + public final void rule__ParameterBooleanType__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11108:1: ( rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 ) + // InternalRos2Parser.g:11109:2: rule__ParameterBooleanType__Group_2__0__Impl rule__ParameterBooleanType__Group_2__1 + { + pushFollow(FOLLOW_59); + rule__ParameterBooleanType__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group_2__0" + + + // $ANTLR start "rule__ParameterBooleanType__Group_2__0__Impl" + // InternalRos2Parser.g:11116:1: rule__ParameterBooleanType__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterBooleanType__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11120:1: ( ( Default ) ) + // InternalRos2Parser.g:11121:1: ( Default ) + { + // InternalRos2Parser.g:11121:1: ( Default ) + // InternalRos2Parser.g:11122:2: Default + { + before(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterBooleanType__Group_2__1" + // InternalRos2Parser.g:11131:1: rule__ParameterBooleanType__Group_2__1 : rule__ParameterBooleanType__Group_2__1__Impl ; + public final void rule__ParameterBooleanType__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11135:1: ( rule__ParameterBooleanType__Group_2__1__Impl ) + // InternalRos2Parser.g:11136:2: rule__ParameterBooleanType__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group_2__1" + + + // $ANTLR start "rule__ParameterBooleanType__Group_2__1__Impl" + // InternalRos2Parser.g:11142:1: rule__ParameterBooleanType__Group_2__1__Impl : ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterBooleanType__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11146:1: ( ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) ) + // InternalRos2Parser.g:11147:1: ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) + { + // InternalRos2Parser.g:11147:1: ( ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) ) + // InternalRos2Parser.g:11148:2: ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) + { + before(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); + // InternalRos2Parser.g:11149:2: ( rule__ParameterBooleanType__DefaultAssignment_2_1 ) + // InternalRos2Parser.g:11149:3: rule__ParameterBooleanType__DefaultAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterBooleanType__DefaultAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBooleanTypeAccess().getDefaultAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterBase64Type__Group__0" + // InternalRos2Parser.g:11158:1: rule__ParameterBase64Type__Group__0 : rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 ; + public final void rule__ParameterBase64Type__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11162:1: ( rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 ) + // InternalRos2Parser.g:11163:2: rule__ParameterBase64Type__Group__0__Impl rule__ParameterBase64Type__Group__1 + { + pushFollow(FOLLOW_60); + rule__ParameterBase64Type__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__0" + + + // $ANTLR start "rule__ParameterBase64Type__Group__0__Impl" + // InternalRos2Parser.g:11170:1: rule__ParameterBase64Type__Group__0__Impl : ( () ) ; + public final void rule__ParameterBase64Type__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11174:1: ( ( () ) ) + // InternalRos2Parser.g:11175:1: ( () ) + { + // InternalRos2Parser.g:11175:1: ( () ) + // InternalRos2Parser.g:11176:2: () + { + before(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); + // InternalRos2Parser.g:11177:2: () + // InternalRos2Parser.g:11177:3: + { + } + + after(grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__0__Impl" + + + // $ANTLR start "rule__ParameterBase64Type__Group__1" + // InternalRos2Parser.g:11185:1: rule__ParameterBase64Type__Group__1 : rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 ; + public final void rule__ParameterBase64Type__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11189:1: ( rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 ) + // InternalRos2Parser.g:11190:2: rule__ParameterBase64Type__Group__1__Impl rule__ParameterBase64Type__Group__2 + { + pushFollow(FOLLOW_54); + rule__ParameterBase64Type__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__1" + + + // $ANTLR start "rule__ParameterBase64Type__Group__1__Impl" + // InternalRos2Parser.g:11197:1: rule__ParameterBase64Type__Group__1__Impl : ( Base64 ) ; + public final void rule__ParameterBase64Type__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11201:1: ( ( Base64 ) ) + // InternalRos2Parser.g:11202:1: ( Base64 ) + { + // InternalRos2Parser.g:11202:1: ( Base64 ) + // InternalRos2Parser.g:11203:2: Base64 + { + before(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); + match(input,Base64,FOLLOW_2); + after(grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__1__Impl" + + + // $ANTLR start "rule__ParameterBase64Type__Group__2" + // InternalRos2Parser.g:11212:1: rule__ParameterBase64Type__Group__2 : rule__ParameterBase64Type__Group__2__Impl ; + public final void rule__ParameterBase64Type__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11216:1: ( rule__ParameterBase64Type__Group__2__Impl ) + // InternalRos2Parser.g:11217:2: rule__ParameterBase64Type__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__2" + + + // $ANTLR start "rule__ParameterBase64Type__Group__2__Impl" + // InternalRos2Parser.g:11223:1: rule__ParameterBase64Type__Group__2__Impl : ( ( rule__ParameterBase64Type__Group_2__0 )? ) ; + public final void rule__ParameterBase64Type__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11227:1: ( ( ( rule__ParameterBase64Type__Group_2__0 )? ) ) + // InternalRos2Parser.g:11228:1: ( ( rule__ParameterBase64Type__Group_2__0 )? ) + { + // InternalRos2Parser.g:11228:1: ( ( rule__ParameterBase64Type__Group_2__0 )? ) + // InternalRos2Parser.g:11229:2: ( rule__ParameterBase64Type__Group_2__0 )? + { + before(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); + // InternalRos2Parser.g:11230:2: ( rule__ParameterBase64Type__Group_2__0 )? + int alt69=2; + int LA69_0 = input.LA(1); + + if ( (LA69_0==Default) ) { + int LA69_1 = input.LA(2); + + if ( (LA69_1==RULE_BINARY) ) { + alt69=1; + } + } + switch (alt69) { + case 1 : + // InternalRos2Parser.g:11230:3: rule__ParameterBase64Type__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterBase64TypeAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group__2__Impl" + + + // $ANTLR start "rule__ParameterBase64Type__Group_2__0" + // InternalRos2Parser.g:11239:1: rule__ParameterBase64Type__Group_2__0 : rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 ; + public final void rule__ParameterBase64Type__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11243:1: ( rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 ) + // InternalRos2Parser.g:11244:2: rule__ParameterBase64Type__Group_2__0__Impl rule__ParameterBase64Type__Group_2__1 + { + pushFollow(FOLLOW_61); + rule__ParameterBase64Type__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group_2__0" + + + // $ANTLR start "rule__ParameterBase64Type__Group_2__0__Impl" + // InternalRos2Parser.g:11251:1: rule__ParameterBase64Type__Group_2__0__Impl : ( Default ) ; + public final void rule__ParameterBase64Type__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11255:1: ( ( Default ) ) + // InternalRos2Parser.g:11256:1: ( Default ) + { + // InternalRos2Parser.g:11256:1: ( Default ) + // InternalRos2Parser.g:11257:2: Default + { + before(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterBase64Type__Group_2__1" + // InternalRos2Parser.g:11266:1: rule__ParameterBase64Type__Group_2__1 : rule__ParameterBase64Type__Group_2__1__Impl ; + public final void rule__ParameterBase64Type__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11270:1: ( rule__ParameterBase64Type__Group_2__1__Impl ) + // InternalRos2Parser.g:11271:2: rule__ParameterBase64Type__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group_2__1" + + + // $ANTLR start "rule__ParameterBase64Type__Group_2__1__Impl" + // InternalRos2Parser.g:11277:1: rule__ParameterBase64Type__Group_2__1__Impl : ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) ; + public final void rule__ParameterBase64Type__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11281:1: ( ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) ) + // InternalRos2Parser.g:11282:1: ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) + { + // InternalRos2Parser.g:11282:1: ( ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) ) + // InternalRos2Parser.g:11283:2: ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) + { + before(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); + // InternalRos2Parser.g:11284:2: ( rule__ParameterBase64Type__DefaultAssignment_2_1 ) + // InternalRos2Parser.g:11284:3: rule__ParameterBase64Type__DefaultAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterBase64Type__DefaultAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterBase64TypeAccess().getDefaultAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__0" + // InternalRos2Parser.g:11293:1: rule__ParameterArrayType__Group__0 : rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 ; + public final void rule__ParameterArrayType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11297:1: ( rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 ) + // InternalRos2Parser.g:11298:2: rule__ParameterArrayType__Group__0__Impl rule__ParameterArrayType__Group__1 + { + pushFollow(FOLLOW_5); + rule__ParameterArrayType__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__0" + + + // $ANTLR start "rule__ParameterArrayType__Group__0__Impl" + // InternalRos2Parser.g:11305:1: rule__ParameterArrayType__Group__0__Impl : ( Array ) ; + public final void rule__ParameterArrayType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11309:1: ( ( Array ) ) + // InternalRos2Parser.g:11310:1: ( Array ) + { + // InternalRos2Parser.g:11310:1: ( Array ) + // InternalRos2Parser.g:11311:2: Array + { + before(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); + match(input,Array,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__0__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__1" + // InternalRos2Parser.g:11320:1: rule__ParameterArrayType__Group__1 : rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 ; + public final void rule__ParameterArrayType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11324:1: ( rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 ) + // InternalRos2Parser.g:11325:2: rule__ParameterArrayType__Group__1__Impl rule__ParameterArrayType__Group__2 + { + pushFollow(FOLLOW_24); + rule__ParameterArrayType__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__1" + + + // $ANTLR start "rule__ParameterArrayType__Group__1__Impl" + // InternalRos2Parser.g:11332:1: rule__ParameterArrayType__Group__1__Impl : ( RULE_BEGIN ) ; + public final void rule__ParameterArrayType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11336:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:11337:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:11337:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:11338:2: RULE_BEGIN + { + before(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__1__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__2" + // InternalRos2Parser.g:11347:1: rule__ParameterArrayType__Group__2 : rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 ; + public final void rule__ParameterArrayType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11351:1: ( rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 ) + // InternalRos2Parser.g:11352:2: rule__ParameterArrayType__Group__2__Impl rule__ParameterArrayType__Group__3 + { + pushFollow(FOLLOW_25); + rule__ParameterArrayType__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__2" + + + // $ANTLR start "rule__ParameterArrayType__Group__2__Impl" + // InternalRos2Parser.g:11359:1: rule__ParameterArrayType__Group__2__Impl : ( Type ) ; + public final void rule__ParameterArrayType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11363:1: ( ( Type ) ) + // InternalRos2Parser.g:11364:1: ( Type ) + { + // InternalRos2Parser.g:11364:1: ( Type ) + // InternalRos2Parser.g:11365:2: Type + { + before(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); + match(input,Type,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__2__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__3" + // InternalRos2Parser.g:11374:1: rule__ParameterArrayType__Group__3 : rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 ; + public final void rule__ParameterArrayType__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11378:1: ( rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 ) + // InternalRos2Parser.g:11379:2: rule__ParameterArrayType__Group__3__Impl rule__ParameterArrayType__Group__4 + { + pushFollow(FOLLOW_62); + rule__ParameterArrayType__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__3" + + + // $ANTLR start "rule__ParameterArrayType__Group__3__Impl" + // InternalRos2Parser.g:11386:1: rule__ParameterArrayType__Group__3__Impl : ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) ; + public final void rule__ParameterArrayType__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11390:1: ( ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) ) + // InternalRos2Parser.g:11391:1: ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) + { + // InternalRos2Parser.g:11391:1: ( ( rule__ParameterArrayType__TypeAssignment_3 ) ) + // InternalRos2Parser.g:11392:2: ( rule__ParameterArrayType__TypeAssignment_3 ) + { + before(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); + // InternalRos2Parser.g:11393:2: ( rule__ParameterArrayType__TypeAssignment_3 ) + // InternalRos2Parser.g:11393:3: rule__ParameterArrayType__TypeAssignment_3 + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__TypeAssignment_3(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterArrayTypeAccess().getTypeAssignment_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__3__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__4" + // InternalRos2Parser.g:11401:1: rule__ParameterArrayType__Group__4 : rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 ; + public final void rule__ParameterArrayType__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11405:1: ( rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 ) + // InternalRos2Parser.g:11406:2: rule__ParameterArrayType__Group__4__Impl rule__ParameterArrayType__Group__5 + { + pushFollow(FOLLOW_62); + rule__ParameterArrayType__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__4" + + + // $ANTLR start "rule__ParameterArrayType__Group__4__Impl" + // InternalRos2Parser.g:11413:1: rule__ParameterArrayType__Group__4__Impl : ( ( rule__ParameterArrayType__Group_4__0 )? ) ; + public final void rule__ParameterArrayType__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11417:1: ( ( ( rule__ParameterArrayType__Group_4__0 )? ) ) + // InternalRos2Parser.g:11418:1: ( ( rule__ParameterArrayType__Group_4__0 )? ) + { + // InternalRos2Parser.g:11418:1: ( ( rule__ParameterArrayType__Group_4__0 )? ) + // InternalRos2Parser.g:11419:2: ( rule__ParameterArrayType__Group_4__0 )? + { + before(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); + // InternalRos2Parser.g:11420:2: ( rule__ParameterArrayType__Group_4__0 )? + int alt70=2; + int LA70_0 = input.LA(1); + + if ( (LA70_0==Default) ) { + alt70=1; + } + switch (alt70) { + case 1 : + // InternalRos2Parser.g:11420:3: rule__ParameterArrayType__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group_4__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterArrayTypeAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__4__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group__5" + // InternalRos2Parser.g:11428:1: rule__ParameterArrayType__Group__5 : rule__ParameterArrayType__Group__5__Impl ; + public final void rule__ParameterArrayType__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11432:1: ( rule__ParameterArrayType__Group__5__Impl ) + // InternalRos2Parser.g:11433:2: rule__ParameterArrayType__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group__5__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__5" + + + // $ANTLR start "rule__ParameterArrayType__Group__5__Impl" + // InternalRos2Parser.g:11439:1: rule__ParameterArrayType__Group__5__Impl : ( RULE_END ) ; + public final void rule__ParameterArrayType__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11443:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:11444:1: ( RULE_END ) + { + // InternalRos2Parser.g:11444:1: ( RULE_END ) + // InternalRos2Parser.g:11445:2: RULE_END + { + before(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group__5__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group_4__0" + // InternalRos2Parser.g:11455:1: rule__ParameterArrayType__Group_4__0 : rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 ; + public final void rule__ParameterArrayType__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11459:1: ( rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 ) + // InternalRos2Parser.g:11460:2: rule__ParameterArrayType__Group_4__0__Impl rule__ParameterArrayType__Group_4__1 + { + pushFollow(FOLLOW_10); + rule__ParameterArrayType__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group_4__0" + + + // $ANTLR start "rule__ParameterArrayType__Group_4__0__Impl" + // InternalRos2Parser.g:11467:1: rule__ParameterArrayType__Group_4__0__Impl : ( Default ) ; + public final void rule__ParameterArrayType__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11471:1: ( ( Default ) ) + // InternalRos2Parser.g:11472:1: ( Default ) + { + // InternalRos2Parser.g:11472:1: ( Default ) + // InternalRos2Parser.g:11473:2: Default + { + before(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); + match(input,Default,FOLLOW_2); + after(grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group_4__0__Impl" + + + // $ANTLR start "rule__ParameterArrayType__Group_4__1" + // InternalRos2Parser.g:11482:1: rule__ParameterArrayType__Group_4__1 : rule__ParameterArrayType__Group_4__1__Impl ; + public final void rule__ParameterArrayType__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11486:1: ( rule__ParameterArrayType__Group_4__1__Impl ) + // InternalRos2Parser.g:11487:2: rule__ParameterArrayType__Group_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__Group_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group_4__1" + + + // $ANTLR start "rule__ParameterArrayType__Group_4__1__Impl" + // InternalRos2Parser.g:11493:1: rule__ParameterArrayType__Group_4__1__Impl : ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) ; + public final void rule__ParameterArrayType__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11497:1: ( ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) ) + // InternalRos2Parser.g:11498:1: ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) + { + // InternalRos2Parser.g:11498:1: ( ( rule__ParameterArrayType__DefaultAssignment_4_1 ) ) + // InternalRos2Parser.g:11499:2: ( rule__ParameterArrayType__DefaultAssignment_4_1 ) + { + before(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); + // InternalRos2Parser.g:11500:2: ( rule__ParameterArrayType__DefaultAssignment_4_1 ) + // InternalRos2Parser.g:11500:3: rule__ParameterArrayType__DefaultAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__ParameterArrayType__DefaultAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterArrayTypeAccess().getDefaultAssignment_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__Group_4__1__Impl" + + + // $ANTLR start "rule__ParameterList__Group__0" + // InternalRos2Parser.g:11509:1: rule__ParameterList__Group__0 : rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 ; + public final void rule__ParameterList__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11513:1: ( rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 ) + // InternalRos2Parser.g:11514:2: rule__ParameterList__Group__0__Impl rule__ParameterList__Group__1 + { + pushFollow(FOLLOW_10); + rule__ParameterList__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterList__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__0" + + + // $ANTLR start "rule__ParameterList__Group__0__Impl" + // InternalRos2Parser.g:11521:1: rule__ParameterList__Group__0__Impl : ( () ) ; + public final void rule__ParameterList__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11525:1: ( ( () ) ) + // InternalRos2Parser.g:11526:1: ( () ) + { + // InternalRos2Parser.g:11526:1: ( () ) + // InternalRos2Parser.g:11527:2: () + { + before(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); + // InternalRos2Parser.g:11528:2: () + // InternalRos2Parser.g:11528:3: + { + } + + after(grammarAccess.getParameterListAccess().getParameterSequenceAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__0__Impl" + + + // $ANTLR start "rule__ParameterList__Group__1" + // InternalRos2Parser.g:11536:1: rule__ParameterList__Group__1 : rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 ; + public final void rule__ParameterList__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11540:1: ( rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 ) + // InternalRos2Parser.g:11541:2: rule__ParameterList__Group__1__Impl rule__ParameterList__Group__2 + { + pushFollow(FOLLOW_63); + rule__ParameterList__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterList__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__1" + + + // $ANTLR start "rule__ParameterList__Group__1__Impl" + // InternalRos2Parser.g:11548:1: rule__ParameterList__Group__1__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterList__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11552:1: ( ( LeftSquareBracket ) ) + // InternalRos2Parser.g:11553:1: ( LeftSquareBracket ) + { + // InternalRos2Parser.g:11553:1: ( LeftSquareBracket ) + // InternalRos2Parser.g:11554:2: LeftSquareBracket + { + before(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__1__Impl" + + + // $ANTLR start "rule__ParameterList__Group__2" + // InternalRos2Parser.g:11563:1: rule__ParameterList__Group__2 : rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 ; + public final void rule__ParameterList__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11567:1: ( rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 ) + // InternalRos2Parser.g:11568:2: rule__ParameterList__Group__2__Impl rule__ParameterList__Group__3 + { + pushFollow(FOLLOW_12); + rule__ParameterList__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterList__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__2" + + + // $ANTLR start "rule__ParameterList__Group__2__Impl" + // InternalRos2Parser.g:11575:1: rule__ParameterList__Group__2__Impl : ( ( rule__ParameterList__ValueAssignment_2 ) ) ; + public final void rule__ParameterList__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11579:1: ( ( ( rule__ParameterList__ValueAssignment_2 ) ) ) + // InternalRos2Parser.g:11580:1: ( ( rule__ParameterList__ValueAssignment_2 ) ) + { + // InternalRos2Parser.g:11580:1: ( ( rule__ParameterList__ValueAssignment_2 ) ) + // InternalRos2Parser.g:11581:2: ( rule__ParameterList__ValueAssignment_2 ) + { + before(grammarAccess.getParameterListAccess().getValueAssignment_2()); + // InternalRos2Parser.g:11582:2: ( rule__ParameterList__ValueAssignment_2 ) + // InternalRos2Parser.g:11582:3: rule__ParameterList__ValueAssignment_2 + { + pushFollow(FOLLOW_2); + rule__ParameterList__ValueAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListAccess().getValueAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__2__Impl" + + + // $ANTLR start "rule__ParameterList__Group__3" + // InternalRos2Parser.g:11590:1: rule__ParameterList__Group__3 : rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 ; + public final void rule__ParameterList__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11594:1: ( rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 ) + // InternalRos2Parser.g:11595:2: rule__ParameterList__Group__3__Impl rule__ParameterList__Group__4 + { + pushFollow(FOLLOW_12); + rule__ParameterList__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterList__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__3" + + + // $ANTLR start "rule__ParameterList__Group__3__Impl" + // InternalRos2Parser.g:11602:1: rule__ParameterList__Group__3__Impl : ( ( rule__ParameterList__Group_3__0 )* ) ; + public final void rule__ParameterList__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11606:1: ( ( ( rule__ParameterList__Group_3__0 )* ) ) + // InternalRos2Parser.g:11607:1: ( ( rule__ParameterList__Group_3__0 )* ) + { + // InternalRos2Parser.g:11607:1: ( ( rule__ParameterList__Group_3__0 )* ) + // InternalRos2Parser.g:11608:2: ( rule__ParameterList__Group_3__0 )* + { + before(grammarAccess.getParameterListAccess().getGroup_3()); + // InternalRos2Parser.g:11609:2: ( rule__ParameterList__Group_3__0 )* + loop71: + do { + int alt71=2; + int LA71_0 = input.LA(1); + + if ( (LA71_0==Comma) ) { + alt71=1; + } + + + switch (alt71) { + case 1 : + // InternalRos2Parser.g:11609:3: rule__ParameterList__Group_3__0 + { + pushFollow(FOLLOW_13); + rule__ParameterList__Group_3__0(); + + state._fsp--; + + + } + break; + + default : + break loop71; + } + } while (true); + + after(grammarAccess.getParameterListAccess().getGroup_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__3__Impl" + + + // $ANTLR start "rule__ParameterList__Group__4" + // InternalRos2Parser.g:11617:1: rule__ParameterList__Group__4 : rule__ParameterList__Group__4__Impl ; + public final void rule__ParameterList__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11621:1: ( rule__ParameterList__Group__4__Impl ) + // InternalRos2Parser.g:11622:2: rule__ParameterList__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterList__Group__4__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__4" + + + // $ANTLR start "rule__ParameterList__Group__4__Impl" + // InternalRos2Parser.g:11628:1: rule__ParameterList__Group__4__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterList__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11632:1: ( ( RightSquareBracket ) ) + // InternalRos2Parser.g:11633:1: ( RightSquareBracket ) + { + // InternalRos2Parser.g:11633:1: ( RightSquareBracket ) + // InternalRos2Parser.g:11634:2: RightSquareBracket + { + before(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group__4__Impl" + + + // $ANTLR start "rule__ParameterList__Group_3__0" + // InternalRos2Parser.g:11644:1: rule__ParameterList__Group_3__0 : rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 ; + public final void rule__ParameterList__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11648:1: ( rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 ) + // InternalRos2Parser.g:11649:2: rule__ParameterList__Group_3__0__Impl rule__ParameterList__Group_3__1 + { + pushFollow(FOLLOW_63); + rule__ParameterList__Group_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterList__Group_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group_3__0" + + + // $ANTLR start "rule__ParameterList__Group_3__0__Impl" + // InternalRos2Parser.g:11656:1: rule__ParameterList__Group_3__0__Impl : ( Comma ) ; + public final void rule__ParameterList__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11660:1: ( ( Comma ) ) + // InternalRos2Parser.g:11661:1: ( Comma ) + { + // InternalRos2Parser.g:11661:1: ( Comma ) + // InternalRos2Parser.g:11662:2: Comma + { + before(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group_3__0__Impl" + + + // $ANTLR start "rule__ParameterList__Group_3__1" + // InternalRos2Parser.g:11671:1: rule__ParameterList__Group_3__1 : rule__ParameterList__Group_3__1__Impl ; + public final void rule__ParameterList__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11675:1: ( rule__ParameterList__Group_3__1__Impl ) + // InternalRos2Parser.g:11676:2: rule__ParameterList__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterList__Group_3__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group_3__1" + + + // $ANTLR start "rule__ParameterList__Group_3__1__Impl" + // InternalRos2Parser.g:11682:1: rule__ParameterList__Group_3__1__Impl : ( ( rule__ParameterList__ValueAssignment_3_1 ) ) ; + public final void rule__ParameterList__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11686:1: ( ( ( rule__ParameterList__ValueAssignment_3_1 ) ) ) + // InternalRos2Parser.g:11687:1: ( ( rule__ParameterList__ValueAssignment_3_1 ) ) + { + // InternalRos2Parser.g:11687:1: ( ( rule__ParameterList__ValueAssignment_3_1 ) ) + // InternalRos2Parser.g:11688:2: ( rule__ParameterList__ValueAssignment_3_1 ) + { + before(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); + // InternalRos2Parser.g:11689:2: ( rule__ParameterList__ValueAssignment_3_1 ) + // InternalRos2Parser.g:11689:3: rule__ParameterList__ValueAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__ParameterList__ValueAssignment_3_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterListAccess().getValueAssignment_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__Group_3__1__Impl" + + + // $ANTLR start "rule__ParameterAny__Group__0" + // InternalRos2Parser.g:11698:1: rule__ParameterAny__Group__0 : rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 ; + public final void rule__ParameterAny__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11702:1: ( rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 ) + // InternalRos2Parser.g:11703:2: rule__ParameterAny__Group__0__Impl rule__ParameterAny__Group__1 + { + pushFollow(FOLLOW_64); + rule__ParameterAny__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterAny__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__0" + + + // $ANTLR start "rule__ParameterAny__Group__0__Impl" + // InternalRos2Parser.g:11710:1: rule__ParameterAny__Group__0__Impl : ( () ) ; + public final void rule__ParameterAny__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11714:1: ( ( () ) ) + // InternalRos2Parser.g:11715:1: ( () ) + { + // InternalRos2Parser.g:11715:1: ( () ) + // InternalRos2Parser.g:11716:2: () + { + before(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); + // InternalRos2Parser.g:11717:2: () + // InternalRos2Parser.g:11717:3: + { + } + + after(grammarAccess.getParameterAnyAccess().getParameterAnyAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__0__Impl" + + + // $ANTLR start "rule__ParameterAny__Group__1" + // InternalRos2Parser.g:11725:1: rule__ParameterAny__Group__1 : rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 ; + public final void rule__ParameterAny__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11729:1: ( rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 ) + // InternalRos2Parser.g:11730:2: rule__ParameterAny__Group__1__Impl rule__ParameterAny__Group__2 + { + pushFollow(FOLLOW_65); + rule__ParameterAny__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterAny__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__1" + + + // $ANTLR start "rule__ParameterAny__Group__1__Impl" + // InternalRos2Parser.g:11737:1: rule__ParameterAny__Group__1__Impl : ( ParameterAny ) ; + public final void rule__ParameterAny__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11741:1: ( ( ParameterAny ) ) + // InternalRos2Parser.g:11742:1: ( ParameterAny ) + { + // InternalRos2Parser.g:11742:1: ( ParameterAny ) + // InternalRos2Parser.g:11743:2: ParameterAny + { + before(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); + match(input,ParameterAny,FOLLOW_2); + after(grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__1__Impl" + + + // $ANTLR start "rule__ParameterAny__Group__2" + // InternalRos2Parser.g:11752:1: rule__ParameterAny__Group__2 : rule__ParameterAny__Group__2__Impl ; + public final void rule__ParameterAny__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11756:1: ( rule__ParameterAny__Group__2__Impl ) + // InternalRos2Parser.g:11757:2: rule__ParameterAny__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterAny__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__2" + + + // $ANTLR start "rule__ParameterAny__Group__2__Impl" + // InternalRos2Parser.g:11763:1: rule__ParameterAny__Group__2__Impl : ( ( rule__ParameterAny__Group_2__0 )? ) ; + public final void rule__ParameterAny__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11767:1: ( ( ( rule__ParameterAny__Group_2__0 )? ) ) + // InternalRos2Parser.g:11768:1: ( ( rule__ParameterAny__Group_2__0 )? ) + { + // InternalRos2Parser.g:11768:1: ( ( rule__ParameterAny__Group_2__0 )? ) + // InternalRos2Parser.g:11769:2: ( rule__ParameterAny__Group_2__0 )? + { + before(grammarAccess.getParameterAnyAccess().getGroup_2()); + // InternalRos2Parser.g:11770:2: ( rule__ParameterAny__Group_2__0 )? + int alt72=2; + int LA72_0 = input.LA(1); + + if ( (LA72_0==Value) ) { + alt72=1; + } + switch (alt72) { + case 1 : + // InternalRos2Parser.g:11770:3: rule__ParameterAny__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ParameterAny__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterAnyAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group__2__Impl" + + + // $ANTLR start "rule__ParameterAny__Group_2__0" + // InternalRos2Parser.g:11779:1: rule__ParameterAny__Group_2__0 : rule__ParameterAny__Group_2__0__Impl rule__ParameterAny__Group_2__1 ; + public final void rule__ParameterAny__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11783:1: ( rule__ParameterAny__Group_2__0__Impl rule__ParameterAny__Group_2__1 ) + // InternalRos2Parser.g:11784:2: rule__ParameterAny__Group_2__0__Impl rule__ParameterAny__Group_2__1 + { + pushFollow(FOLLOW_7); + rule__ParameterAny__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterAny__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group_2__0" + + + // $ANTLR start "rule__ParameterAny__Group_2__0__Impl" + // InternalRos2Parser.g:11791:1: rule__ParameterAny__Group_2__0__Impl : ( Value ) ; + public final void rule__ParameterAny__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11795:1: ( ( Value ) ) + // InternalRos2Parser.g:11796:1: ( Value ) + { + // InternalRos2Parser.g:11796:1: ( Value ) + // InternalRos2Parser.g:11797:2: Value + { + before(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); + match(input,Value,FOLLOW_2); + after(grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group_2__0__Impl" + + + // $ANTLR start "rule__ParameterAny__Group_2__1" + // InternalRos2Parser.g:11806:1: rule__ParameterAny__Group_2__1 : rule__ParameterAny__Group_2__1__Impl ; + public final void rule__ParameterAny__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11810:1: ( rule__ParameterAny__Group_2__1__Impl ) + // InternalRos2Parser.g:11811:2: rule__ParameterAny__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterAny__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group_2__1" + + + // $ANTLR start "rule__ParameterAny__Group_2__1__Impl" + // InternalRos2Parser.g:11817:1: rule__ParameterAny__Group_2__1__Impl : ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) ; + public final void rule__ParameterAny__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11821:1: ( ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) ) + // InternalRos2Parser.g:11822:1: ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) + { + // InternalRos2Parser.g:11822:1: ( ( rule__ParameterAny__ValueAssignment_2_1 ) ) + // InternalRos2Parser.g:11823:2: ( rule__ParameterAny__ValueAssignment_2_1 ) + { + before(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); + // InternalRos2Parser.g:11824:2: ( rule__ParameterAny__ValueAssignment_2_1 ) + // InternalRos2Parser.g:11824:3: rule__ParameterAny__ValueAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ParameterAny__ValueAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAnyAccess().getValueAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__Group_2__1__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group__0" + // InternalRos2Parser.g:11833:1: rule__ParameterStruct__Group__0 : rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 ; + public final void rule__ParameterStruct__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11837:1: ( rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 ) + // InternalRos2Parser.g:11838:2: rule__ParameterStruct__Group__0__Impl rule__ParameterStruct__Group__1 + { + pushFollow(FOLLOW_63); + rule__ParameterStruct__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group__0" + + + // $ANTLR start "rule__ParameterStruct__Group__0__Impl" + // InternalRos2Parser.g:11845:1: rule__ParameterStruct__Group__0__Impl : ( () ) ; + public final void rule__ParameterStruct__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11849:1: ( ( () ) ) + // InternalRos2Parser.g:11850:1: ( () ) + { + // InternalRos2Parser.g:11850:1: ( () ) + // InternalRos2Parser.g:11851:2: () + { + before(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); + // InternalRos2Parser.g:11852:2: () + // InternalRos2Parser.g:11852:3: + { + } + + after(grammarAccess.getParameterStructAccess().getParameterStructAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group__0__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group__1" + // InternalRos2Parser.g:11860:1: rule__ParameterStruct__Group__1 : rule__ParameterStruct__Group__1__Impl ; + public final void rule__ParameterStruct__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11864:1: ( rule__ParameterStruct__Group__1__Impl ) + // InternalRos2Parser.g:11865:2: rule__ParameterStruct__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group__1" + + + // $ANTLR start "rule__ParameterStruct__Group__1__Impl" + // InternalRos2Parser.g:11871:1: rule__ParameterStruct__Group__1__Impl : ( ( rule__ParameterStruct__Group_1__0 )? ) ; + public final void rule__ParameterStruct__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11875:1: ( ( ( rule__ParameterStruct__Group_1__0 )? ) ) + // InternalRos2Parser.g:11876:1: ( ( rule__ParameterStruct__Group_1__0 )? ) + { + // InternalRos2Parser.g:11876:1: ( ( rule__ParameterStruct__Group_1__0 )? ) + // InternalRos2Parser.g:11877:2: ( rule__ParameterStruct__Group_1__0 )? + { + before(grammarAccess.getParameterStructAccess().getGroup_1()); + // InternalRos2Parser.g:11878:2: ( rule__ParameterStruct__Group_1__0 )? + int alt73=2; + int LA73_0 = input.LA(1); + + if ( (LA73_0==LeftSquareBracket) ) { + alt73=1; + } + switch (alt73) { + case 1 : + // InternalRos2Parser.g:11878:3: rule__ParameterStruct__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterStructAccess().getGroup_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group__1__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1__0" + // InternalRos2Parser.g:11887:1: rule__ParameterStruct__Group_1__0 : rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 ; + public final void rule__ParameterStruct__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11891:1: ( rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 ) + // InternalRos2Parser.g:11892:2: rule__ParameterStruct__Group_1__0__Impl rule__ParameterStruct__Group_1__1 + { + pushFollow(FOLLOW_66); + rule__ParameterStruct__Group_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__0" + + + // $ANTLR start "rule__ParameterStruct__Group_1__0__Impl" + // InternalRos2Parser.g:11899:1: rule__ParameterStruct__Group_1__0__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterStruct__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11903:1: ( ( LeftSquareBracket ) ) + // InternalRos2Parser.g:11904:1: ( LeftSquareBracket ) + { + // InternalRos2Parser.g:11904:1: ( LeftSquareBracket ) + // InternalRos2Parser.g:11905:2: LeftSquareBracket + { + before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__0__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1__1" + // InternalRos2Parser.g:11914:1: rule__ParameterStruct__Group_1__1 : rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 ; + public final void rule__ParameterStruct__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11918:1: ( rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 ) + // InternalRos2Parser.g:11919:2: rule__ParameterStruct__Group_1__1__Impl rule__ParameterStruct__Group_1__2 + { + pushFollow(FOLLOW_12); + rule__ParameterStruct__Group_1__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__1" + + + // $ANTLR start "rule__ParameterStruct__Group_1__1__Impl" + // InternalRos2Parser.g:11926:1: rule__ParameterStruct__Group_1__1__Impl : ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) ; + public final void rule__ParameterStruct__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11930:1: ( ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) ) + // InternalRos2Parser.g:11931:1: ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) + { + // InternalRos2Parser.g:11931:1: ( ( rule__ParameterStruct__ValueAssignment_1_1 ) ) + // InternalRos2Parser.g:11932:2: ( rule__ParameterStruct__ValueAssignment_1_1 ) + { + before(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); + // InternalRos2Parser.g:11933:2: ( rule__ParameterStruct__ValueAssignment_1_1 ) + // InternalRos2Parser.g:11933:3: rule__ParameterStruct__ValueAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__ValueAssignment_1_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructAccess().getValueAssignment_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__1__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1__2" + // InternalRos2Parser.g:11941:1: rule__ParameterStruct__Group_1__2 : rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 ; + public final void rule__ParameterStruct__Group_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11945:1: ( rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 ) + // InternalRos2Parser.g:11946:2: rule__ParameterStruct__Group_1__2__Impl rule__ParameterStruct__Group_1__3 + { + pushFollow(FOLLOW_12); + rule__ParameterStruct__Group_1__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__2" + + + // $ANTLR start "rule__ParameterStruct__Group_1__2__Impl" + // InternalRos2Parser.g:11953:1: rule__ParameterStruct__Group_1__2__Impl : ( ( rule__ParameterStruct__Group_1_2__0 )* ) ; + public final void rule__ParameterStruct__Group_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11957:1: ( ( ( rule__ParameterStruct__Group_1_2__0 )* ) ) + // InternalRos2Parser.g:11958:1: ( ( rule__ParameterStruct__Group_1_2__0 )* ) + { + // InternalRos2Parser.g:11958:1: ( ( rule__ParameterStruct__Group_1_2__0 )* ) + // InternalRos2Parser.g:11959:2: ( rule__ParameterStruct__Group_1_2__0 )* + { + before(grammarAccess.getParameterStructAccess().getGroup_1_2()); + // InternalRos2Parser.g:11960:2: ( rule__ParameterStruct__Group_1_2__0 )* + loop74: + do { + int alt74=2; + int LA74_0 = input.LA(1); + + if ( (LA74_0==Comma) ) { + alt74=1; + } + + + switch (alt74) { + case 1 : + // InternalRos2Parser.g:11960:3: rule__ParameterStruct__Group_1_2__0 + { + pushFollow(FOLLOW_13); + rule__ParameterStruct__Group_1_2__0(); + + state._fsp--; + + + } + break; + + default : + break loop74; + } + } while (true); + + after(grammarAccess.getParameterStructAccess().getGroup_1_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__2__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1__3" + // InternalRos2Parser.g:11968:1: rule__ParameterStruct__Group_1__3 : rule__ParameterStruct__Group_1__3__Impl ; + public final void rule__ParameterStruct__Group_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11972:1: ( rule__ParameterStruct__Group_1__3__Impl ) + // InternalRos2Parser.g:11973:2: rule__ParameterStruct__Group_1__3__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__3" + + + // $ANTLR start "rule__ParameterStruct__Group_1__3__Impl" + // InternalRos2Parser.g:11979:1: rule__ParameterStruct__Group_1__3__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterStruct__Group_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11983:1: ( ( RightSquareBracket ) ) + // InternalRos2Parser.g:11984:1: ( RightSquareBracket ) + { + // InternalRos2Parser.g:11984:1: ( RightSquareBracket ) + // InternalRos2Parser.g:11985:2: RightSquareBracket + { + before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1__3__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__0" + // InternalRos2Parser.g:11995:1: rule__ParameterStruct__Group_1_2__0 : rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 ; + public final void rule__ParameterStruct__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:11999:1: ( rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 ) + // InternalRos2Parser.g:12000:2: rule__ParameterStruct__Group_1_2__0__Impl rule__ParameterStruct__Group_1_2__1 + { + pushFollow(FOLLOW_10); + rule__ParameterStruct__Group_1_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__0" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__0__Impl" + // InternalRos2Parser.g:12007:1: rule__ParameterStruct__Group_1_2__0__Impl : ( Comma ) ; + public final void rule__ParameterStruct__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12011:1: ( ( Comma ) ) + // InternalRos2Parser.g:12012:1: ( Comma ) + { + // InternalRos2Parser.g:12012:1: ( Comma ) + // InternalRos2Parser.g:12013:2: Comma + { + before(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__0__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__1" + // InternalRos2Parser.g:12022:1: rule__ParameterStruct__Group_1_2__1 : rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 ; + public final void rule__ParameterStruct__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12026:1: ( rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 ) + // InternalRos2Parser.g:12027:2: rule__ParameterStruct__Group_1_2__1__Impl rule__ParameterStruct__Group_1_2__2 + { + pushFollow(FOLLOW_66); + rule__ParameterStruct__Group_1_2__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1_2__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__1" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__1__Impl" + // InternalRos2Parser.g:12034:1: rule__ParameterStruct__Group_1_2__1__Impl : ( LeftSquareBracket ) ; + public final void rule__ParameterStruct__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12038:1: ( ( LeftSquareBracket ) ) + // InternalRos2Parser.g:12039:1: ( LeftSquareBracket ) + { + // InternalRos2Parser.g:12039:1: ( LeftSquareBracket ) + // InternalRos2Parser.g:12040:2: LeftSquareBracket + { + before(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__1__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__2" + // InternalRos2Parser.g:12049:1: rule__ParameterStruct__Group_1_2__2 : rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 ; + public final void rule__ParameterStruct__Group_1_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12053:1: ( rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 ) + // InternalRos2Parser.g:12054:2: rule__ParameterStruct__Group_1_2__2__Impl rule__ParameterStruct__Group_1_2__3 + { + pushFollow(FOLLOW_67); + rule__ParameterStruct__Group_1_2__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1_2__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__2" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__2__Impl" + // InternalRos2Parser.g:12061:1: rule__ParameterStruct__Group_1_2__2__Impl : ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) ; + public final void rule__ParameterStruct__Group_1_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12065:1: ( ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) ) + // InternalRos2Parser.g:12066:1: ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) + { + // InternalRos2Parser.g:12066:1: ( ( rule__ParameterStruct__ValueAssignment_1_2_2 ) ) + // InternalRos2Parser.g:12067:2: ( rule__ParameterStruct__ValueAssignment_1_2_2 ) + { + before(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); + // InternalRos2Parser.g:12068:2: ( rule__ParameterStruct__ValueAssignment_1_2_2 ) + // InternalRos2Parser.g:12068:3: rule__ParameterStruct__ValueAssignment_1_2_2 + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__ValueAssignment_1_2_2(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructAccess().getValueAssignment_1_2_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__2__Impl" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__3" + // InternalRos2Parser.g:12076:1: rule__ParameterStruct__Group_1_2__3 : rule__ParameterStruct__Group_1_2__3__Impl ; + public final void rule__ParameterStruct__Group_1_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12080:1: ( rule__ParameterStruct__Group_1_2__3__Impl ) + // InternalRos2Parser.g:12081:2: rule__ParameterStruct__Group_1_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStruct__Group_1_2__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__3" + + + // $ANTLR start "rule__ParameterStruct__Group_1_2__3__Impl" + // InternalRos2Parser.g:12087:1: rule__ParameterStruct__Group_1_2__3__Impl : ( RightSquareBracket ) ; + public final void rule__ParameterStruct__Group_1_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12091:1: ( ( RightSquareBracket ) ) + // InternalRos2Parser.g:12092:1: ( RightSquareBracket ) + { + // InternalRos2Parser.g:12092:1: ( RightSquareBracket ) + // InternalRos2Parser.g:12093:2: RightSquareBracket + { + before(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__Group_1_2__3__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__0" + // InternalRos2Parser.g:12103:1: rule__ParameterStructMember__Group__0 : rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 ; + public final void rule__ParameterStructMember__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12107:1: ( rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 ) + // InternalRos2Parser.g:12108:2: rule__ParameterStructMember__Group__0__Impl rule__ParameterStructMember__Group__1 + { + pushFollow(FOLLOW_7); + rule__ParameterStructMember__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__0" + + + // $ANTLR start "rule__ParameterStructMember__Group__0__Impl" + // InternalRos2Parser.g:12115:1: rule__ParameterStructMember__Group__0__Impl : ( ParameterStructMember ) ; + public final void rule__ParameterStructMember__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12119:1: ( ( ParameterStructMember ) ) + // InternalRos2Parser.g:12120:1: ( ParameterStructMember ) + { + // InternalRos2Parser.g:12120:1: ( ParameterStructMember ) + // InternalRos2Parser.g:12121:2: ParameterStructMember + { + before(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); + match(input,ParameterStructMember,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__0__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__1" + // InternalRos2Parser.g:12130:1: rule__ParameterStructMember__Group__1 : rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 ; + public final void rule__ParameterStructMember__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12134:1: ( rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 ) + // InternalRos2Parser.g:12135:2: rule__ParameterStructMember__Group__1__Impl rule__ParameterStructMember__Group__2 + { + pushFollow(FOLLOW_4); + rule__ParameterStructMember__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__1" + + + // $ANTLR start "rule__ParameterStructMember__Group__1__Impl" + // InternalRos2Parser.g:12142:1: rule__ParameterStructMember__Group__1__Impl : ( ( rule__ParameterStructMember__NameAssignment_1 ) ) ; + public final void rule__ParameterStructMember__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12146:1: ( ( ( rule__ParameterStructMember__NameAssignment_1 ) ) ) + // InternalRos2Parser.g:12147:1: ( ( rule__ParameterStructMember__NameAssignment_1 ) ) + { + // InternalRos2Parser.g:12147:1: ( ( rule__ParameterStructMember__NameAssignment_1 ) ) + // InternalRos2Parser.g:12148:2: ( rule__ParameterStructMember__NameAssignment_1 ) + { + before(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); + // InternalRos2Parser.g:12149:2: ( rule__ParameterStructMember__NameAssignment_1 ) + // InternalRos2Parser.g:12149:3: rule__ParameterStructMember__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStructMember__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructMemberAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__1__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__2" + // InternalRos2Parser.g:12157:1: rule__ParameterStructMember__Group__2 : rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 ; + public final void rule__ParameterStructMember__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12161:1: ( rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 ) + // InternalRos2Parser.g:12162:2: rule__ParameterStructMember__Group__2__Impl rule__ParameterStructMember__Group__3 + { + pushFollow(FOLLOW_5); + rule__ParameterStructMember__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__2" + + + // $ANTLR start "rule__ParameterStructMember__Group__2__Impl" + // InternalRos2Parser.g:12169:1: rule__ParameterStructMember__Group__2__Impl : ( Colon ) ; + public final void rule__ParameterStructMember__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12173:1: ( ( Colon ) ) + // InternalRos2Parser.g:12174:1: ( Colon ) + { + // InternalRos2Parser.g:12174:1: ( Colon ) + // InternalRos2Parser.g:12175:2: Colon + { + before(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__2__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__3" + // InternalRos2Parser.g:12184:1: rule__ParameterStructMember__Group__3 : rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 ; + public final void rule__ParameterStructMember__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12188:1: ( rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 ) + // InternalRos2Parser.g:12189:2: rule__ParameterStructMember__Group__3__Impl rule__ParameterStructMember__Group__4 + { + pushFollow(FOLLOW_63); + rule__ParameterStructMember__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__3" + + + // $ANTLR start "rule__ParameterStructMember__Group__3__Impl" + // InternalRos2Parser.g:12196:1: rule__ParameterStructMember__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__ParameterStructMember__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12200:1: ( ( RULE_BEGIN ) ) + // InternalRos2Parser.g:12201:1: ( RULE_BEGIN ) + { + // InternalRos2Parser.g:12201:1: ( RULE_BEGIN ) + // InternalRos2Parser.g:12202:2: RULE_BEGIN + { + before(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__3__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__4" + // InternalRos2Parser.g:12211:1: rule__ParameterStructMember__Group__4 : rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 ; + public final void rule__ParameterStructMember__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12215:1: ( rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 ) + // InternalRos2Parser.g:12216:2: rule__ParameterStructMember__Group__4__Impl rule__ParameterStructMember__Group__5 + { + pushFollow(FOLLOW_23); + rule__ParameterStructMember__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__4" + + + // $ANTLR start "rule__ParameterStructMember__Group__4__Impl" + // InternalRos2Parser.g:12223:1: rule__ParameterStructMember__Group__4__Impl : ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) ; + public final void rule__ParameterStructMember__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12227:1: ( ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) ) + // InternalRos2Parser.g:12228:1: ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) + { + // InternalRos2Parser.g:12228:1: ( ( rule__ParameterStructMember__ValueAssignment_4 ) ) + // InternalRos2Parser.g:12229:2: ( rule__ParameterStructMember__ValueAssignment_4 ) + { + before(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); + // InternalRos2Parser.g:12230:2: ( rule__ParameterStructMember__ValueAssignment_4 ) + // InternalRos2Parser.g:12230:3: rule__ParameterStructMember__ValueAssignment_4 + { + pushFollow(FOLLOW_2); + rule__ParameterStructMember__ValueAssignment_4(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructMemberAccess().getValueAssignment_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__4__Impl" + + + // $ANTLR start "rule__ParameterStructMember__Group__5" + // InternalRos2Parser.g:12238:1: rule__ParameterStructMember__Group__5 : rule__ParameterStructMember__Group__5__Impl ; + public final void rule__ParameterStructMember__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12242:1: ( rule__ParameterStructMember__Group__5__Impl ) + // InternalRos2Parser.g:12243:2: rule__ParameterStructMember__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStructMember__Group__5__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__5" + + + // $ANTLR start "rule__ParameterStructMember__Group__5__Impl" + // InternalRos2Parser.g:12249:1: rule__ParameterStructMember__Group__5__Impl : ( RULE_END ) ; + public final void rule__ParameterStructMember__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12253:1: ( ( RULE_END ) ) + // InternalRos2Parser.g:12254:1: ( RULE_END ) + { + // InternalRos2Parser.g:12254:1: ( RULE_END ) + // InternalRos2Parser.g:12255:2: RULE_END + { + before(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__Group__5__Impl" + + + // $ANTLR start "rule__ParameterStructTypeMember__Group__0" + // InternalRos2Parser.g:12265:1: rule__ParameterStructTypeMember__Group__0 : rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 ; + public final void rule__ParameterStructTypeMember__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12269:1: ( rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 ) + // InternalRos2Parser.g:12270:2: rule__ParameterStructTypeMember__Group__0__Impl rule__ParameterStructTypeMember__Group__1 + { + pushFollow(FOLLOW_25); + rule__ParameterStructTypeMember__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__Group__0" + + + // $ANTLR start "rule__ParameterStructTypeMember__Group__0__Impl" + // InternalRos2Parser.g:12277:1: rule__ParameterStructTypeMember__Group__0__Impl : ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) ; + public final void rule__ParameterStructTypeMember__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12281:1: ( ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) ) + // InternalRos2Parser.g:12282:1: ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) + { + // InternalRos2Parser.g:12282:1: ( ( rule__ParameterStructTypeMember__NameAssignment_0 ) ) + // InternalRos2Parser.g:12283:2: ( rule__ParameterStructTypeMember__NameAssignment_0 ) + { + before(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); + // InternalRos2Parser.g:12284:2: ( rule__ParameterStructTypeMember__NameAssignment_0 ) + // InternalRos2Parser.g:12284:3: rule__ParameterStructTypeMember__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__NameAssignment_0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeMemberAccess().getNameAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__Group__0__Impl" + + + // $ANTLR start "rule__ParameterStructTypeMember__Group__1" + // InternalRos2Parser.g:12292:1: rule__ParameterStructTypeMember__Group__1 : rule__ParameterStructTypeMember__Group__1__Impl ; + public final void rule__ParameterStructTypeMember__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12296:1: ( rule__ParameterStructTypeMember__Group__1__Impl ) + // InternalRos2Parser.g:12297:2: rule__ParameterStructTypeMember__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__Group__1" + + + // $ANTLR start "rule__ParameterStructTypeMember__Group__1__Impl" + // InternalRos2Parser.g:12303:1: rule__ParameterStructTypeMember__Group__1__Impl : ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) ; + public final void rule__ParameterStructTypeMember__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12307:1: ( ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) ) + // InternalRos2Parser.g:12308:1: ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) + { + // InternalRos2Parser.g:12308:1: ( ( rule__ParameterStructTypeMember__TypeAssignment_1 ) ) + // InternalRos2Parser.g:12309:2: ( rule__ParameterStructTypeMember__TypeAssignment_1 ) + { + before(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); + // InternalRos2Parser.g:12310:2: ( rule__ParameterStructTypeMember__TypeAssignment_1 ) + // InternalRos2Parser.g:12310:3: rule__ParameterStructTypeMember__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ParameterStructTypeMember__TypeAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterStructTypeMemberAccess().getTypeAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__Group__1__Impl" + + + // $ANTLR start "rule__MessagePart__Group__0" + // InternalRos2Parser.g:12319:1: rule__MessagePart__Group__0 : rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 ; + public final void rule__MessagePart__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12323:1: ( rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 ) + // InternalRos2Parser.g:12324:2: rule__MessagePart__Group__0__Impl rule__MessagePart__Group__1 + { + pushFollow(FOLLOW_68); + rule__MessagePart__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__MessagePart__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__Group__0" + + + // $ANTLR start "rule__MessagePart__Group__0__Impl" + // InternalRos2Parser.g:12331:1: rule__MessagePart__Group__0__Impl : ( ( rule__MessagePart__TypeAssignment_0 ) ) ; + public final void rule__MessagePart__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12335:1: ( ( ( rule__MessagePart__TypeAssignment_0 ) ) ) + // InternalRos2Parser.g:12336:1: ( ( rule__MessagePart__TypeAssignment_0 ) ) + { + // InternalRos2Parser.g:12336:1: ( ( rule__MessagePart__TypeAssignment_0 ) ) + // InternalRos2Parser.g:12337:2: ( rule__MessagePart__TypeAssignment_0 ) + { + before(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); + // InternalRos2Parser.g:12338:2: ( rule__MessagePart__TypeAssignment_0 ) + // InternalRos2Parser.g:12338:3: rule__MessagePart__TypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__MessagePart__TypeAssignment_0(); + + state._fsp--; + + + } + + after(grammarAccess.getMessagePartAccess().getTypeAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__Group__0__Impl" + + + // $ANTLR start "rule__MessagePart__Group__1" + // InternalRos2Parser.g:12346:1: rule__MessagePart__Group__1 : rule__MessagePart__Group__1__Impl ; + public final void rule__MessagePart__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12350:1: ( rule__MessagePart__Group__1__Impl ) + // InternalRos2Parser.g:12351:2: rule__MessagePart__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__MessagePart__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__Group__1" + + + // $ANTLR start "rule__MessagePart__Group__1__Impl" + // InternalRos2Parser.g:12357:1: rule__MessagePart__Group__1__Impl : ( ( rule__MessagePart__DataAssignment_1 ) ) ; + public final void rule__MessagePart__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12361:1: ( ( ( rule__MessagePart__DataAssignment_1 ) ) ) + // InternalRos2Parser.g:12362:1: ( ( rule__MessagePart__DataAssignment_1 ) ) + { + // InternalRos2Parser.g:12362:1: ( ( rule__MessagePart__DataAssignment_1 ) ) + // InternalRos2Parser.g:12363:2: ( rule__MessagePart__DataAssignment_1 ) + { + before(grammarAccess.getMessagePartAccess().getDataAssignment_1()); + // InternalRos2Parser.g:12364:2: ( rule__MessagePart__DataAssignment_1 ) + // InternalRos2Parser.g:12364:3: rule__MessagePart__DataAssignment_1 + { + pushFollow(FOLLOW_2); + rule__MessagePart__DataAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getMessagePartAccess().getDataAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__Group__1__Impl" + + + // $ANTLR start "rule__Bool__Group__0" + // InternalRos2Parser.g:12373:1: rule__Bool__Group__0 : rule__Bool__Group__0__Impl rule__Bool__Group__1 ; + public final void rule__Bool__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12377:1: ( rule__Bool__Group__0__Impl rule__Bool__Group__1 ) + // InternalRos2Parser.g:12378:2: rule__Bool__Group__0__Impl rule__Bool__Group__1 + { + pushFollow(FOLLOW_69); + rule__Bool__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Bool__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Bool__Group__0" + + + // $ANTLR start "rule__Bool__Group__0__Impl" + // InternalRos2Parser.g:12385:1: rule__Bool__Group__0__Impl : ( () ) ; + public final void rule__Bool__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12389:1: ( ( () ) ) + // InternalRos2Parser.g:12390:1: ( () ) + { + // InternalRos2Parser.g:12390:1: ( () ) + // InternalRos2Parser.g:12391:2: () + { + before(grammarAccess.getBoolAccess().getBoolAction_0()); + // InternalRos2Parser.g:12392:2: () + // InternalRos2Parser.g:12392:3: + { + } + + after(grammarAccess.getBoolAccess().getBoolAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Bool__Group__0__Impl" + + + // $ANTLR start "rule__Bool__Group__1" + // InternalRos2Parser.g:12400:1: rule__Bool__Group__1 : rule__Bool__Group__1__Impl ; + public final void rule__Bool__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12404:1: ( rule__Bool__Group__1__Impl ) + // InternalRos2Parser.g:12405:2: rule__Bool__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Bool__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Bool__Group__1" + + + // $ANTLR start "rule__Bool__Group__1__Impl" + // InternalRos2Parser.g:12411:1: rule__Bool__Group__1__Impl : ( Bool ) ; + public final void rule__Bool__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12415:1: ( ( Bool ) ) + // InternalRos2Parser.g:12416:1: ( Bool ) + { + // InternalRos2Parser.g:12416:1: ( Bool ) + // InternalRos2Parser.g:12417:2: Bool + { + before(grammarAccess.getBoolAccess().getBoolKeyword_1()); + match(input,Bool,FOLLOW_2); + after(grammarAccess.getBoolAccess().getBoolKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Bool__Group__1__Impl" + + + // $ANTLR start "rule__Int8__Group__0" + // InternalRos2Parser.g:12427:1: rule__Int8__Group__0 : rule__Int8__Group__0__Impl rule__Int8__Group__1 ; + public final void rule__Int8__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12431:1: ( rule__Int8__Group__0__Impl rule__Int8__Group__1 ) + // InternalRos2Parser.g:12432:2: rule__Int8__Group__0__Impl rule__Int8__Group__1 + { + pushFollow(FOLLOW_70); + rule__Int8__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int8__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8__Group__0" + + + // $ANTLR start "rule__Int8__Group__0__Impl" + // InternalRos2Parser.g:12439:1: rule__Int8__Group__0__Impl : ( () ) ; + public final void rule__Int8__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12443:1: ( ( () ) ) + // InternalRos2Parser.g:12444:1: ( () ) + { + // InternalRos2Parser.g:12444:1: ( () ) + // InternalRos2Parser.g:12445:2: () + { + before(grammarAccess.getInt8Access().getInt8Action_0()); + // InternalRos2Parser.g:12446:2: () + // InternalRos2Parser.g:12446:3: + { + } + + after(grammarAccess.getInt8Access().getInt8Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8__Group__0__Impl" + + + // $ANTLR start "rule__Int8__Group__1" + // InternalRos2Parser.g:12454:1: rule__Int8__Group__1 : rule__Int8__Group__1__Impl ; + public final void rule__Int8__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12458:1: ( rule__Int8__Group__1__Impl ) + // InternalRos2Parser.g:12459:2: rule__Int8__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int8__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8__Group__1" + + + // $ANTLR start "rule__Int8__Group__1__Impl" + // InternalRos2Parser.g:12465:1: rule__Int8__Group__1__Impl : ( Int8 ) ; + public final void rule__Int8__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12469:1: ( ( Int8 ) ) + // InternalRos2Parser.g:12470:1: ( Int8 ) + { + // InternalRos2Parser.g:12470:1: ( Int8 ) + // InternalRos2Parser.g:12471:2: Int8 + { + before(grammarAccess.getInt8Access().getInt8Keyword_1()); + match(input,Int8,FOLLOW_2); + after(grammarAccess.getInt8Access().getInt8Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8__Group__1__Impl" + + + // $ANTLR start "rule__Uint8__Group__0" + // InternalRos2Parser.g:12481:1: rule__Uint8__Group__0 : rule__Uint8__Group__0__Impl rule__Uint8__Group__1 ; + public final void rule__Uint8__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12485:1: ( rule__Uint8__Group__0__Impl rule__Uint8__Group__1 ) + // InternalRos2Parser.g:12486:2: rule__Uint8__Group__0__Impl rule__Uint8__Group__1 + { + pushFollow(FOLLOW_71); + rule__Uint8__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint8__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8__Group__0" + + + // $ANTLR start "rule__Uint8__Group__0__Impl" + // InternalRos2Parser.g:12493:1: rule__Uint8__Group__0__Impl : ( () ) ; + public final void rule__Uint8__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12497:1: ( ( () ) ) + // InternalRos2Parser.g:12498:1: ( () ) + { + // InternalRos2Parser.g:12498:1: ( () ) + // InternalRos2Parser.g:12499:2: () + { + before(grammarAccess.getUint8Access().getUint8Action_0()); + // InternalRos2Parser.g:12500:2: () + // InternalRos2Parser.g:12500:3: + { + } + + after(grammarAccess.getUint8Access().getUint8Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8__Group__0__Impl" + + + // $ANTLR start "rule__Uint8__Group__1" + // InternalRos2Parser.g:12508:1: rule__Uint8__Group__1 : rule__Uint8__Group__1__Impl ; + public final void rule__Uint8__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12512:1: ( rule__Uint8__Group__1__Impl ) + // InternalRos2Parser.g:12513:2: rule__Uint8__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint8__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8__Group__1" + + + // $ANTLR start "rule__Uint8__Group__1__Impl" + // InternalRos2Parser.g:12519:1: rule__Uint8__Group__1__Impl : ( Uint8 ) ; + public final void rule__Uint8__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12523:1: ( ( Uint8 ) ) + // InternalRos2Parser.g:12524:1: ( Uint8 ) + { + // InternalRos2Parser.g:12524:1: ( Uint8 ) + // InternalRos2Parser.g:12525:2: Uint8 + { + before(grammarAccess.getUint8Access().getUint8Keyword_1()); + match(input,Uint8,FOLLOW_2); + after(grammarAccess.getUint8Access().getUint8Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8__Group__1__Impl" + + + // $ANTLR start "rule__Int16__Group__0" + // InternalRos2Parser.g:12535:1: rule__Int16__Group__0 : rule__Int16__Group__0__Impl rule__Int16__Group__1 ; + public final void rule__Int16__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12539:1: ( rule__Int16__Group__0__Impl rule__Int16__Group__1 ) + // InternalRos2Parser.g:12540:2: rule__Int16__Group__0__Impl rule__Int16__Group__1 + { + pushFollow(FOLLOW_72); + rule__Int16__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int16__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16__Group__0" + + + // $ANTLR start "rule__Int16__Group__0__Impl" + // InternalRos2Parser.g:12547:1: rule__Int16__Group__0__Impl : ( () ) ; + public final void rule__Int16__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12551:1: ( ( () ) ) + // InternalRos2Parser.g:12552:1: ( () ) + { + // InternalRos2Parser.g:12552:1: ( () ) + // InternalRos2Parser.g:12553:2: () + { + before(grammarAccess.getInt16Access().getInt16Action_0()); + // InternalRos2Parser.g:12554:2: () + // InternalRos2Parser.g:12554:3: + { + } + + after(grammarAccess.getInt16Access().getInt16Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16__Group__0__Impl" + + + // $ANTLR start "rule__Int16__Group__1" + // InternalRos2Parser.g:12562:1: rule__Int16__Group__1 : rule__Int16__Group__1__Impl ; + public final void rule__Int16__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12566:1: ( rule__Int16__Group__1__Impl ) + // InternalRos2Parser.g:12567:2: rule__Int16__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int16__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16__Group__1" + + + // $ANTLR start "rule__Int16__Group__1__Impl" + // InternalRos2Parser.g:12573:1: rule__Int16__Group__1__Impl : ( Int16 ) ; + public final void rule__Int16__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12577:1: ( ( Int16 ) ) + // InternalRos2Parser.g:12578:1: ( Int16 ) + { + // InternalRos2Parser.g:12578:1: ( Int16 ) + // InternalRos2Parser.g:12579:2: Int16 + { + before(grammarAccess.getInt16Access().getInt16Keyword_1()); + match(input,Int16,FOLLOW_2); + after(grammarAccess.getInt16Access().getInt16Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16__Group__1__Impl" + + + // $ANTLR start "rule__Uint16__Group__0" + // InternalRos2Parser.g:12589:1: rule__Uint16__Group__0 : rule__Uint16__Group__0__Impl rule__Uint16__Group__1 ; + public final void rule__Uint16__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12593:1: ( rule__Uint16__Group__0__Impl rule__Uint16__Group__1 ) + // InternalRos2Parser.g:12594:2: rule__Uint16__Group__0__Impl rule__Uint16__Group__1 + { + pushFollow(FOLLOW_73); + rule__Uint16__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint16__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16__Group__0" + + + // $ANTLR start "rule__Uint16__Group__0__Impl" + // InternalRos2Parser.g:12601:1: rule__Uint16__Group__0__Impl : ( () ) ; + public final void rule__Uint16__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12605:1: ( ( () ) ) + // InternalRos2Parser.g:12606:1: ( () ) + { + // InternalRos2Parser.g:12606:1: ( () ) + // InternalRos2Parser.g:12607:2: () + { + before(grammarAccess.getUint16Access().getUint16Action_0()); + // InternalRos2Parser.g:12608:2: () + // InternalRos2Parser.g:12608:3: + { + } + + after(grammarAccess.getUint16Access().getUint16Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16__Group__0__Impl" + + + // $ANTLR start "rule__Uint16__Group__1" + // InternalRos2Parser.g:12616:1: rule__Uint16__Group__1 : rule__Uint16__Group__1__Impl ; + public final void rule__Uint16__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12620:1: ( rule__Uint16__Group__1__Impl ) + // InternalRos2Parser.g:12621:2: rule__Uint16__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint16__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16__Group__1" + + + // $ANTLR start "rule__Uint16__Group__1__Impl" + // InternalRos2Parser.g:12627:1: rule__Uint16__Group__1__Impl : ( Uint16 ) ; + public final void rule__Uint16__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12631:1: ( ( Uint16 ) ) + // InternalRos2Parser.g:12632:1: ( Uint16 ) + { + // InternalRos2Parser.g:12632:1: ( Uint16 ) + // InternalRos2Parser.g:12633:2: Uint16 + { + before(grammarAccess.getUint16Access().getUint16Keyword_1()); + match(input,Uint16,FOLLOW_2); + after(grammarAccess.getUint16Access().getUint16Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16__Group__1__Impl" + + + // $ANTLR start "rule__Int32__Group__0" + // InternalRos2Parser.g:12643:1: rule__Int32__Group__0 : rule__Int32__Group__0__Impl rule__Int32__Group__1 ; + public final void rule__Int32__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12647:1: ( rule__Int32__Group__0__Impl rule__Int32__Group__1 ) + // InternalRos2Parser.g:12648:2: rule__Int32__Group__0__Impl rule__Int32__Group__1 + { + pushFollow(FOLLOW_74); + rule__Int32__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int32__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32__Group__0" + + + // $ANTLR start "rule__Int32__Group__0__Impl" + // InternalRos2Parser.g:12655:1: rule__Int32__Group__0__Impl : ( () ) ; + public final void rule__Int32__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12659:1: ( ( () ) ) + // InternalRos2Parser.g:12660:1: ( () ) + { + // InternalRos2Parser.g:12660:1: ( () ) + // InternalRos2Parser.g:12661:2: () + { + before(grammarAccess.getInt32Access().getInt32Action_0()); + // InternalRos2Parser.g:12662:2: () + // InternalRos2Parser.g:12662:3: + { + } + + after(grammarAccess.getInt32Access().getInt32Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32__Group__0__Impl" + + + // $ANTLR start "rule__Int32__Group__1" + // InternalRos2Parser.g:12670:1: rule__Int32__Group__1 : rule__Int32__Group__1__Impl ; + public final void rule__Int32__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12674:1: ( rule__Int32__Group__1__Impl ) + // InternalRos2Parser.g:12675:2: rule__Int32__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int32__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32__Group__1" + + + // $ANTLR start "rule__Int32__Group__1__Impl" + // InternalRos2Parser.g:12681:1: rule__Int32__Group__1__Impl : ( Int32 ) ; + public final void rule__Int32__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12685:1: ( ( Int32 ) ) + // InternalRos2Parser.g:12686:1: ( Int32 ) + { + // InternalRos2Parser.g:12686:1: ( Int32 ) + // InternalRos2Parser.g:12687:2: Int32 + { + before(grammarAccess.getInt32Access().getInt32Keyword_1()); + match(input,Int32,FOLLOW_2); + after(grammarAccess.getInt32Access().getInt32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32__Group__1__Impl" + + + // $ANTLR start "rule__Uint32__Group__0" + // InternalRos2Parser.g:12697:1: rule__Uint32__Group__0 : rule__Uint32__Group__0__Impl rule__Uint32__Group__1 ; + public final void rule__Uint32__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12701:1: ( rule__Uint32__Group__0__Impl rule__Uint32__Group__1 ) + // InternalRos2Parser.g:12702:2: rule__Uint32__Group__0__Impl rule__Uint32__Group__1 + { + pushFollow(FOLLOW_75); + rule__Uint32__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint32__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32__Group__0" + + + // $ANTLR start "rule__Uint32__Group__0__Impl" + // InternalRos2Parser.g:12709:1: rule__Uint32__Group__0__Impl : ( () ) ; + public final void rule__Uint32__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12713:1: ( ( () ) ) + // InternalRos2Parser.g:12714:1: ( () ) + { + // InternalRos2Parser.g:12714:1: ( () ) + // InternalRos2Parser.g:12715:2: () + { + before(grammarAccess.getUint32Access().getUint32Action_0()); + // InternalRos2Parser.g:12716:2: () + // InternalRos2Parser.g:12716:3: + { + } + + after(grammarAccess.getUint32Access().getUint32Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32__Group__0__Impl" + + + // $ANTLR start "rule__Uint32__Group__1" + // InternalRos2Parser.g:12724:1: rule__Uint32__Group__1 : rule__Uint32__Group__1__Impl ; + public final void rule__Uint32__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12728:1: ( rule__Uint32__Group__1__Impl ) + // InternalRos2Parser.g:12729:2: rule__Uint32__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint32__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32__Group__1" + + + // $ANTLR start "rule__Uint32__Group__1__Impl" + // InternalRos2Parser.g:12735:1: rule__Uint32__Group__1__Impl : ( Uint32 ) ; + public final void rule__Uint32__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12739:1: ( ( Uint32 ) ) + // InternalRos2Parser.g:12740:1: ( Uint32 ) + { + // InternalRos2Parser.g:12740:1: ( Uint32 ) + // InternalRos2Parser.g:12741:2: Uint32 + { + before(grammarAccess.getUint32Access().getUint32Keyword_1()); + match(input,Uint32,FOLLOW_2); + after(grammarAccess.getUint32Access().getUint32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32__Group__1__Impl" + + + // $ANTLR start "rule__Int64__Group__0" + // InternalRos2Parser.g:12751:1: rule__Int64__Group__0 : rule__Int64__Group__0__Impl rule__Int64__Group__1 ; + public final void rule__Int64__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12755:1: ( rule__Int64__Group__0__Impl rule__Int64__Group__1 ) + // InternalRos2Parser.g:12756:2: rule__Int64__Group__0__Impl rule__Int64__Group__1 + { + pushFollow(FOLLOW_76); + rule__Int64__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int64__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64__Group__0" + + + // $ANTLR start "rule__Int64__Group__0__Impl" + // InternalRos2Parser.g:12763:1: rule__Int64__Group__0__Impl : ( () ) ; + public final void rule__Int64__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12767:1: ( ( () ) ) + // InternalRos2Parser.g:12768:1: ( () ) + { + // InternalRos2Parser.g:12768:1: ( () ) + // InternalRos2Parser.g:12769:2: () + { + before(grammarAccess.getInt64Access().getInt64Action_0()); + // InternalRos2Parser.g:12770:2: () + // InternalRos2Parser.g:12770:3: + { + } + + after(grammarAccess.getInt64Access().getInt64Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64__Group__0__Impl" + + + // $ANTLR start "rule__Int64__Group__1" + // InternalRos2Parser.g:12778:1: rule__Int64__Group__1 : rule__Int64__Group__1__Impl ; + public final void rule__Int64__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12782:1: ( rule__Int64__Group__1__Impl ) + // InternalRos2Parser.g:12783:2: rule__Int64__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int64__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64__Group__1" + + + // $ANTLR start "rule__Int64__Group__1__Impl" + // InternalRos2Parser.g:12789:1: rule__Int64__Group__1__Impl : ( Int64 ) ; + public final void rule__Int64__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12793:1: ( ( Int64 ) ) + // InternalRos2Parser.g:12794:1: ( Int64 ) + { + // InternalRos2Parser.g:12794:1: ( Int64 ) + // InternalRos2Parser.g:12795:2: Int64 + { + before(grammarAccess.getInt64Access().getInt64Keyword_1()); + match(input,Int64,FOLLOW_2); + after(grammarAccess.getInt64Access().getInt64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64__Group__1__Impl" + + + // $ANTLR start "rule__Uint64__Group__0" + // InternalRos2Parser.g:12805:1: rule__Uint64__Group__0 : rule__Uint64__Group__0__Impl rule__Uint64__Group__1 ; + public final void rule__Uint64__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12809:1: ( rule__Uint64__Group__0__Impl rule__Uint64__Group__1 ) + // InternalRos2Parser.g:12810:2: rule__Uint64__Group__0__Impl rule__Uint64__Group__1 + { + pushFollow(FOLLOW_77); + rule__Uint64__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint64__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64__Group__0" + + + // $ANTLR start "rule__Uint64__Group__0__Impl" + // InternalRos2Parser.g:12817:1: rule__Uint64__Group__0__Impl : ( () ) ; + public final void rule__Uint64__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12821:1: ( ( () ) ) + // InternalRos2Parser.g:12822:1: ( () ) + { + // InternalRos2Parser.g:12822:1: ( () ) + // InternalRos2Parser.g:12823:2: () + { + before(grammarAccess.getUint64Access().getUint64Action_0()); + // InternalRos2Parser.g:12824:2: () + // InternalRos2Parser.g:12824:3: + { + } + + after(grammarAccess.getUint64Access().getUint64Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64__Group__0__Impl" + + + // $ANTLR start "rule__Uint64__Group__1" + // InternalRos2Parser.g:12832:1: rule__Uint64__Group__1 : rule__Uint64__Group__1__Impl ; + public final void rule__Uint64__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12836:1: ( rule__Uint64__Group__1__Impl ) + // InternalRos2Parser.g:12837:2: rule__Uint64__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint64__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64__Group__1" + + + // $ANTLR start "rule__Uint64__Group__1__Impl" + // InternalRos2Parser.g:12843:1: rule__Uint64__Group__1__Impl : ( Uint64 ) ; + public final void rule__Uint64__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12847:1: ( ( Uint64 ) ) + // InternalRos2Parser.g:12848:1: ( Uint64 ) + { + // InternalRos2Parser.g:12848:1: ( Uint64 ) + // InternalRos2Parser.g:12849:2: Uint64 + { + before(grammarAccess.getUint64Access().getUint64Keyword_1()); + match(input,Uint64,FOLLOW_2); + after(grammarAccess.getUint64Access().getUint64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64__Group__1__Impl" + + + // $ANTLR start "rule__Float32__Group__0" + // InternalRos2Parser.g:12859:1: rule__Float32__Group__0 : rule__Float32__Group__0__Impl rule__Float32__Group__1 ; + public final void rule__Float32__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12863:1: ( rule__Float32__Group__0__Impl rule__Float32__Group__1 ) + // InternalRos2Parser.g:12864:2: rule__Float32__Group__0__Impl rule__Float32__Group__1 + { + pushFollow(FOLLOW_78); + rule__Float32__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Float32__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32__Group__0" + + + // $ANTLR start "rule__Float32__Group__0__Impl" + // InternalRos2Parser.g:12871:1: rule__Float32__Group__0__Impl : ( () ) ; + public final void rule__Float32__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12875:1: ( ( () ) ) + // InternalRos2Parser.g:12876:1: ( () ) + { + // InternalRos2Parser.g:12876:1: ( () ) + // InternalRos2Parser.g:12877:2: () + { + before(grammarAccess.getFloat32Access().getFloat32Action_0()); + // InternalRos2Parser.g:12878:2: () + // InternalRos2Parser.g:12878:3: + { + } + + after(grammarAccess.getFloat32Access().getFloat32Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32__Group__0__Impl" + + + // $ANTLR start "rule__Float32__Group__1" + // InternalRos2Parser.g:12886:1: rule__Float32__Group__1 : rule__Float32__Group__1__Impl ; + public final void rule__Float32__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12890:1: ( rule__Float32__Group__1__Impl ) + // InternalRos2Parser.g:12891:2: rule__Float32__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Float32__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32__Group__1" + + + // $ANTLR start "rule__Float32__Group__1__Impl" + // InternalRos2Parser.g:12897:1: rule__Float32__Group__1__Impl : ( Float32 ) ; + public final void rule__Float32__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12901:1: ( ( Float32 ) ) + // InternalRos2Parser.g:12902:1: ( Float32 ) + { + // InternalRos2Parser.g:12902:1: ( Float32 ) + // InternalRos2Parser.g:12903:2: Float32 + { + before(grammarAccess.getFloat32Access().getFloat32Keyword_1()); + match(input,Float32,FOLLOW_2); + after(grammarAccess.getFloat32Access().getFloat32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32__Group__1__Impl" + + + // $ANTLR start "rule__Float64__Group__0" + // InternalRos2Parser.g:12913:1: rule__Float64__Group__0 : rule__Float64__Group__0__Impl rule__Float64__Group__1 ; + public final void rule__Float64__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12917:1: ( rule__Float64__Group__0__Impl rule__Float64__Group__1 ) + // InternalRos2Parser.g:12918:2: rule__Float64__Group__0__Impl rule__Float64__Group__1 + { + pushFollow(FOLLOW_79); + rule__Float64__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Float64__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64__Group__0" + + + // $ANTLR start "rule__Float64__Group__0__Impl" + // InternalRos2Parser.g:12925:1: rule__Float64__Group__0__Impl : ( () ) ; + public final void rule__Float64__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12929:1: ( ( () ) ) + // InternalRos2Parser.g:12930:1: ( () ) + { + // InternalRos2Parser.g:12930:1: ( () ) + // InternalRos2Parser.g:12931:2: () + { + before(grammarAccess.getFloat64Access().getFloat64Action_0()); + // InternalRos2Parser.g:12932:2: () + // InternalRos2Parser.g:12932:3: + { + } + + after(grammarAccess.getFloat64Access().getFloat64Action_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64__Group__0__Impl" + + + // $ANTLR start "rule__Float64__Group__1" + // InternalRos2Parser.g:12940:1: rule__Float64__Group__1 : rule__Float64__Group__1__Impl ; + public final void rule__Float64__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12944:1: ( rule__Float64__Group__1__Impl ) + // InternalRos2Parser.g:12945:2: rule__Float64__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Float64__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64__Group__1" + + + // $ANTLR start "rule__Float64__Group__1__Impl" + // InternalRos2Parser.g:12951:1: rule__Float64__Group__1__Impl : ( Float64 ) ; + public final void rule__Float64__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12955:1: ( ( Float64 ) ) + // InternalRos2Parser.g:12956:1: ( Float64 ) + { + // InternalRos2Parser.g:12956:1: ( Float64 ) + // InternalRos2Parser.g:12957:2: Float64 + { + before(grammarAccess.getFloat64Access().getFloat64Keyword_1()); + match(input,Float64,FOLLOW_2); + after(grammarAccess.getFloat64Access().getFloat64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64__Group__1__Impl" + + + // $ANTLR start "rule__String0__Group__0" + // InternalRos2Parser.g:12967:1: rule__String0__Group__0 : rule__String0__Group__0__Impl rule__String0__Group__1 ; + public final void rule__String0__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12971:1: ( rule__String0__Group__0__Impl rule__String0__Group__1 ) + // InternalRos2Parser.g:12972:2: rule__String0__Group__0__Impl rule__String0__Group__1 + { + pushFollow(FOLLOW_80); + rule__String0__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__String0__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0__Group__0" + + + // $ANTLR start "rule__String0__Group__0__Impl" + // InternalRos2Parser.g:12979:1: rule__String0__Group__0__Impl : ( () ) ; + public final void rule__String0__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12983:1: ( ( () ) ) + // InternalRos2Parser.g:12984:1: ( () ) + { + // InternalRos2Parser.g:12984:1: ( () ) + // InternalRos2Parser.g:12985:2: () + { + before(grammarAccess.getString0Access().getStringAction_0()); + // InternalRos2Parser.g:12986:2: () + // InternalRos2Parser.g:12986:3: + { + } + + after(grammarAccess.getString0Access().getStringAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0__Group__0__Impl" + + + // $ANTLR start "rule__String0__Group__1" + // InternalRos2Parser.g:12994:1: rule__String0__Group__1 : rule__String0__Group__1__Impl ; + public final void rule__String0__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:12998:1: ( rule__String0__Group__1__Impl ) + // InternalRos2Parser.g:12999:2: rule__String0__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__String0__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0__Group__1" + + + // $ANTLR start "rule__String0__Group__1__Impl" + // InternalRos2Parser.g:13005:1: rule__String0__Group__1__Impl : ( String_1 ) ; + public final void rule__String0__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13009:1: ( ( String_1 ) ) + // InternalRos2Parser.g:13010:1: ( String_1 ) + { + // InternalRos2Parser.g:13010:1: ( String_1 ) + // InternalRos2Parser.g:13011:2: String_1 + { + before(grammarAccess.getString0Access().getStringKeyword_1()); + match(input,String_1,FOLLOW_2); + after(grammarAccess.getString0Access().getStringKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0__Group__1__Impl" + + + // $ANTLR start "rule__Byte__Group__0" + // InternalRos2Parser.g:13021:1: rule__Byte__Group__0 : rule__Byte__Group__0__Impl rule__Byte__Group__1 ; + public final void rule__Byte__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13025:1: ( rule__Byte__Group__0__Impl rule__Byte__Group__1 ) + // InternalRos2Parser.g:13026:2: rule__Byte__Group__0__Impl rule__Byte__Group__1 + { + pushFollow(FOLLOW_81); + rule__Byte__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Byte__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Byte__Group__0" + + + // $ANTLR start "rule__Byte__Group__0__Impl" + // InternalRos2Parser.g:13033:1: rule__Byte__Group__0__Impl : ( () ) ; + public final void rule__Byte__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13037:1: ( ( () ) ) + // InternalRos2Parser.g:13038:1: ( () ) + { + // InternalRos2Parser.g:13038:1: ( () ) + // InternalRos2Parser.g:13039:2: () + { + before(grammarAccess.getByteAccess().getByteAction_0()); + // InternalRos2Parser.g:13040:2: () + // InternalRos2Parser.g:13040:3: + { + } + + after(grammarAccess.getByteAccess().getByteAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Byte__Group__0__Impl" + + + // $ANTLR start "rule__Byte__Group__1" + // InternalRos2Parser.g:13048:1: rule__Byte__Group__1 : rule__Byte__Group__1__Impl ; + public final void rule__Byte__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13052:1: ( rule__Byte__Group__1__Impl ) + // InternalRos2Parser.g:13053:2: rule__Byte__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Byte__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Byte__Group__1" + + + // $ANTLR start "rule__Byte__Group__1__Impl" + // InternalRos2Parser.g:13059:1: rule__Byte__Group__1__Impl : ( Byte ) ; + public final void rule__Byte__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13063:1: ( ( Byte ) ) + // InternalRos2Parser.g:13064:1: ( Byte ) + { + // InternalRos2Parser.g:13064:1: ( Byte ) + // InternalRos2Parser.g:13065:2: Byte + { + before(grammarAccess.getByteAccess().getByteKeyword_1()); + match(input,Byte,FOLLOW_2); + after(grammarAccess.getByteAccess().getByteKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Byte__Group__1__Impl" + + + // $ANTLR start "rule__Time__Group__0" + // InternalRos2Parser.g:13075:1: rule__Time__Group__0 : rule__Time__Group__0__Impl rule__Time__Group__1 ; + public final void rule__Time__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13079:1: ( rule__Time__Group__0__Impl rule__Time__Group__1 ) + // InternalRos2Parser.g:13080:2: rule__Time__Group__0__Impl rule__Time__Group__1 + { + pushFollow(FOLLOW_82); + rule__Time__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Time__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Time__Group__0" + + + // $ANTLR start "rule__Time__Group__0__Impl" + // InternalRos2Parser.g:13087:1: rule__Time__Group__0__Impl : ( () ) ; + public final void rule__Time__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13091:1: ( ( () ) ) + // InternalRos2Parser.g:13092:1: ( () ) + { + // InternalRos2Parser.g:13092:1: ( () ) + // InternalRos2Parser.g:13093:2: () + { + before(grammarAccess.getTimeAccess().getTimeAction_0()); + // InternalRos2Parser.g:13094:2: () + // InternalRos2Parser.g:13094:3: + { + } + + after(grammarAccess.getTimeAccess().getTimeAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Time__Group__0__Impl" + + + // $ANTLR start "rule__Time__Group__1" + // InternalRos2Parser.g:13102:1: rule__Time__Group__1 : rule__Time__Group__1__Impl ; + public final void rule__Time__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13106:1: ( rule__Time__Group__1__Impl ) + // InternalRos2Parser.g:13107:2: rule__Time__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Time__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Time__Group__1" + + + // $ANTLR start "rule__Time__Group__1__Impl" + // InternalRos2Parser.g:13113:1: rule__Time__Group__1__Impl : ( Time ) ; + public final void rule__Time__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13117:1: ( ( Time ) ) + // InternalRos2Parser.g:13118:1: ( Time ) + { + // InternalRos2Parser.g:13118:1: ( Time ) + // InternalRos2Parser.g:13119:2: Time + { + before(grammarAccess.getTimeAccess().getTimeKeyword_1()); + match(input,Time,FOLLOW_2); + after(grammarAccess.getTimeAccess().getTimeKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Time__Group__1__Impl" + + + // $ANTLR start "rule__Duration__Group__0" + // InternalRos2Parser.g:13129:1: rule__Duration__Group__0 : rule__Duration__Group__0__Impl rule__Duration__Group__1 ; + public final void rule__Duration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13133:1: ( rule__Duration__Group__0__Impl rule__Duration__Group__1 ) + // InternalRos2Parser.g:13134:2: rule__Duration__Group__0__Impl rule__Duration__Group__1 + { + pushFollow(FOLLOW_83); + rule__Duration__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Duration__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Duration__Group__0" + + + // $ANTLR start "rule__Duration__Group__0__Impl" + // InternalRos2Parser.g:13141:1: rule__Duration__Group__0__Impl : ( () ) ; + public final void rule__Duration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13145:1: ( ( () ) ) + // InternalRos2Parser.g:13146:1: ( () ) + { + // InternalRos2Parser.g:13146:1: ( () ) + // InternalRos2Parser.g:13147:2: () + { + before(grammarAccess.getDurationAccess().getDurationAction_0()); + // InternalRos2Parser.g:13148:2: () + // InternalRos2Parser.g:13148:3: + { + } + + after(grammarAccess.getDurationAccess().getDurationAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Duration__Group__0__Impl" + + + // $ANTLR start "rule__Duration__Group__1" + // InternalRos2Parser.g:13156:1: rule__Duration__Group__1 : rule__Duration__Group__1__Impl ; + public final void rule__Duration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13160:1: ( rule__Duration__Group__1__Impl ) + // InternalRos2Parser.g:13161:2: rule__Duration__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Duration__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Duration__Group__1" + + + // $ANTLR start "rule__Duration__Group__1__Impl" + // InternalRos2Parser.g:13167:1: rule__Duration__Group__1__Impl : ( Duration ) ; + public final void rule__Duration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13171:1: ( ( Duration ) ) + // InternalRos2Parser.g:13172:1: ( Duration ) + { + // InternalRos2Parser.g:13172:1: ( Duration ) + // InternalRos2Parser.g:13173:2: Duration + { + before(grammarAccess.getDurationAccess().getDurationKeyword_1()); + match(input,Duration,FOLLOW_2); + after(grammarAccess.getDurationAccess().getDurationKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Duration__Group__1__Impl" + + + // $ANTLR start "rule__BoolArray__Group__0" + // InternalRos2Parser.g:13183:1: rule__BoolArray__Group__0 : rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 ; + public final void rule__BoolArray__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13187:1: ( rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 ) + // InternalRos2Parser.g:13188:2: rule__BoolArray__Group__0__Impl rule__BoolArray__Group__1 + { + pushFollow(FOLLOW_84); + rule__BoolArray__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__BoolArray__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__BoolArray__Group__0" + + + // $ANTLR start "rule__BoolArray__Group__0__Impl" + // InternalRos2Parser.g:13195:1: rule__BoolArray__Group__0__Impl : ( () ) ; + public final void rule__BoolArray__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13199:1: ( ( () ) ) + // InternalRos2Parser.g:13200:1: ( () ) + { + // InternalRos2Parser.g:13200:1: ( () ) + // InternalRos2Parser.g:13201:2: () + { + before(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); + // InternalRos2Parser.g:13202:2: () + // InternalRos2Parser.g:13202:3: + { + } + + after(grammarAccess.getBoolArrayAccess().getBoolArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__BoolArray__Group__0__Impl" + + + // $ANTLR start "rule__BoolArray__Group__1" + // InternalRos2Parser.g:13210:1: rule__BoolArray__Group__1 : rule__BoolArray__Group__1__Impl ; + public final void rule__BoolArray__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13214:1: ( rule__BoolArray__Group__1__Impl ) + // InternalRos2Parser.g:13215:2: rule__BoolArray__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__BoolArray__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__BoolArray__Group__1" + + + // $ANTLR start "rule__BoolArray__Group__1__Impl" + // InternalRos2Parser.g:13221:1: rule__BoolArray__Group__1__Impl : ( Bool_1 ) ; + public final void rule__BoolArray__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13225:1: ( ( Bool_1 ) ) + // InternalRos2Parser.g:13226:1: ( Bool_1 ) + { + // InternalRos2Parser.g:13226:1: ( Bool_1 ) + // InternalRos2Parser.g:13227:2: Bool_1 + { + before(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); + match(input,Bool_1,FOLLOW_2); + after(grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__BoolArray__Group__1__Impl" + + + // $ANTLR start "rule__Int8Array__Group__0" + // InternalRos2Parser.g:13237:1: rule__Int8Array__Group__0 : rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 ; + public final void rule__Int8Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13241:1: ( rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 ) + // InternalRos2Parser.g:13242:2: rule__Int8Array__Group__0__Impl rule__Int8Array__Group__1 + { + pushFollow(FOLLOW_85); + rule__Int8Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int8Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8Array__Group__0" + + + // $ANTLR start "rule__Int8Array__Group__0__Impl" + // InternalRos2Parser.g:13249:1: rule__Int8Array__Group__0__Impl : ( () ) ; + public final void rule__Int8Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13253:1: ( ( () ) ) + // InternalRos2Parser.g:13254:1: ( () ) + { + // InternalRos2Parser.g:13254:1: ( () ) + // InternalRos2Parser.g:13255:2: () + { + before(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); + // InternalRos2Parser.g:13256:2: () + // InternalRos2Parser.g:13256:3: + { + } + + after(grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8Array__Group__0__Impl" + + + // $ANTLR start "rule__Int8Array__Group__1" + // InternalRos2Parser.g:13264:1: rule__Int8Array__Group__1 : rule__Int8Array__Group__1__Impl ; + public final void rule__Int8Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13268:1: ( rule__Int8Array__Group__1__Impl ) + // InternalRos2Parser.g:13269:2: rule__Int8Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int8Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8Array__Group__1" + + + // $ANTLR start "rule__Int8Array__Group__1__Impl" + // InternalRos2Parser.g:13275:1: rule__Int8Array__Group__1__Impl : ( Int8_1 ) ; + public final void rule__Int8Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13279:1: ( ( Int8_1 ) ) + // InternalRos2Parser.g:13280:1: ( Int8_1 ) + { + // InternalRos2Parser.g:13280:1: ( Int8_1 ) + // InternalRos2Parser.g:13281:2: Int8_1 + { + before(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); + match(input,Int8_1,FOLLOW_2); + after(grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int8Array__Group__1__Impl" + + + // $ANTLR start "rule__Uint8Array__Group__0" + // InternalRos2Parser.g:13291:1: rule__Uint8Array__Group__0 : rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 ; + public final void rule__Uint8Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13295:1: ( rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 ) + // InternalRos2Parser.g:13296:2: rule__Uint8Array__Group__0__Impl rule__Uint8Array__Group__1 + { + pushFollow(FOLLOW_86); + rule__Uint8Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint8Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8Array__Group__0" + + + // $ANTLR start "rule__Uint8Array__Group__0__Impl" + // InternalRos2Parser.g:13303:1: rule__Uint8Array__Group__0__Impl : ( () ) ; + public final void rule__Uint8Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13307:1: ( ( () ) ) + // InternalRos2Parser.g:13308:1: ( () ) + { + // InternalRos2Parser.g:13308:1: ( () ) + // InternalRos2Parser.g:13309:2: () + { + before(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); + // InternalRos2Parser.g:13310:2: () + // InternalRos2Parser.g:13310:3: + { + } + + after(grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8Array__Group__0__Impl" + + + // $ANTLR start "rule__Uint8Array__Group__1" + // InternalRos2Parser.g:13318:1: rule__Uint8Array__Group__1 : rule__Uint8Array__Group__1__Impl ; + public final void rule__Uint8Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13322:1: ( rule__Uint8Array__Group__1__Impl ) + // InternalRos2Parser.g:13323:2: rule__Uint8Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint8Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8Array__Group__1" + + + // $ANTLR start "rule__Uint8Array__Group__1__Impl" + // InternalRos2Parser.g:13329:1: rule__Uint8Array__Group__1__Impl : ( Uint8_1 ) ; + public final void rule__Uint8Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13333:1: ( ( Uint8_1 ) ) + // InternalRos2Parser.g:13334:1: ( Uint8_1 ) + { + // InternalRos2Parser.g:13334:1: ( Uint8_1 ) + // InternalRos2Parser.g:13335:2: Uint8_1 + { + before(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); + match(input,Uint8_1,FOLLOW_2); + after(grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint8Array__Group__1__Impl" + + + // $ANTLR start "rule__Int16Array__Group__0" + // InternalRos2Parser.g:13345:1: rule__Int16Array__Group__0 : rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 ; + public final void rule__Int16Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13349:1: ( rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 ) + // InternalRos2Parser.g:13350:2: rule__Int16Array__Group__0__Impl rule__Int16Array__Group__1 + { + pushFollow(FOLLOW_87); + rule__Int16Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int16Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16Array__Group__0" + + + // $ANTLR start "rule__Int16Array__Group__0__Impl" + // InternalRos2Parser.g:13357:1: rule__Int16Array__Group__0__Impl : ( () ) ; + public final void rule__Int16Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13361:1: ( ( () ) ) + // InternalRos2Parser.g:13362:1: ( () ) + { + // InternalRos2Parser.g:13362:1: ( () ) + // InternalRos2Parser.g:13363:2: () + { + before(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); + // InternalRos2Parser.g:13364:2: () + // InternalRos2Parser.g:13364:3: + { + } + + after(grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16Array__Group__0__Impl" + + + // $ANTLR start "rule__Int16Array__Group__1" + // InternalRos2Parser.g:13372:1: rule__Int16Array__Group__1 : rule__Int16Array__Group__1__Impl ; + public final void rule__Int16Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13376:1: ( rule__Int16Array__Group__1__Impl ) + // InternalRos2Parser.g:13377:2: rule__Int16Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int16Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16Array__Group__1" + + + // $ANTLR start "rule__Int16Array__Group__1__Impl" + // InternalRos2Parser.g:13383:1: rule__Int16Array__Group__1__Impl : ( Int16_1 ) ; + public final void rule__Int16Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13387:1: ( ( Int16_1 ) ) + // InternalRos2Parser.g:13388:1: ( Int16_1 ) + { + // InternalRos2Parser.g:13388:1: ( Int16_1 ) + // InternalRos2Parser.g:13389:2: Int16_1 + { + before(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); + match(input,Int16_1,FOLLOW_2); + after(grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int16Array__Group__1__Impl" + + + // $ANTLR start "rule__Uint16Array__Group__0" + // InternalRos2Parser.g:13399:1: rule__Uint16Array__Group__0 : rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 ; + public final void rule__Uint16Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13403:1: ( rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 ) + // InternalRos2Parser.g:13404:2: rule__Uint16Array__Group__0__Impl rule__Uint16Array__Group__1 + { + pushFollow(FOLLOW_88); + rule__Uint16Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint16Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16Array__Group__0" + + + // $ANTLR start "rule__Uint16Array__Group__0__Impl" + // InternalRos2Parser.g:13411:1: rule__Uint16Array__Group__0__Impl : ( () ) ; + public final void rule__Uint16Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13415:1: ( ( () ) ) + // InternalRos2Parser.g:13416:1: ( () ) + { + // InternalRos2Parser.g:13416:1: ( () ) + // InternalRos2Parser.g:13417:2: () + { + before(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); + // InternalRos2Parser.g:13418:2: () + // InternalRos2Parser.g:13418:3: + { + } + + after(grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16Array__Group__0__Impl" + + + // $ANTLR start "rule__Uint16Array__Group__1" + // InternalRos2Parser.g:13426:1: rule__Uint16Array__Group__1 : rule__Uint16Array__Group__1__Impl ; + public final void rule__Uint16Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13430:1: ( rule__Uint16Array__Group__1__Impl ) + // InternalRos2Parser.g:13431:2: rule__Uint16Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint16Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16Array__Group__1" + + + // $ANTLR start "rule__Uint16Array__Group__1__Impl" + // InternalRos2Parser.g:13437:1: rule__Uint16Array__Group__1__Impl : ( Uint16_1 ) ; + public final void rule__Uint16Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13441:1: ( ( Uint16_1 ) ) + // InternalRos2Parser.g:13442:1: ( Uint16_1 ) + { + // InternalRos2Parser.g:13442:1: ( Uint16_1 ) + // InternalRos2Parser.g:13443:2: Uint16_1 + { + before(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); + match(input,Uint16_1,FOLLOW_2); + after(grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint16Array__Group__1__Impl" + + + // $ANTLR start "rule__Int32Array__Group__0" + // InternalRos2Parser.g:13453:1: rule__Int32Array__Group__0 : rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 ; + public final void rule__Int32Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13457:1: ( rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 ) + // InternalRos2Parser.g:13458:2: rule__Int32Array__Group__0__Impl rule__Int32Array__Group__1 + { + pushFollow(FOLLOW_89); + rule__Int32Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int32Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32Array__Group__0" + + + // $ANTLR start "rule__Int32Array__Group__0__Impl" + // InternalRos2Parser.g:13465:1: rule__Int32Array__Group__0__Impl : ( () ) ; + public final void rule__Int32Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13469:1: ( ( () ) ) + // InternalRos2Parser.g:13470:1: ( () ) + { + // InternalRos2Parser.g:13470:1: ( () ) + // InternalRos2Parser.g:13471:2: () + { + before(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); + // InternalRos2Parser.g:13472:2: () + // InternalRos2Parser.g:13472:3: + { + } + + after(grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32Array__Group__0__Impl" + + + // $ANTLR start "rule__Int32Array__Group__1" + // InternalRos2Parser.g:13480:1: rule__Int32Array__Group__1 : rule__Int32Array__Group__1__Impl ; + public final void rule__Int32Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13484:1: ( rule__Int32Array__Group__1__Impl ) + // InternalRos2Parser.g:13485:2: rule__Int32Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int32Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32Array__Group__1" + + + // $ANTLR start "rule__Int32Array__Group__1__Impl" + // InternalRos2Parser.g:13491:1: rule__Int32Array__Group__1__Impl : ( Int32_1 ) ; + public final void rule__Int32Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13495:1: ( ( Int32_1 ) ) + // InternalRos2Parser.g:13496:1: ( Int32_1 ) + { + // InternalRos2Parser.g:13496:1: ( Int32_1 ) + // InternalRos2Parser.g:13497:2: Int32_1 + { + before(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); + match(input,Int32_1,FOLLOW_2); + after(grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int32Array__Group__1__Impl" + + + // $ANTLR start "rule__Uint32Array__Group__0" + // InternalRos2Parser.g:13507:1: rule__Uint32Array__Group__0 : rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 ; + public final void rule__Uint32Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13511:1: ( rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 ) + // InternalRos2Parser.g:13512:2: rule__Uint32Array__Group__0__Impl rule__Uint32Array__Group__1 + { + pushFollow(FOLLOW_90); + rule__Uint32Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint32Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32Array__Group__0" + + + // $ANTLR start "rule__Uint32Array__Group__0__Impl" + // InternalRos2Parser.g:13519:1: rule__Uint32Array__Group__0__Impl : ( () ) ; + public final void rule__Uint32Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13523:1: ( ( () ) ) + // InternalRos2Parser.g:13524:1: ( () ) + { + // InternalRos2Parser.g:13524:1: ( () ) + // InternalRos2Parser.g:13525:2: () + { + before(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); + // InternalRos2Parser.g:13526:2: () + // InternalRos2Parser.g:13526:3: + { + } + + after(grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32Array__Group__0__Impl" + + + // $ANTLR start "rule__Uint32Array__Group__1" + // InternalRos2Parser.g:13534:1: rule__Uint32Array__Group__1 : rule__Uint32Array__Group__1__Impl ; + public final void rule__Uint32Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13538:1: ( rule__Uint32Array__Group__1__Impl ) + // InternalRos2Parser.g:13539:2: rule__Uint32Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint32Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32Array__Group__1" + + + // $ANTLR start "rule__Uint32Array__Group__1__Impl" + // InternalRos2Parser.g:13545:1: rule__Uint32Array__Group__1__Impl : ( Uint32_1 ) ; + public final void rule__Uint32Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13549:1: ( ( Uint32_1 ) ) + // InternalRos2Parser.g:13550:1: ( Uint32_1 ) + { + // InternalRos2Parser.g:13550:1: ( Uint32_1 ) + // InternalRos2Parser.g:13551:2: Uint32_1 + { + before(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); + match(input,Uint32_1,FOLLOW_2); + after(grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint32Array__Group__1__Impl" + + + // $ANTLR start "rule__Int64Array__Group__0" + // InternalRos2Parser.g:13561:1: rule__Int64Array__Group__0 : rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 ; + public final void rule__Int64Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13565:1: ( rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 ) + // InternalRos2Parser.g:13566:2: rule__Int64Array__Group__0__Impl rule__Int64Array__Group__1 + { + pushFollow(FOLLOW_91); + rule__Int64Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Int64Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64Array__Group__0" + + + // $ANTLR start "rule__Int64Array__Group__0__Impl" + // InternalRos2Parser.g:13573:1: rule__Int64Array__Group__0__Impl : ( () ) ; + public final void rule__Int64Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13577:1: ( ( () ) ) + // InternalRos2Parser.g:13578:1: ( () ) + { + // InternalRos2Parser.g:13578:1: ( () ) + // InternalRos2Parser.g:13579:2: () + { + before(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); + // InternalRos2Parser.g:13580:2: () + // InternalRos2Parser.g:13580:3: + { + } + + after(grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64Array__Group__0__Impl" + + + // $ANTLR start "rule__Int64Array__Group__1" + // InternalRos2Parser.g:13588:1: rule__Int64Array__Group__1 : rule__Int64Array__Group__1__Impl ; + public final void rule__Int64Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13592:1: ( rule__Int64Array__Group__1__Impl ) + // InternalRos2Parser.g:13593:2: rule__Int64Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Int64Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64Array__Group__1" + + + // $ANTLR start "rule__Int64Array__Group__1__Impl" + // InternalRos2Parser.g:13599:1: rule__Int64Array__Group__1__Impl : ( Int64_1 ) ; + public final void rule__Int64Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13603:1: ( ( Int64_1 ) ) + // InternalRos2Parser.g:13604:1: ( Int64_1 ) + { + // InternalRos2Parser.g:13604:1: ( Int64_1 ) + // InternalRos2Parser.g:13605:2: Int64_1 + { + before(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); + match(input,Int64_1,FOLLOW_2); + after(grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Int64Array__Group__1__Impl" + + + // $ANTLR start "rule__Uint64Array__Group__0" + // InternalRos2Parser.g:13615:1: rule__Uint64Array__Group__0 : rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 ; + public final void rule__Uint64Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13619:1: ( rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 ) + // InternalRos2Parser.g:13620:2: rule__Uint64Array__Group__0__Impl rule__Uint64Array__Group__1 + { + pushFollow(FOLLOW_92); + rule__Uint64Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Uint64Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64Array__Group__0" + + + // $ANTLR start "rule__Uint64Array__Group__0__Impl" + // InternalRos2Parser.g:13627:1: rule__Uint64Array__Group__0__Impl : ( () ) ; + public final void rule__Uint64Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13631:1: ( ( () ) ) + // InternalRos2Parser.g:13632:1: ( () ) + { + // InternalRos2Parser.g:13632:1: ( () ) + // InternalRos2Parser.g:13633:2: () + { + before(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); + // InternalRos2Parser.g:13634:2: () + // InternalRos2Parser.g:13634:3: + { + } + + after(grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64Array__Group__0__Impl" + + + // $ANTLR start "rule__Uint64Array__Group__1" + // InternalRos2Parser.g:13642:1: rule__Uint64Array__Group__1 : rule__Uint64Array__Group__1__Impl ; + public final void rule__Uint64Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13646:1: ( rule__Uint64Array__Group__1__Impl ) + // InternalRos2Parser.g:13647:2: rule__Uint64Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Uint64Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64Array__Group__1" + + + // $ANTLR start "rule__Uint64Array__Group__1__Impl" + // InternalRos2Parser.g:13653:1: rule__Uint64Array__Group__1__Impl : ( Uint64_1 ) ; + public final void rule__Uint64Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13657:1: ( ( Uint64_1 ) ) + // InternalRos2Parser.g:13658:1: ( Uint64_1 ) + { + // InternalRos2Parser.g:13658:1: ( Uint64_1 ) + // InternalRos2Parser.g:13659:2: Uint64_1 + { + before(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); + match(input,Uint64_1,FOLLOW_2); + after(grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Uint64Array__Group__1__Impl" + + + // $ANTLR start "rule__Float32Array__Group__0" + // InternalRos2Parser.g:13669:1: rule__Float32Array__Group__0 : rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 ; + public final void rule__Float32Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13673:1: ( rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 ) + // InternalRos2Parser.g:13674:2: rule__Float32Array__Group__0__Impl rule__Float32Array__Group__1 + { + pushFollow(FOLLOW_93); + rule__Float32Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Float32Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32Array__Group__0" + + + // $ANTLR start "rule__Float32Array__Group__0__Impl" + // InternalRos2Parser.g:13681:1: rule__Float32Array__Group__0__Impl : ( () ) ; + public final void rule__Float32Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13685:1: ( ( () ) ) + // InternalRos2Parser.g:13686:1: ( () ) + { + // InternalRos2Parser.g:13686:1: ( () ) + // InternalRos2Parser.g:13687:2: () + { + before(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); + // InternalRos2Parser.g:13688:2: () + // InternalRos2Parser.g:13688:3: + { + } + + after(grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32Array__Group__0__Impl" + + + // $ANTLR start "rule__Float32Array__Group__1" + // InternalRos2Parser.g:13696:1: rule__Float32Array__Group__1 : rule__Float32Array__Group__1__Impl ; + public final void rule__Float32Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13700:1: ( rule__Float32Array__Group__1__Impl ) + // InternalRos2Parser.g:13701:2: rule__Float32Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Float32Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32Array__Group__1" + + + // $ANTLR start "rule__Float32Array__Group__1__Impl" + // InternalRos2Parser.g:13707:1: rule__Float32Array__Group__1__Impl : ( Float32_1 ) ; + public final void rule__Float32Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13711:1: ( ( Float32_1 ) ) + // InternalRos2Parser.g:13712:1: ( Float32_1 ) + { + // InternalRos2Parser.g:13712:1: ( Float32_1 ) + // InternalRos2Parser.g:13713:2: Float32_1 + { + before(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); + match(input,Float32_1,FOLLOW_2); + after(grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float32Array__Group__1__Impl" + + + // $ANTLR start "rule__Float64Array__Group__0" + // InternalRos2Parser.g:13723:1: rule__Float64Array__Group__0 : rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 ; + public final void rule__Float64Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13727:1: ( rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 ) + // InternalRos2Parser.g:13728:2: rule__Float64Array__Group__0__Impl rule__Float64Array__Group__1 + { + pushFollow(FOLLOW_94); + rule__Float64Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Float64Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64Array__Group__0" + + + // $ANTLR start "rule__Float64Array__Group__0__Impl" + // InternalRos2Parser.g:13735:1: rule__Float64Array__Group__0__Impl : ( () ) ; + public final void rule__Float64Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13739:1: ( ( () ) ) + // InternalRos2Parser.g:13740:1: ( () ) + { + // InternalRos2Parser.g:13740:1: ( () ) + // InternalRos2Parser.g:13741:2: () + { + before(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); + // InternalRos2Parser.g:13742:2: () + // InternalRos2Parser.g:13742:3: + { + } + + after(grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64Array__Group__0__Impl" + + + // $ANTLR start "rule__Float64Array__Group__1" + // InternalRos2Parser.g:13750:1: rule__Float64Array__Group__1 : rule__Float64Array__Group__1__Impl ; + public final void rule__Float64Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13754:1: ( rule__Float64Array__Group__1__Impl ) + // InternalRos2Parser.g:13755:2: rule__Float64Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Float64Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64Array__Group__1" + + + // $ANTLR start "rule__Float64Array__Group__1__Impl" + // InternalRos2Parser.g:13761:1: rule__Float64Array__Group__1__Impl : ( Float64_1 ) ; + public final void rule__Float64Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13765:1: ( ( Float64_1 ) ) + // InternalRos2Parser.g:13766:1: ( Float64_1 ) + { + // InternalRos2Parser.g:13766:1: ( Float64_1 ) + // InternalRos2Parser.g:13767:2: Float64_1 + { + before(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); + match(input,Float64_1,FOLLOW_2); + after(grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Float64Array__Group__1__Impl" + + + // $ANTLR start "rule__String0Array__Group__0" + // InternalRos2Parser.g:13777:1: rule__String0Array__Group__0 : rule__String0Array__Group__0__Impl rule__String0Array__Group__1 ; + public final void rule__String0Array__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13781:1: ( rule__String0Array__Group__0__Impl rule__String0Array__Group__1 ) + // InternalRos2Parser.g:13782:2: rule__String0Array__Group__0__Impl rule__String0Array__Group__1 + { + pushFollow(FOLLOW_95); + rule__String0Array__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__String0Array__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0Array__Group__0" + + + // $ANTLR start "rule__String0Array__Group__0__Impl" + // InternalRos2Parser.g:13789:1: rule__String0Array__Group__0__Impl : ( () ) ; + public final void rule__String0Array__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13793:1: ( ( () ) ) + // InternalRos2Parser.g:13794:1: ( () ) + { + // InternalRos2Parser.g:13794:1: ( () ) + // InternalRos2Parser.g:13795:2: () + { + before(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); + // InternalRos2Parser.g:13796:2: () + // InternalRos2Parser.g:13796:3: + { + } + + after(grammarAccess.getString0ArrayAccess().getStringArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0Array__Group__0__Impl" + + + // $ANTLR start "rule__String0Array__Group__1" + // InternalRos2Parser.g:13804:1: rule__String0Array__Group__1 : rule__String0Array__Group__1__Impl ; + public final void rule__String0Array__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13808:1: ( rule__String0Array__Group__1__Impl ) + // InternalRos2Parser.g:13809:2: rule__String0Array__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__String0Array__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0Array__Group__1" + + + // $ANTLR start "rule__String0Array__Group__1__Impl" + // InternalRos2Parser.g:13815:1: rule__String0Array__Group__1__Impl : ( String_2 ) ; + public final void rule__String0Array__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13819:1: ( ( String_2 ) ) + // InternalRos2Parser.g:13820:1: ( String_2 ) + { + // InternalRos2Parser.g:13820:1: ( String_2 ) + // InternalRos2Parser.g:13821:2: String_2 + { + before(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); + match(input,String_2,FOLLOW_2); + after(grammarAccess.getString0ArrayAccess().getStringKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__String0Array__Group__1__Impl" + + + // $ANTLR start "rule__ByteArray__Group__0" + // InternalRos2Parser.g:13831:1: rule__ByteArray__Group__0 : rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 ; + public final void rule__ByteArray__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13835:1: ( rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 ) + // InternalRos2Parser.g:13836:2: rule__ByteArray__Group__0__Impl rule__ByteArray__Group__1 + { + pushFollow(FOLLOW_96); + rule__ByteArray__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ByteArray__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ByteArray__Group__0" + + + // $ANTLR start "rule__ByteArray__Group__0__Impl" + // InternalRos2Parser.g:13843:1: rule__ByteArray__Group__0__Impl : ( () ) ; + public final void rule__ByteArray__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13847:1: ( ( () ) ) + // InternalRos2Parser.g:13848:1: ( () ) + { + // InternalRos2Parser.g:13848:1: ( () ) + // InternalRos2Parser.g:13849:2: () + { + before(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); + // InternalRos2Parser.g:13850:2: () + // InternalRos2Parser.g:13850:3: + { + } + + after(grammarAccess.getByteArrayAccess().getByteArrayAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ByteArray__Group__0__Impl" + + + // $ANTLR start "rule__ByteArray__Group__1" + // InternalRos2Parser.g:13858:1: rule__ByteArray__Group__1 : rule__ByteArray__Group__1__Impl ; + public final void rule__ByteArray__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13862:1: ( rule__ByteArray__Group__1__Impl ) + // InternalRos2Parser.g:13863:2: rule__ByteArray__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ByteArray__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ByteArray__Group__1" + + + // $ANTLR start "rule__ByteArray__Group__1__Impl" + // InternalRos2Parser.g:13869:1: rule__ByteArray__Group__1__Impl : ( Byte_1 ) ; + public final void rule__ByteArray__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13873:1: ( ( Byte_1 ) ) + // InternalRos2Parser.g:13874:1: ( Byte_1 ) + { + // InternalRos2Parser.g:13874:1: ( Byte_1 ) + // InternalRos2Parser.g:13875:2: Byte_1 + { + before(grammarAccess.getByteArrayAccess().getByteKeyword_1()); + match(input,Byte_1,FOLLOW_2); + after(grammarAccess.getByteArrayAccess().getByteKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ByteArray__Group__1__Impl" + + + // $ANTLR start "rule__Header__Group__0" + // InternalRos2Parser.g:13885:1: rule__Header__Group__0 : rule__Header__Group__0__Impl rule__Header__Group__1 ; + public final void rule__Header__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13889:1: ( rule__Header__Group__0__Impl rule__Header__Group__1 ) + // InternalRos2Parser.g:13890:2: rule__Header__Group__0__Impl rule__Header__Group__1 + { + pushFollow(FOLLOW_97); + rule__Header__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Header__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Header__Group__0" + + + // $ANTLR start "rule__Header__Group__0__Impl" + // InternalRos2Parser.g:13897:1: rule__Header__Group__0__Impl : ( () ) ; + public final void rule__Header__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13901:1: ( ( () ) ) + // InternalRos2Parser.g:13902:1: ( () ) + { + // InternalRos2Parser.g:13902:1: ( () ) + // InternalRos2Parser.g:13903:2: () + { + before(grammarAccess.getHeaderAccess().getHeaderAction_0()); + // InternalRos2Parser.g:13904:2: () + // InternalRos2Parser.g:13904:3: + { + } + + after(grammarAccess.getHeaderAccess().getHeaderAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Header__Group__0__Impl" + + + // $ANTLR start "rule__Header__Group__1" + // InternalRos2Parser.g:13912:1: rule__Header__Group__1 : rule__Header__Group__1__Impl ; + public final void rule__Header__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13916:1: ( rule__Header__Group__1__Impl ) + // InternalRos2Parser.g:13917:2: rule__Header__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Header__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Header__Group__1" + + + // $ANTLR start "rule__Header__Group__1__Impl" + // InternalRos2Parser.g:13923:1: rule__Header__Group__1__Impl : ( Header ) ; + public final void rule__Header__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13927:1: ( ( Header ) ) + // InternalRos2Parser.g:13928:1: ( Header ) + { + // InternalRos2Parser.g:13928:1: ( Header ) + // InternalRos2Parser.g:13929:2: Header + { + before(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); + match(input,Header,FOLLOW_2); + after(grammarAccess.getHeaderAccess().getHeaderKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Header__Group__1__Impl" + + + // $ANTLR start "rule__ArrayTopicSpecRef__Group__0" + // InternalRos2Parser.g:13939:1: rule__ArrayTopicSpecRef__Group__0 : rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 ; + public final void rule__ArrayTopicSpecRef__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13943:1: ( rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 ) + // InternalRos2Parser.g:13944:2: rule__ArrayTopicSpecRef__Group__0__Impl rule__ArrayTopicSpecRef__Group__1 + { + pushFollow(FOLLOW_98); + rule__ArrayTopicSpecRef__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ArrayTopicSpecRef__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayTopicSpecRef__Group__0" + + + // $ANTLR start "rule__ArrayTopicSpecRef__Group__0__Impl" + // InternalRos2Parser.g:13951:1: rule__ArrayTopicSpecRef__Group__0__Impl : ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) ; + public final void rule__ArrayTopicSpecRef__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13955:1: ( ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) ) + // InternalRos2Parser.g:13956:1: ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) + { + // InternalRos2Parser.g:13956:1: ( ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) ) + // InternalRos2Parser.g:13957:2: ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) + { + before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); + // InternalRos2Parser.g:13958:2: ( rule__ArrayTopicSpecRef__TopicSpecAssignment_0 ) + // InternalRos2Parser.g:13958:3: rule__ArrayTopicSpecRef__TopicSpecAssignment_0 + { + pushFollow(FOLLOW_2); + rule__ArrayTopicSpecRef__TopicSpecAssignment_0(); + + state._fsp--; + + + } + + after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayTopicSpecRef__Group__0__Impl" + + + // $ANTLR start "rule__ArrayTopicSpecRef__Group__1" + // InternalRos2Parser.g:13966:1: rule__ArrayTopicSpecRef__Group__1 : rule__ArrayTopicSpecRef__Group__1__Impl ; + public final void rule__ArrayTopicSpecRef__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13970:1: ( rule__ArrayTopicSpecRef__Group__1__Impl ) + // InternalRos2Parser.g:13971:2: rule__ArrayTopicSpecRef__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ArrayTopicSpecRef__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayTopicSpecRef__Group__1" + + + // $ANTLR start "rule__ArrayTopicSpecRef__Group__1__Impl" + // InternalRos2Parser.g:13977:1: rule__ArrayTopicSpecRef__Group__1__Impl : ( LeftSquareBracketRightSquareBracket ) ; + public final void rule__ArrayTopicSpecRef__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:13981:1: ( ( LeftSquareBracketRightSquareBracket ) ) + // InternalRos2Parser.g:13982:1: ( LeftSquareBracketRightSquareBracket ) + { + // InternalRos2Parser.g:13982:1: ( LeftSquareBracketRightSquareBracket ) + // InternalRos2Parser.g:13983:2: LeftSquareBracketRightSquareBracket + { + before(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); + match(input,LeftSquareBracketRightSquareBracket,FOLLOW_2); + after(grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayTopicSpecRef__Group__1__Impl" + + + // $ANTLR start "rule__QualityOfService__UnorderedGroup_1" + // InternalRos2Parser.g:13993:1: rule__QualityOfService__UnorderedGroup_1 : ( rule__QualityOfService__UnorderedGroup_1__0 )? ; + public final void rule__QualityOfService__UnorderedGroup_1() throws RecognitionException { + + int stackSize = keepStackSize(); + getUnorderedGroupHelper().enter(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + + try { + // InternalRos2Parser.g:13998:1: ( ( rule__QualityOfService__UnorderedGroup_1__0 )? ) + // InternalRos2Parser.g:13999:2: ( rule__QualityOfService__UnorderedGroup_1__0 )? + { + // InternalRos2Parser.g:13999:2: ( rule__QualityOfService__UnorderedGroup_1__0 )? + int alt75=2; + int LA75_0 = input.LA(1); + + if ( LA75_0 == Profile && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0) ) { + alt75=1; + } + else if ( LA75_0 == History && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1) ) { + alt75=1; + } + else if ( LA75_0 == Depth && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2) ) { + alt75=1; + } + else if ( LA75_0 == Reliability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3) ) { + alt75=1; + } + else if ( LA75_0 == Durability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4) ) { + alt75=1; + } + switch (alt75) { + case 1 : + // InternalRos2Parser.g:13999:2: rule__QualityOfService__UnorderedGroup_1__0 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__UnorderedGroup_1__0(); + + state._fsp--; + + + } + break; + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + getUnorderedGroupHelper().leave(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__UnorderedGroup_1" + + + // $ANTLR start "rule__QualityOfService__UnorderedGroup_1__Impl" + // InternalRos2Parser.g:14007:1: rule__QualityOfService__UnorderedGroup_1__Impl : ( ({...}? => ( ( ( rule__QualityOfService__Group_1_0__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_1__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_2__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_3__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_4__0 ) ) ) ) ) ; + public final void rule__QualityOfService__UnorderedGroup_1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + boolean selected = false; + + try { + // InternalRos2Parser.g:14012:1: ( ( ({...}? => ( ( ( rule__QualityOfService__Group_1_0__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_1__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_2__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_3__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_4__0 ) ) ) ) ) ) + // InternalRos2Parser.g:14013:3: ( ({...}? => ( ( ( rule__QualityOfService__Group_1_0__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_1__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_2__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_3__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_4__0 ) ) ) ) ) + { + // InternalRos2Parser.g:14013:3: ( ({...}? => ( ( ( rule__QualityOfService__Group_1_0__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_1__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_2__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_3__0 ) ) ) ) | ({...}? => ( ( ( rule__QualityOfService__Group_1_4__0 ) ) ) ) ) + int alt76=5; + int LA76_0 = input.LA(1); + + if ( LA76_0 == Profile && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0) ) { + alt76=1; + } + else if ( LA76_0 == History && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1) ) { + alt76=2; + } + else if ( LA76_0 == Depth && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2) ) { + alt76=3; + } + else if ( LA76_0 == Reliability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3) ) { + alt76=4; + } + else if ( LA76_0 == Durability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4) ) { + alt76=5; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 76, 0, input); + + throw nvae; + } + switch (alt76) { + case 1 : + // InternalRos2Parser.g:14014:3: ({...}? => ( ( ( rule__QualityOfService__Group_1_0__0 ) ) ) ) + { + // InternalRos2Parser.g:14014:3: ({...}? => ( ( ( rule__QualityOfService__Group_1_0__0 ) ) ) ) + // InternalRos2Parser.g:14015:4: {...}? => ( ( ( rule__QualityOfService__Group_1_0__0 ) ) ) + { + if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0) ) { + throw new FailedPredicateException(input, "rule__QualityOfService__UnorderedGroup_1__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0)"); + } + // InternalRos2Parser.g:14015:112: ( ( ( rule__QualityOfService__Group_1_0__0 ) ) ) + // InternalRos2Parser.g:14016:5: ( ( rule__QualityOfService__Group_1_0__0 ) ) + { + + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0); + + + selected = true; + + // InternalRos2Parser.g:14022:5: ( ( rule__QualityOfService__Group_1_0__0 ) ) + // InternalRos2Parser.g:14023:6: ( rule__QualityOfService__Group_1_0__0 ) + { + before(grammarAccess.getQualityOfServiceAccess().getGroup_1_0()); + // InternalRos2Parser.g:14024:6: ( rule__QualityOfService__Group_1_0__0 ) + // InternalRos2Parser.g:14024:7: rule__QualityOfService__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_0__0(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getGroup_1_0()); + + } + + + } + + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:14029:3: ({...}? => ( ( ( rule__QualityOfService__Group_1_1__0 ) ) ) ) + { + // InternalRos2Parser.g:14029:3: ({...}? => ( ( ( rule__QualityOfService__Group_1_1__0 ) ) ) ) + // InternalRos2Parser.g:14030:4: {...}? => ( ( ( rule__QualityOfService__Group_1_1__0 ) ) ) + { + if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1) ) { + throw new FailedPredicateException(input, "rule__QualityOfService__UnorderedGroup_1__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1)"); + } + // InternalRos2Parser.g:14030:112: ( ( ( rule__QualityOfService__Group_1_1__0 ) ) ) + // InternalRos2Parser.g:14031:5: ( ( rule__QualityOfService__Group_1_1__0 ) ) + { + + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1); + + + selected = true; + + // InternalRos2Parser.g:14037:5: ( ( rule__QualityOfService__Group_1_1__0 ) ) + // InternalRos2Parser.g:14038:6: ( rule__QualityOfService__Group_1_1__0 ) + { + before(grammarAccess.getQualityOfServiceAccess().getGroup_1_1()); + // InternalRos2Parser.g:14039:6: ( rule__QualityOfService__Group_1_1__0 ) + // InternalRos2Parser.g:14039:7: rule__QualityOfService__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_1__0(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getGroup_1_1()); + + } + + + } + + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:14044:3: ({...}? => ( ( ( rule__QualityOfService__Group_1_2__0 ) ) ) ) + { + // InternalRos2Parser.g:14044:3: ({...}? => ( ( ( rule__QualityOfService__Group_1_2__0 ) ) ) ) + // InternalRos2Parser.g:14045:4: {...}? => ( ( ( rule__QualityOfService__Group_1_2__0 ) ) ) + { + if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2) ) { + throw new FailedPredicateException(input, "rule__QualityOfService__UnorderedGroup_1__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2)"); + } + // InternalRos2Parser.g:14045:112: ( ( ( rule__QualityOfService__Group_1_2__0 ) ) ) + // InternalRos2Parser.g:14046:5: ( ( rule__QualityOfService__Group_1_2__0 ) ) + { + + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2); + + + selected = true; + + // InternalRos2Parser.g:14052:5: ( ( rule__QualityOfService__Group_1_2__0 ) ) + // InternalRos2Parser.g:14053:6: ( rule__QualityOfService__Group_1_2__0 ) + { + before(grammarAccess.getQualityOfServiceAccess().getGroup_1_2()); + // InternalRos2Parser.g:14054:6: ( rule__QualityOfService__Group_1_2__0 ) + // InternalRos2Parser.g:14054:7: rule__QualityOfService__Group_1_2__0 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_2__0(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getGroup_1_2()); + + } + + + } + + + } + + + } + break; + case 4 : + // InternalRos2Parser.g:14059:3: ({...}? => ( ( ( rule__QualityOfService__Group_1_3__0 ) ) ) ) + { + // InternalRos2Parser.g:14059:3: ({...}? => ( ( ( rule__QualityOfService__Group_1_3__0 ) ) ) ) + // InternalRos2Parser.g:14060:4: {...}? => ( ( ( rule__QualityOfService__Group_1_3__0 ) ) ) + { + if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3) ) { + throw new FailedPredicateException(input, "rule__QualityOfService__UnorderedGroup_1__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3)"); + } + // InternalRos2Parser.g:14060:112: ( ( ( rule__QualityOfService__Group_1_3__0 ) ) ) + // InternalRos2Parser.g:14061:5: ( ( rule__QualityOfService__Group_1_3__0 ) ) + { + + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3); + + + selected = true; + + // InternalRos2Parser.g:14067:5: ( ( rule__QualityOfService__Group_1_3__0 ) ) + // InternalRos2Parser.g:14068:6: ( rule__QualityOfService__Group_1_3__0 ) + { + before(grammarAccess.getQualityOfServiceAccess().getGroup_1_3()); + // InternalRos2Parser.g:14069:6: ( rule__QualityOfService__Group_1_3__0 ) + // InternalRos2Parser.g:14069:7: rule__QualityOfService__Group_1_3__0 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_3__0(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getGroup_1_3()); + + } + + + } + + + } + + + } + break; + case 5 : + // InternalRos2Parser.g:14074:3: ({...}? => ( ( ( rule__QualityOfService__Group_1_4__0 ) ) ) ) + { + // InternalRos2Parser.g:14074:3: ({...}? => ( ( ( rule__QualityOfService__Group_1_4__0 ) ) ) ) + // InternalRos2Parser.g:14075:4: {...}? => ( ( ( rule__QualityOfService__Group_1_4__0 ) ) ) + { + if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4) ) { + throw new FailedPredicateException(input, "rule__QualityOfService__UnorderedGroup_1__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4)"); + } + // InternalRos2Parser.g:14075:112: ( ( ( rule__QualityOfService__Group_1_4__0 ) ) ) + // InternalRos2Parser.g:14076:5: ( ( rule__QualityOfService__Group_1_4__0 ) ) + { + + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4); + + + selected = true; + + // InternalRos2Parser.g:14082:5: ( ( rule__QualityOfService__Group_1_4__0 ) ) + // InternalRos2Parser.g:14083:6: ( rule__QualityOfService__Group_1_4__0 ) + { + before(grammarAccess.getQualityOfServiceAccess().getGroup_1_4()); + // InternalRos2Parser.g:14084:6: ( rule__QualityOfService__Group_1_4__0 ) + // InternalRos2Parser.g:14084:7: rule__QualityOfService__Group_1_4__0 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__Group_1_4__0(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getGroup_1_4()); + + } + + + } + + + } + + + } + break; + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + if (selected) + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__UnorderedGroup_1__Impl" + + + // $ANTLR start "rule__QualityOfService__UnorderedGroup_1__0" + // InternalRos2Parser.g:14097:1: rule__QualityOfService__UnorderedGroup_1__0 : rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__1 )? ; + public final void rule__QualityOfService__UnorderedGroup_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14101:1: ( rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__1 )? ) + // InternalRos2Parser.g:14102:2: rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__1 )? + { + pushFollow(FOLLOW_99); + rule__QualityOfService__UnorderedGroup_1__Impl(); + + state._fsp--; + + // InternalRos2Parser.g:14103:2: ( rule__QualityOfService__UnorderedGroup_1__1 )? + int alt77=2; + int LA77_0 = input.LA(1); + + if ( LA77_0 == Profile && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0) ) { + alt77=1; + } + else if ( LA77_0 == History && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1) ) { + alt77=1; + } + else if ( LA77_0 == Depth && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2) ) { + alt77=1; + } + else if ( LA77_0 == Reliability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3) ) { + alt77=1; + } + else if ( LA77_0 == Durability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4) ) { + alt77=1; + } + switch (alt77) { + case 1 : + // InternalRos2Parser.g:14103:2: rule__QualityOfService__UnorderedGroup_1__1 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__UnorderedGroup_1__1(); + + state._fsp--; + + + } + break; + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__UnorderedGroup_1__0" + + + // $ANTLR start "rule__QualityOfService__UnorderedGroup_1__1" + // InternalRos2Parser.g:14109:1: rule__QualityOfService__UnorderedGroup_1__1 : rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__2 )? ; + public final void rule__QualityOfService__UnorderedGroup_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14113:1: ( rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__2 )? ) + // InternalRos2Parser.g:14114:2: rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__2 )? + { + pushFollow(FOLLOW_99); + rule__QualityOfService__UnorderedGroup_1__Impl(); + + state._fsp--; + + // InternalRos2Parser.g:14115:2: ( rule__QualityOfService__UnorderedGroup_1__2 )? + int alt78=2; + int LA78_0 = input.LA(1); + + if ( LA78_0 == Profile && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0) ) { + alt78=1; + } + else if ( LA78_0 == History && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1) ) { + alt78=1; + } + else if ( LA78_0 == Depth && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2) ) { + alt78=1; + } + else if ( LA78_0 == Reliability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3) ) { + alt78=1; + } + else if ( LA78_0 == Durability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4) ) { + alt78=1; + } + switch (alt78) { + case 1 : + // InternalRos2Parser.g:14115:2: rule__QualityOfService__UnorderedGroup_1__2 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__UnorderedGroup_1__2(); + + state._fsp--; + + + } + break; + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__UnorderedGroup_1__1" + + + // $ANTLR start "rule__QualityOfService__UnorderedGroup_1__2" + // InternalRos2Parser.g:14121:1: rule__QualityOfService__UnorderedGroup_1__2 : rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__3 )? ; + public final void rule__QualityOfService__UnorderedGroup_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14125:1: ( rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__3 )? ) + // InternalRos2Parser.g:14126:2: rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__3 )? + { + pushFollow(FOLLOW_99); + rule__QualityOfService__UnorderedGroup_1__Impl(); + + state._fsp--; + + // InternalRos2Parser.g:14127:2: ( rule__QualityOfService__UnorderedGroup_1__3 )? + int alt79=2; + int LA79_0 = input.LA(1); + + if ( LA79_0 == Profile && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0) ) { + alt79=1; + } + else if ( LA79_0 == History && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1) ) { + alt79=1; + } + else if ( LA79_0 == Depth && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2) ) { + alt79=1; + } + else if ( LA79_0 == Reliability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3) ) { + alt79=1; + } + else if ( LA79_0 == Durability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4) ) { + alt79=1; + } + switch (alt79) { + case 1 : + // InternalRos2Parser.g:14127:2: rule__QualityOfService__UnorderedGroup_1__3 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__UnorderedGroup_1__3(); + + state._fsp--; + + + } + break; + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__UnorderedGroup_1__2" + + + // $ANTLR start "rule__QualityOfService__UnorderedGroup_1__3" + // InternalRos2Parser.g:14133:1: rule__QualityOfService__UnorderedGroup_1__3 : rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__4 )? ; + public final void rule__QualityOfService__UnorderedGroup_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14137:1: ( rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__4 )? ) + // InternalRos2Parser.g:14138:2: rule__QualityOfService__UnorderedGroup_1__Impl ( rule__QualityOfService__UnorderedGroup_1__4 )? + { + pushFollow(FOLLOW_99); + rule__QualityOfService__UnorderedGroup_1__Impl(); + + state._fsp--; + + // InternalRos2Parser.g:14139:2: ( rule__QualityOfService__UnorderedGroup_1__4 )? + int alt80=2; + int LA80_0 = input.LA(1); + + if ( LA80_0 == Profile && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0) ) { + alt80=1; + } + else if ( LA80_0 == History && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1) ) { + alt80=1; + } + else if ( LA80_0 == Depth && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2) ) { + alt80=1; + } + else if ( LA80_0 == Reliability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3) ) { + alt80=1; + } + else if ( LA80_0 == Durability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4) ) { + alt80=1; + } + switch (alt80) { + case 1 : + // InternalRos2Parser.g:14139:2: rule__QualityOfService__UnorderedGroup_1__4 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__UnorderedGroup_1__4(); + + state._fsp--; + + + } + break; + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__UnorderedGroup_1__3" + + + // $ANTLR start "rule__QualityOfService__UnorderedGroup_1__4" + // InternalRos2Parser.g:14145:1: rule__QualityOfService__UnorderedGroup_1__4 : rule__QualityOfService__UnorderedGroup_1__Impl ; + public final void rule__QualityOfService__UnorderedGroup_1__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14149:1: ( rule__QualityOfService__UnorderedGroup_1__Impl ) + // InternalRos2Parser.g:14150:2: rule__QualityOfService__UnorderedGroup_1__Impl + { + pushFollow(FOLLOW_2); + rule__QualityOfService__UnorderedGroup_1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__UnorderedGroup_1__4" + + + // $ANTLR start "rule__AmentPackage__NameAssignment_1" + // InternalRos2Parser.g:14157:1: rule__AmentPackage__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__AmentPackage__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14161:1: ( ( ruleRosNames ) ) + // InternalRos2Parser.g:14162:2: ( ruleRosNames ) + { + // InternalRos2Parser.g:14162:2: ( ruleRosNames ) + // InternalRos2Parser.g:14163:3: ruleRosNames + { + before(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleRosNames(); + + state._fsp--; + + after(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__NameAssignment_1" + + + // $ANTLR start "rule__AmentPackage__FromGitRepoAssignment_4_1" + // InternalRos2Parser.g:14172:1: rule__AmentPackage__FromGitRepoAssignment_4_1 : ( ruleEString ) ; + public final void rule__AmentPackage__FromGitRepoAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14176:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:14177:2: ( ruleEString ) + { + // InternalRos2Parser.g:14177:2: ( ruleEString ) + // InternalRos2Parser.g:14178:3: ruleEString + { + before(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__FromGitRepoAssignment_4_1" + + + // $ANTLR start "rule__AmentPackage__ArtifactAssignment_5_2" + // InternalRos2Parser.g:14187:1: rule__AmentPackage__ArtifactAssignment_5_2 : ( ruleArtifact ) ; + public final void rule__AmentPackage__ArtifactAssignment_5_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14191:1: ( ( ruleArtifact ) ) + // InternalRos2Parser.g:14192:2: ( ruleArtifact ) + { + // InternalRos2Parser.g:14192:2: ( ruleArtifact ) + // InternalRos2Parser.g:14193:3: ruleArtifact + { + before(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); + pushFollow(FOLLOW_2); + ruleArtifact(); + + state._fsp--; + + after(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__ArtifactAssignment_5_2" + + + // $ANTLR start "rule__AmentPackage__DependencyAssignment_6_2" + // InternalRos2Parser.g:14202:1: rule__AmentPackage__DependencyAssignment_6_2 : ( ruleDependency ) ; + public final void rule__AmentPackage__DependencyAssignment_6_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14206:1: ( ( ruleDependency ) ) + // InternalRos2Parser.g:14207:2: ( ruleDependency ) + { + // InternalRos2Parser.g:14207:2: ( ruleDependency ) + // InternalRos2Parser.g:14208:3: ruleDependency + { + before(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); + pushFollow(FOLLOW_2); + ruleDependency(); + + state._fsp--; + + after(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__DependencyAssignment_6_2" + + + // $ANTLR start "rule__AmentPackage__DependencyAssignment_6_3_1" + // InternalRos2Parser.g:14217:1: rule__AmentPackage__DependencyAssignment_6_3_1 : ( ruleDependency ) ; + public final void rule__AmentPackage__DependencyAssignment_6_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14221:1: ( ( ruleDependency ) ) + // InternalRos2Parser.g:14222:2: ( ruleDependency ) + { + // InternalRos2Parser.g:14222:2: ( ruleDependency ) + // InternalRos2Parser.g:14223:3: ruleDependency + { + before(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + pushFollow(FOLLOW_2); + ruleDependency(); + + state._fsp--; + + after(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AmentPackage__DependencyAssignment_6_3_1" + + + // $ANTLR start "rule__QualityOfService__QoSProfileAssignment_1_0_1" + // InternalRos2Parser.g:14232:1: rule__QualityOfService__QoSProfileAssignment_1_0_1 : ( ( rule__QualityOfService__QoSProfileAlternatives_1_0_1_0 ) ) ; + public final void rule__QualityOfService__QoSProfileAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14236:1: ( ( ( rule__QualityOfService__QoSProfileAlternatives_1_0_1_0 ) ) ) + // InternalRos2Parser.g:14237:2: ( ( rule__QualityOfService__QoSProfileAlternatives_1_0_1_0 ) ) + { + // InternalRos2Parser.g:14237:2: ( ( rule__QualityOfService__QoSProfileAlternatives_1_0_1_0 ) ) + // InternalRos2Parser.g:14238:3: ( rule__QualityOfService__QoSProfileAlternatives_1_0_1_0 ) + { + before(grammarAccess.getQualityOfServiceAccess().getQoSProfileAlternatives_1_0_1_0()); + // InternalRos2Parser.g:14239:3: ( rule__QualityOfService__QoSProfileAlternatives_1_0_1_0 ) + // InternalRos2Parser.g:14239:4: rule__QualityOfService__QoSProfileAlternatives_1_0_1_0 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__QoSProfileAlternatives_1_0_1_0(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getQoSProfileAlternatives_1_0_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__QoSProfileAssignment_1_0_1" + + + // $ANTLR start "rule__QualityOfService__HistoryAssignment_1_1_1" + // InternalRos2Parser.g:14247:1: rule__QualityOfService__HistoryAssignment_1_1_1 : ( ( rule__QualityOfService__HistoryAlternatives_1_1_1_0 ) ) ; + public final void rule__QualityOfService__HistoryAssignment_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14251:1: ( ( ( rule__QualityOfService__HistoryAlternatives_1_1_1_0 ) ) ) + // InternalRos2Parser.g:14252:2: ( ( rule__QualityOfService__HistoryAlternatives_1_1_1_0 ) ) + { + // InternalRos2Parser.g:14252:2: ( ( rule__QualityOfService__HistoryAlternatives_1_1_1_0 ) ) + // InternalRos2Parser.g:14253:3: ( rule__QualityOfService__HistoryAlternatives_1_1_1_0 ) + { + before(grammarAccess.getQualityOfServiceAccess().getHistoryAlternatives_1_1_1_0()); + // InternalRos2Parser.g:14254:3: ( rule__QualityOfService__HistoryAlternatives_1_1_1_0 ) + // InternalRos2Parser.g:14254:4: rule__QualityOfService__HistoryAlternatives_1_1_1_0 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__HistoryAlternatives_1_1_1_0(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getHistoryAlternatives_1_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__HistoryAssignment_1_1_1" + + + // $ANTLR start "rule__QualityOfService__DepthAssignment_1_2_1" + // InternalRos2Parser.g:14262:1: rule__QualityOfService__DepthAssignment_1_2_1 : ( ruleInteger0 ) ; + public final void rule__QualityOfService__DepthAssignment_1_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14266:1: ( ( ruleInteger0 ) ) + // InternalRos2Parser.g:14267:2: ( ruleInteger0 ) + { + // InternalRos2Parser.g:14267:2: ( ruleInteger0 ) + // InternalRos2Parser.g:14268:3: ruleInteger0 + { + before(grammarAccess.getQualityOfServiceAccess().getDepthInteger0ParserRuleCall_1_2_1_0()); + pushFollow(FOLLOW_2); + ruleInteger0(); + + state._fsp--; + + after(grammarAccess.getQualityOfServiceAccess().getDepthInteger0ParserRuleCall_1_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__DepthAssignment_1_2_1" + + + // $ANTLR start "rule__QualityOfService__ReliabilityAssignment_1_3_1" + // InternalRos2Parser.g:14277:1: rule__QualityOfService__ReliabilityAssignment_1_3_1 : ( ( rule__QualityOfService__ReliabilityAlternatives_1_3_1_0 ) ) ; + public final void rule__QualityOfService__ReliabilityAssignment_1_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14281:1: ( ( ( rule__QualityOfService__ReliabilityAlternatives_1_3_1_0 ) ) ) + // InternalRos2Parser.g:14282:2: ( ( rule__QualityOfService__ReliabilityAlternatives_1_3_1_0 ) ) + { + // InternalRos2Parser.g:14282:2: ( ( rule__QualityOfService__ReliabilityAlternatives_1_3_1_0 ) ) + // InternalRos2Parser.g:14283:3: ( rule__QualityOfService__ReliabilityAlternatives_1_3_1_0 ) + { + before(grammarAccess.getQualityOfServiceAccess().getReliabilityAlternatives_1_3_1_0()); + // InternalRos2Parser.g:14284:3: ( rule__QualityOfService__ReliabilityAlternatives_1_3_1_0 ) + // InternalRos2Parser.g:14284:4: rule__QualityOfService__ReliabilityAlternatives_1_3_1_0 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__ReliabilityAlternatives_1_3_1_0(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getReliabilityAlternatives_1_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__ReliabilityAssignment_1_3_1" + + + // $ANTLR start "rule__QualityOfService__DurabilityAssignment_1_4_1" + // InternalRos2Parser.g:14292:1: rule__QualityOfService__DurabilityAssignment_1_4_1 : ( ( rule__QualityOfService__DurabilityAlternatives_1_4_1_0 ) ) ; + public final void rule__QualityOfService__DurabilityAssignment_1_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14296:1: ( ( ( rule__QualityOfService__DurabilityAlternatives_1_4_1_0 ) ) ) + // InternalRos2Parser.g:14297:2: ( ( rule__QualityOfService__DurabilityAlternatives_1_4_1_0 ) ) + { + // InternalRos2Parser.g:14297:2: ( ( rule__QualityOfService__DurabilityAlternatives_1_4_1_0 ) ) + // InternalRos2Parser.g:14298:3: ( rule__QualityOfService__DurabilityAlternatives_1_4_1_0 ) + { + before(grammarAccess.getQualityOfServiceAccess().getDurabilityAlternatives_1_4_1_0()); + // InternalRos2Parser.g:14299:3: ( rule__QualityOfService__DurabilityAlternatives_1_4_1_0 ) + // InternalRos2Parser.g:14299:4: rule__QualityOfService__DurabilityAlternatives_1_4_1_0 + { + pushFollow(FOLLOW_2); + rule__QualityOfService__DurabilityAlternatives_1_4_1_0(); + + state._fsp--; + + + } + + after(grammarAccess.getQualityOfServiceAccess().getDurabilityAlternatives_1_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualityOfService__DurabilityAssignment_1_4_1" + + + // $ANTLR start "rule__Publisher__NameAssignment_1" + // InternalRos2Parser.g:14307:1: rule__Publisher__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Publisher__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14311:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:14312:2: ( ruleEString ) + { + // InternalRos2Parser.g:14312:2: ( ruleEString ) + // InternalRos2Parser.g:14313: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" + // InternalRos2Parser.g:14322:1: rule__Publisher__MessageAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__Publisher__MessageAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14326:1: ( ( ( ruleEString ) ) ) + // InternalRos2Parser.g:14327:2: ( ( ruleEString ) ) + { + // InternalRos2Parser.g:14327:2: ( ( ruleEString ) ) + // InternalRos2Parser.g:14328:3: ( ruleEString ) + { + before(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + // InternalRos2Parser.g:14329:3: ( ruleEString ) + // InternalRos2Parser.g:14330: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__Publisher__NamespaceAssignment_6_1" + // InternalRos2Parser.g:14341:1: rule__Publisher__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__Publisher__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14345:1: ( ( ruleNamespace ) ) + // InternalRos2Parser.g:14346:2: ( ruleNamespace ) + { + // InternalRos2Parser.g:14346:2: ( ruleNamespace ) + // InternalRos2Parser.g:14347:3: ruleNamespace + { + before(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__Publisher__QosAssignment_7_2" + // InternalRos2Parser.g:14356:1: rule__Publisher__QosAssignment_7_2 : ( ruleQualityOfService ) ; + public final void rule__Publisher__QosAssignment_7_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14360:1: ( ( ruleQualityOfService ) ) + // InternalRos2Parser.g:14361:2: ( ruleQualityOfService ) + { + // InternalRos2Parser.g:14361:2: ( ruleQualityOfService ) + // InternalRos2Parser.g:14362:3: ruleQualityOfService + { + before(grammarAccess.getPublisherAccess().getQosQualityOfServiceParserRuleCall_7_2_0()); + pushFollow(FOLLOW_2); + ruleQualityOfService(); + + state._fsp--; + + after(grammarAccess.getPublisherAccess().getQosQualityOfServiceParserRuleCall_7_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__QosAssignment_7_2" + + + // $ANTLR start "rule__Subscriber__NameAssignment_1" + // InternalRos2Parser.g:14371:1: rule__Subscriber__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Subscriber__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14375:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:14376:2: ( ruleEString ) + { + // InternalRos2Parser.g:14376:2: ( ruleEString ) + // InternalRos2Parser.g:14377: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" + // InternalRos2Parser.g:14386:1: rule__Subscriber__MessageAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__Subscriber__MessageAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14390:1: ( ( ( ruleEString ) ) ) + // InternalRos2Parser.g:14391:2: ( ( ruleEString ) ) + { + // InternalRos2Parser.g:14391:2: ( ( ruleEString ) ) + // InternalRos2Parser.g:14392:3: ( ruleEString ) + { + before(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + // InternalRos2Parser.g:14393:3: ( ruleEString ) + // InternalRos2Parser.g:14394: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__Subscriber__NamespaceAssignment_6_1" + // InternalRos2Parser.g:14405:1: rule__Subscriber__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__Subscriber__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14409:1: ( ( ruleNamespace ) ) + // InternalRos2Parser.g:14410:2: ( ruleNamespace ) + { + // InternalRos2Parser.g:14410:2: ( ruleNamespace ) + // InternalRos2Parser.g:14411:3: ruleNamespace + { + before(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__Subscriber__QosAssignment_7_1" + // InternalRos2Parser.g:14420:1: rule__Subscriber__QosAssignment_7_1 : ( ruleQualityOfService ) ; + public final void rule__Subscriber__QosAssignment_7_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14424:1: ( ( ruleQualityOfService ) ) + // InternalRos2Parser.g:14425:2: ( ruleQualityOfService ) + { + // InternalRos2Parser.g:14425:2: ( ruleQualityOfService ) + // InternalRos2Parser.g:14426:3: ruleQualityOfService + { + before(grammarAccess.getSubscriberAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + pushFollow(FOLLOW_2); + ruleQualityOfService(); + + state._fsp--; + + after(grammarAccess.getSubscriberAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__QosAssignment_7_1" + + + // $ANTLR start "rule__ServiceServer__NameAssignment_1" + // InternalRos2Parser.g:14435:1: rule__ServiceServer__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ServiceServer__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14439:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:14440:2: ( ruleEString ) + { + // InternalRos2Parser.g:14440:2: ( ruleEString ) + // InternalRos2Parser.g:14441:3: ruleEString + { + before(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__NameAssignment_1" + + + // $ANTLR start "rule__ServiceServer__ServiceAssignment_5" + // InternalRos2Parser.g:14450:1: rule__ServiceServer__ServiceAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__ServiceServer__ServiceAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14454:1: ( ( ( ruleEString ) ) ) + // InternalRos2Parser.g:14455:2: ( ( ruleEString ) ) + { + // InternalRos2Parser.g:14455:2: ( ( ruleEString ) ) + // InternalRos2Parser.g:14456:3: ( ruleEString ) + { + before(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); + // InternalRos2Parser.g:14457:3: ( ruleEString ) + // InternalRos2Parser.g:14458:4: ruleEString + { + before(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getServiceServerAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); + + } + + after(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__ServiceAssignment_5" + + + // $ANTLR start "rule__ServiceServer__NamespaceAssignment_6_1" + // InternalRos2Parser.g:14469:1: rule__ServiceServer__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__ServiceServer__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14473:1: ( ( ruleNamespace ) ) + // InternalRos2Parser.g:14474:2: ( ruleNamespace ) + { + // InternalRos2Parser.g:14474:2: ( ruleNamespace ) + // InternalRos2Parser.g:14475:3: ruleNamespace + { + before(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__ServiceServer__QosAssignment_7_1" + // InternalRos2Parser.g:14484:1: rule__ServiceServer__QosAssignment_7_1 : ( ruleQualityOfService ) ; + public final void rule__ServiceServer__QosAssignment_7_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14488:1: ( ( ruleQualityOfService ) ) + // InternalRos2Parser.g:14489:2: ( ruleQualityOfService ) + { + // InternalRos2Parser.g:14489:2: ( ruleQualityOfService ) + // InternalRos2Parser.g:14490:3: ruleQualityOfService + { + before(grammarAccess.getServiceServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + pushFollow(FOLLOW_2); + ruleQualityOfService(); + + state._fsp--; + + after(grammarAccess.getServiceServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceServer__QosAssignment_7_1" + + + // $ANTLR start "rule__ServiceClient__NameAssignment_1" + // InternalRos2Parser.g:14499:1: rule__ServiceClient__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ServiceClient__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14503:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:14504:2: ( ruleEString ) + { + // InternalRos2Parser.g:14504:2: ( ruleEString ) + // InternalRos2Parser.g:14505:3: ruleEString + { + before(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__NameAssignment_1" + + + // $ANTLR start "rule__ServiceClient__ServiceAssignment_5" + // InternalRos2Parser.g:14514:1: rule__ServiceClient__ServiceAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__ServiceClient__ServiceAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14518:1: ( ( ( ruleEString ) ) ) + // InternalRos2Parser.g:14519:2: ( ( ruleEString ) ) + { + // InternalRos2Parser.g:14519:2: ( ( ruleEString ) ) + // InternalRos2Parser.g:14520:3: ( ruleEString ) + { + before(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); + // InternalRos2Parser.g:14521:3: ( ruleEString ) + // InternalRos2Parser.g:14522:4: ruleEString + { + before(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getServiceClientAccess().getServiceServiceSpecEStringParserRuleCall_5_0_1()); + + } + + after(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__ServiceAssignment_5" + + + // $ANTLR start "rule__ServiceClient__NamespaceAssignment_6_1" + // InternalRos2Parser.g:14533:1: rule__ServiceClient__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__ServiceClient__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14537:1: ( ( ruleNamespace ) ) + // InternalRos2Parser.g:14538:2: ( ruleNamespace ) + { + // InternalRos2Parser.g:14538:2: ( ruleNamespace ) + // InternalRos2Parser.g:14539:3: ruleNamespace + { + before(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__ServiceClient__QosAssignment_7_1" + // InternalRos2Parser.g:14548:1: rule__ServiceClient__QosAssignment_7_1 : ( ruleQualityOfService ) ; + public final void rule__ServiceClient__QosAssignment_7_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14552:1: ( ( ruleQualityOfService ) ) + // InternalRos2Parser.g:14553:2: ( ruleQualityOfService ) + { + // InternalRos2Parser.g:14553:2: ( ruleQualityOfService ) + // InternalRos2Parser.g:14554:3: ruleQualityOfService + { + before(grammarAccess.getServiceClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + pushFollow(FOLLOW_2); + ruleQualityOfService(); + + state._fsp--; + + after(grammarAccess.getServiceClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceClient__QosAssignment_7_1" + + + // $ANTLR start "rule__ActionServer__NameAssignment_1" + // InternalRos2Parser.g:14563:1: rule__ActionServer__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ActionServer__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14567:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:14568:2: ( ruleEString ) + { + // InternalRos2Parser.g:14568:2: ( ruleEString ) + // InternalRos2Parser.g:14569:3: ruleEString + { + before(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__NameAssignment_1" + + + // $ANTLR start "rule__ActionServer__ActionAssignment_5" + // InternalRos2Parser.g:14578:1: rule__ActionServer__ActionAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__ActionServer__ActionAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14582:1: ( ( ( ruleEString ) ) ) + // InternalRos2Parser.g:14583:2: ( ( ruleEString ) ) + { + // InternalRos2Parser.g:14583:2: ( ( ruleEString ) ) + // InternalRos2Parser.g:14584:3: ( ruleEString ) + { + before(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); + // InternalRos2Parser.g:14585:3: ( ruleEString ) + // InternalRos2Parser.g:14586:4: ruleEString + { + before(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getActionServerAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); + + } + + after(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__ActionAssignment_5" + + + // $ANTLR start "rule__ActionServer__NamespaceAssignment_6_1" + // InternalRos2Parser.g:14597:1: rule__ActionServer__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__ActionServer__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14601:1: ( ( ruleNamespace ) ) + // InternalRos2Parser.g:14602:2: ( ruleNamespace ) + { + // InternalRos2Parser.g:14602:2: ( ruleNamespace ) + // InternalRos2Parser.g:14603:3: ruleNamespace + { + before(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__ActionServer__QosAssignment_7_1" + // InternalRos2Parser.g:14612:1: rule__ActionServer__QosAssignment_7_1 : ( ruleQualityOfService ) ; + public final void rule__ActionServer__QosAssignment_7_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14616:1: ( ( ruleQualityOfService ) ) + // InternalRos2Parser.g:14617:2: ( ruleQualityOfService ) + { + // InternalRos2Parser.g:14617:2: ( ruleQualityOfService ) + // InternalRos2Parser.g:14618:3: ruleQualityOfService + { + before(grammarAccess.getActionServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + pushFollow(FOLLOW_2); + ruleQualityOfService(); + + state._fsp--; + + after(grammarAccess.getActionServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionServer__QosAssignment_7_1" + + + // $ANTLR start "rule__ActionClient__NameAssignment_1" + // InternalRos2Parser.g:14627:1: rule__ActionClient__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ActionClient__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14631:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:14632:2: ( ruleEString ) + { + // InternalRos2Parser.g:14632:2: ( ruleEString ) + // InternalRos2Parser.g:14633:3: ruleEString + { + before(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__NameAssignment_1" + + + // $ANTLR start "rule__ActionClient__ActionAssignment_5" + // InternalRos2Parser.g:14642:1: rule__ActionClient__ActionAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__ActionClient__ActionAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14646:1: ( ( ( ruleEString ) ) ) + // InternalRos2Parser.g:14647:2: ( ( ruleEString ) ) + { + // InternalRos2Parser.g:14647:2: ( ( ruleEString ) ) + // InternalRos2Parser.g:14648:3: ( ruleEString ) + { + before(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); + // InternalRos2Parser.g:14649:3: ( ruleEString ) + // InternalRos2Parser.g:14650:4: ruleEString + { + before(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getActionClientAccess().getActionActionSpecEStringParserRuleCall_5_0_1()); + + } + + after(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__ActionAssignment_5" + + + // $ANTLR start "rule__ActionClient__NamespaceAssignment_6_1" + // InternalRos2Parser.g:14661:1: rule__ActionClient__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__ActionClient__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14665:1: ( ( ruleNamespace ) ) + // InternalRos2Parser.g:14666:2: ( ruleNamespace ) + { + // InternalRos2Parser.g:14666:2: ( ruleNamespace ) + // InternalRos2Parser.g:14667:3: ruleNamespace + { + before(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__ActionClient__QosAssignment_7_1" + // InternalRos2Parser.g:14676:1: rule__ActionClient__QosAssignment_7_1 : ( ruleQualityOfService ) ; + public final void rule__ActionClient__QosAssignment_7_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14680:1: ( ( ruleQualityOfService ) ) + // InternalRos2Parser.g:14681:2: ( ruleQualityOfService ) + { + // InternalRos2Parser.g:14681:2: ( ruleQualityOfService ) + // InternalRos2Parser.g:14682:3: ruleQualityOfService + { + before(grammarAccess.getActionClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + pushFollow(FOLLOW_2); + ruleQualityOfService(); + + state._fsp--; + + after(grammarAccess.getActionClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionClient__QosAssignment_7_1" + + + // $ANTLR start "rule__Parameter__NameAssignment_1" + // InternalRos2Parser.g:14691:1: rule__Parameter__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Parameter__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14695:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:14696:2: ( ruleEString ) + { + // InternalRos2Parser.g:14696:2: ( ruleEString ) + // InternalRos2Parser.g:14697: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__Parameter__TypeAssignment_5" + // InternalRos2Parser.g:14706:1: rule__Parameter__TypeAssignment_5 : ( ruleParameterType ) ; + public final void rule__Parameter__TypeAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14710:1: ( ( ruleParameterType ) ) + // InternalRos2Parser.g:14711:2: ( ruleParameterType ) + { + // InternalRos2Parser.g:14711:2: ( ruleParameterType ) + // InternalRos2Parser.g:14712:3: ruleParameterType + { + before(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); + pushFollow(FOLLOW_2); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__TypeAssignment_5" + + + // $ANTLR start "rule__Parameter__NamespaceAssignment_6_1" + // InternalRos2Parser.g:14721:1: rule__Parameter__NamespaceAssignment_6_1 : ( ruleNamespace ) ; + public final void rule__Parameter__NamespaceAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14725:1: ( ( ruleNamespace ) ) + // InternalRos2Parser.g:14726:2: ( ruleNamespace ) + { + // InternalRos2Parser.g:14726:2: ( ruleNamespace ) + // InternalRos2Parser.g:14727:3: ruleNamespace + { + before(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + pushFollow(FOLLOW_2); + ruleNamespace(); + + state._fsp--; + + after(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__NamespaceAssignment_6_1" + + + // $ANTLR start "rule__Parameter__QosAssignment_7_1" + // InternalRos2Parser.g:14736:1: rule__Parameter__QosAssignment_7_1 : ( ruleQualityOfService ) ; + public final void rule__Parameter__QosAssignment_7_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14740:1: ( ( ruleQualityOfService ) ) + // InternalRos2Parser.g:14741:2: ( ruleQualityOfService ) + { + // InternalRos2Parser.g:14741:2: ( ruleQualityOfService ) + // InternalRos2Parser.g:14742:3: ruleQualityOfService + { + before(grammarAccess.getParameterAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + pushFollow(FOLLOW_2); + ruleQualityOfService(); + + state._fsp--; + + after(grammarAccess.getParameterAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__QosAssignment_7_1" + + + // $ANTLR start "rule__Package_Impl__NameAssignment_1" + // InternalRos2Parser.g:14751:1: rule__Package_Impl__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__Package_Impl__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14755:1: ( ( ruleRosNames ) ) + // InternalRos2Parser.g:14756:2: ( ruleRosNames ) + { + // InternalRos2Parser.g:14756:2: ( ruleRosNames ) + // InternalRos2Parser.g:14757:3: ruleRosNames + { + before(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleRosNames(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__NameAssignment_1" + + + // $ANTLR start "rule__Package_Impl__FromGitRepoAssignment_4_1" + // InternalRos2Parser.g:14766:1: rule__Package_Impl__FromGitRepoAssignment_4_1 : ( ruleEString ) ; + public final void rule__Package_Impl__FromGitRepoAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14770:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:14771:2: ( ruleEString ) + { + // InternalRos2Parser.g:14771:2: ( ruleEString ) + // InternalRos2Parser.g:14772:3: ruleEString + { + before(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__FromGitRepoAssignment_4_1" + + + // $ANTLR start "rule__Package_Impl__SpecAssignment_5_2" + // InternalRos2Parser.g:14781:1: rule__Package_Impl__SpecAssignment_5_2 : ( ruleSpecBase ) ; + public final void rule__Package_Impl__SpecAssignment_5_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14785:1: ( ( ruleSpecBase ) ) + // InternalRos2Parser.g:14786:2: ( ruleSpecBase ) + { + // InternalRos2Parser.g:14786:2: ( ruleSpecBase ) + // InternalRos2Parser.g:14787:3: ruleSpecBase + { + before(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); + pushFollow(FOLLOW_2); + ruleSpecBase(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__SpecAssignment_5_2" + + + // $ANTLR start "rule__Package_Impl__DependencyAssignment_6_2" + // InternalRos2Parser.g:14796:1: rule__Package_Impl__DependencyAssignment_6_2 : ( ruleDependency ) ; + public final void rule__Package_Impl__DependencyAssignment_6_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14800:1: ( ( ruleDependency ) ) + // InternalRos2Parser.g:14801:2: ( ruleDependency ) + { + // InternalRos2Parser.g:14801:2: ( ruleDependency ) + // InternalRos2Parser.g:14802:3: ruleDependency + { + before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); + pushFollow(FOLLOW_2); + ruleDependency(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__DependencyAssignment_6_2" + + + // $ANTLR start "rule__Package_Impl__DependencyAssignment_6_3_1" + // InternalRos2Parser.g:14811:1: rule__Package_Impl__DependencyAssignment_6_3_1 : ( ruleDependency ) ; + public final void rule__Package_Impl__DependencyAssignment_6_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14815:1: ( ( ruleDependency ) ) + // InternalRos2Parser.g:14816:2: ( ruleDependency ) + { + // InternalRos2Parser.g:14816:2: ( ruleDependency ) + // InternalRos2Parser.g:14817:3: ruleDependency + { + before(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + pushFollow(FOLLOW_2); + ruleDependency(); + + state._fsp--; + + after(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Package_Impl__DependencyAssignment_6_3_1" + + + // $ANTLR start "rule__Artifact__NameAssignment_1" + // InternalRos2Parser.g:14826:1: rule__Artifact__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__Artifact__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14830:1: ( ( ruleRosNames ) ) + // InternalRos2Parser.g:14831:2: ( ruleRosNames ) + { + // InternalRos2Parser.g:14831:2: ( ruleRosNames ) + // InternalRos2Parser.g:14832: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" + // InternalRos2Parser.g:14841:1: rule__Artifact__NodeAssignment_4 : ( ruleNode ) ; + public final void rule__Artifact__NodeAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14845:1: ( ( ruleNode ) ) + // InternalRos2Parser.g:14846:2: ( ruleNode ) + { + // InternalRos2Parser.g:14846:2: ( ruleNode ) + // InternalRos2Parser.g:14847: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" + // InternalRos2Parser.g:14856:1: rule__Node__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__Node__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14860:1: ( ( ruleRosNames ) ) + // InternalRos2Parser.g:14861:2: ( ruleRosNames ) + { + // InternalRos2Parser.g:14861:2: ( ruleRosNames ) + // InternalRos2Parser.g:14862: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_0_2" + // InternalRos2Parser.g:14871:1: rule__Node__PublisherAssignment_3_0_2 : ( rulePublisher ) ; + public final void rule__Node__PublisherAssignment_3_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14875:1: ( ( rulePublisher ) ) + // InternalRos2Parser.g:14876:2: ( rulePublisher ) + { + // InternalRos2Parser.g:14876:2: ( rulePublisher ) + // InternalRos2Parser.g:14877:3: rulePublisher + { + before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); + pushFollow(FOLLOW_2); + rulePublisher(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__PublisherAssignment_3_0_2" + + + // $ANTLR start "rule__Node__SubscriberAssignment_3_1_2" + // InternalRos2Parser.g:14886:1: rule__Node__SubscriberAssignment_3_1_2 : ( ruleSubscriber ) ; + public final void rule__Node__SubscriberAssignment_3_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14890:1: ( ( ruleSubscriber ) ) + // InternalRos2Parser.g:14891:2: ( ruleSubscriber ) + { + // InternalRos2Parser.g:14891:2: ( ruleSubscriber ) + // InternalRos2Parser.g:14892:3: ruleSubscriber + { + before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); + pushFollow(FOLLOW_2); + ruleSubscriber(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__SubscriberAssignment_3_1_2" + + + // $ANTLR start "rule__Node__ServiceserverAssignment_3_2_2" + // InternalRos2Parser.g:14901:1: rule__Node__ServiceserverAssignment_3_2_2 : ( ruleServiceServer ) ; + public final void rule__Node__ServiceserverAssignment_3_2_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14905:1: ( ( ruleServiceServer ) ) + // InternalRos2Parser.g:14906:2: ( ruleServiceServer ) + { + // InternalRos2Parser.g:14906:2: ( ruleServiceServer ) + // InternalRos2Parser.g:14907:3: ruleServiceServer + { + before(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); + pushFollow(FOLLOW_2); + ruleServiceServer(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__ServiceserverAssignment_3_2_2" + + + // $ANTLR start "rule__Node__ServiceclientAssignment_3_3_2" + // InternalRos2Parser.g:14916:1: rule__Node__ServiceclientAssignment_3_3_2 : ( ruleServiceClient ) ; + public final void rule__Node__ServiceclientAssignment_3_3_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14920:1: ( ( ruleServiceClient ) ) + // InternalRos2Parser.g:14921:2: ( ruleServiceClient ) + { + // InternalRos2Parser.g:14921:2: ( ruleServiceClient ) + // InternalRos2Parser.g:14922:3: ruleServiceClient + { + before(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); + pushFollow(FOLLOW_2); + ruleServiceClient(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__ServiceclientAssignment_3_3_2" + + + // $ANTLR start "rule__Node__ActionserverAssignment_3_4_2" + // InternalRos2Parser.g:14931:1: rule__Node__ActionserverAssignment_3_4_2 : ( ruleActionServer ) ; + public final void rule__Node__ActionserverAssignment_3_4_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14935:1: ( ( ruleActionServer ) ) + // InternalRos2Parser.g:14936:2: ( ruleActionServer ) + { + // InternalRos2Parser.g:14936:2: ( ruleActionServer ) + // InternalRos2Parser.g:14937:3: ruleActionServer + { + before(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); + pushFollow(FOLLOW_2); + ruleActionServer(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__ActionserverAssignment_3_4_2" + + + // $ANTLR start "rule__Node__ActionclientAssignment_3_5_2" + // InternalRos2Parser.g:14946:1: rule__Node__ActionclientAssignment_3_5_2 : ( ruleActionClient ) ; + public final void rule__Node__ActionclientAssignment_3_5_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14950:1: ( ( ruleActionClient ) ) + // InternalRos2Parser.g:14951:2: ( ruleActionClient ) + { + // InternalRos2Parser.g:14951:2: ( ruleActionClient ) + // InternalRos2Parser.g:14952:3: ruleActionClient + { + before(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); + pushFollow(FOLLOW_2); + ruleActionClient(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__ActionclientAssignment_3_5_2" + + + // $ANTLR start "rule__Node__ParameterAssignment_3_6_2" + // InternalRos2Parser.g:14961:1: rule__Node__ParameterAssignment_3_6_2 : ( ruleParameter ) ; + public final void rule__Node__ParameterAssignment_3_6_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14965:1: ( ( ruleParameter ) ) + // InternalRos2Parser.g:14966:2: ( ruleParameter ) + { + // InternalRos2Parser.g:14966:2: ( ruleParameter ) + // InternalRos2Parser.g:14967:3: ruleParameter + { + before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); + pushFollow(FOLLOW_2); + ruleParameter(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__ParameterAssignment_3_6_2" + + + // $ANTLR start "rule__TopicSpec__NameAssignment_2" + // InternalRos2Parser.g:14976:1: rule__TopicSpec__NameAssignment_2 : ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) ; + public final void rule__TopicSpec__NameAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14980:1: ( ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) ) + // InternalRos2Parser.g:14981:2: ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) + { + // InternalRos2Parser.g:14981:2: ( ( rule__TopicSpec__NameAlternatives_2_0 ) ) + // InternalRos2Parser.g:14982:3: ( rule__TopicSpec__NameAlternatives_2_0 ) + { + before(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); + // InternalRos2Parser.g:14983:3: ( rule__TopicSpec__NameAlternatives_2_0 ) + // InternalRos2Parser.g:14983:4: rule__TopicSpec__NameAlternatives_2_0 + { + pushFollow(FOLLOW_2); + rule__TopicSpec__NameAlternatives_2_0(); + + state._fsp--; + + + } + + after(grammarAccess.getTopicSpecAccess().getNameAlternatives_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__NameAssignment_2" + + + // $ANTLR start "rule__TopicSpec__MessageAssignment_5_1" + // InternalRos2Parser.g:14991:1: rule__TopicSpec__MessageAssignment_5_1 : ( ruleMessageDefinition ) ; + public final void rule__TopicSpec__MessageAssignment_5_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:14995:1: ( ( ruleMessageDefinition ) ) + // InternalRos2Parser.g:14996:2: ( ruleMessageDefinition ) + { + // InternalRos2Parser.g:14996:2: ( ruleMessageDefinition ) + // InternalRos2Parser.g:14997:3: ruleMessageDefinition + { + before(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpec__MessageAssignment_5_1" + + + // $ANTLR start "rule__ServiceSpec__NameAssignment_2" + // InternalRos2Parser.g:15006:1: rule__ServiceSpec__NameAssignment_2 : ( ruleEString ) ; + public final void rule__ServiceSpec__NameAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15010:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:15011:2: ( ruleEString ) + { + // InternalRos2Parser.g:15011:2: ( ruleEString ) + // InternalRos2Parser.g:15012:3: ruleEString + { + before(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__NameAssignment_2" + + + // $ANTLR start "rule__ServiceSpec__RequestAssignment_5_1" + // InternalRos2Parser.g:15021:1: rule__ServiceSpec__RequestAssignment_5_1 : ( ruleMessageDefinition ) ; + public final void rule__ServiceSpec__RequestAssignment_5_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15025:1: ( ( ruleMessageDefinition ) ) + // InternalRos2Parser.g:15026:2: ( ruleMessageDefinition ) + { + // InternalRos2Parser.g:15026:2: ( ruleMessageDefinition ) + // InternalRos2Parser.g:15027:3: ruleMessageDefinition + { + before(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__RequestAssignment_5_1" + + + // $ANTLR start "rule__ServiceSpec__ResponseAssignment_7_1" + // InternalRos2Parser.g:15036:1: rule__ServiceSpec__ResponseAssignment_7_1 : ( ruleMessageDefinition ) ; + public final void rule__ServiceSpec__ResponseAssignment_7_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15040:1: ( ( ruleMessageDefinition ) ) + // InternalRos2Parser.g:15041:2: ( ruleMessageDefinition ) + { + // InternalRos2Parser.g:15041:2: ( ruleMessageDefinition ) + // InternalRos2Parser.g:15042:3: ruleMessageDefinition + { + before(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ServiceSpec__ResponseAssignment_7_1" + + + // $ANTLR start "rule__ActionSpec__NameAssignment_2" + // InternalRos2Parser.g:15051:1: rule__ActionSpec__NameAssignment_2 : ( ruleEString ) ; + public final void rule__ActionSpec__NameAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15055:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:15056:2: ( ruleEString ) + { + // InternalRos2Parser.g:15056:2: ( ruleEString ) + // InternalRos2Parser.g:15057:3: ruleEString + { + before(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__NameAssignment_2" + + + // $ANTLR start "rule__ActionSpec__GoalAssignment_5_1" + // InternalRos2Parser.g:15066:1: rule__ActionSpec__GoalAssignment_5_1 : ( ruleMessageDefinition ) ; + public final void rule__ActionSpec__GoalAssignment_5_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15070:1: ( ( ruleMessageDefinition ) ) + // InternalRos2Parser.g:15071:2: ( ruleMessageDefinition ) + { + // InternalRos2Parser.g:15071:2: ( ruleMessageDefinition ) + // InternalRos2Parser.g:15072:3: ruleMessageDefinition + { + before(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__GoalAssignment_5_1" + + + // $ANTLR start "rule__ActionSpec__ResultAssignment_7_1" + // InternalRos2Parser.g:15081:1: rule__ActionSpec__ResultAssignment_7_1 : ( ruleMessageDefinition ) ; + public final void rule__ActionSpec__ResultAssignment_7_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15085:1: ( ( ruleMessageDefinition ) ) + // InternalRos2Parser.g:15086:2: ( ruleMessageDefinition ) + { + // InternalRos2Parser.g:15086:2: ( ruleMessageDefinition ) + // InternalRos2Parser.g:15087:3: ruleMessageDefinition + { + before(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__ResultAssignment_7_1" + + + // $ANTLR start "rule__ActionSpec__FeedbackAssignment_9_1" + // InternalRos2Parser.g:15096:1: rule__ActionSpec__FeedbackAssignment_9_1 : ( ruleMessageDefinition ) ; + public final void rule__ActionSpec__FeedbackAssignment_9_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15100:1: ( ( ruleMessageDefinition ) ) + // InternalRos2Parser.g:15101:2: ( ruleMessageDefinition ) + { + // InternalRos2Parser.g:15101:2: ( ruleMessageDefinition ) + // InternalRos2Parser.g:15102:3: ruleMessageDefinition + { + before(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); + pushFollow(FOLLOW_2); + ruleMessageDefinition(); + + state._fsp--; + + after(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ActionSpec__FeedbackAssignment_9_1" + + + // $ANTLR start "rule__MessageDefinition__MessagePartAssignment_1" + // InternalRos2Parser.g:15111:1: rule__MessageDefinition__MessagePartAssignment_1 : ( ruleMessagePart ) ; + public final void rule__MessageDefinition__MessagePartAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15115:1: ( ( ruleMessagePart ) ) + // InternalRos2Parser.g:15116:2: ( ruleMessagePart ) + { + // InternalRos2Parser.g:15116:2: ( ruleMessagePart ) + // InternalRos2Parser.g:15117:3: ruleMessagePart + { + before(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleMessagePart(); + + state._fsp--; + + after(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessageDefinition__MessagePartAssignment_1" + + + // $ANTLR start "rule__PackageDependency__PackageAssignment" + // InternalRos2Parser.g:15126:1: rule__PackageDependency__PackageAssignment : ( ( ruleEString ) ) ; + public final void rule__PackageDependency__PackageAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15130:1: ( ( ( ruleEString ) ) ) + // InternalRos2Parser.g:15131:2: ( ( ruleEString ) ) + { + // InternalRos2Parser.g:15131:2: ( ( ruleEString ) ) + // InternalRos2Parser.g:15132:3: ( ruleEString ) + { + before(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); + // InternalRos2Parser.g:15133:3: ( ruleEString ) + // InternalRos2Parser.g:15134: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" + // InternalRos2Parser.g:15145:1: rule__ExternalDependency__NameAssignment_2 : ( ruleEString ) ; + public final void rule__ExternalDependency__NameAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15149:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:15150:2: ( ruleEString ) + { + // InternalRos2Parser.g:15150:2: ( ruleEString ) + // InternalRos2Parser.g:15151: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" + + + // $ANTLR start "rule__GlobalNamespace__PartsAssignment_2_1" + // InternalRos2Parser.g:15160:1: rule__GlobalNamespace__PartsAssignment_2_1 : ( ruleGraphName ) ; + public final void rule__GlobalNamespace__PartsAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15164:1: ( ( ruleGraphName ) ) + // InternalRos2Parser.g:15165:2: ( ruleGraphName ) + { + // InternalRos2Parser.g:15165:2: ( ruleGraphName ) + // InternalRos2Parser.g:15166:3: ruleGraphName + { + before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__PartsAssignment_2_1" + + + // $ANTLR start "rule__GlobalNamespace__PartsAssignment_2_2_1" + // InternalRos2Parser.g:15175:1: rule__GlobalNamespace__PartsAssignment_2_2_1 : ( ruleGraphName ) ; + public final void rule__GlobalNamespace__PartsAssignment_2_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15179:1: ( ( ruleGraphName ) ) + // InternalRos2Parser.g:15180:2: ( ruleGraphName ) + { + // InternalRos2Parser.g:15180:2: ( ruleGraphName ) + // InternalRos2Parser.g:15181:3: ruleGraphName + { + before(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalNamespace__PartsAssignment_2_2_1" + + + // $ANTLR start "rule__RelativeNamespace_Impl__PartsAssignment_2_1" + // InternalRos2Parser.g:15190:1: rule__RelativeNamespace_Impl__PartsAssignment_2_1 : ( ruleGraphName ) ; + public final void rule__RelativeNamespace_Impl__PartsAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15194:1: ( ( ruleGraphName ) ) + // InternalRos2Parser.g:15195:2: ( ruleGraphName ) + { + // InternalRos2Parser.g:15195:2: ( ruleGraphName ) + // InternalRos2Parser.g:15196:3: ruleGraphName + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__PartsAssignment_2_1" + + + // $ANTLR start "rule__RelativeNamespace_Impl__PartsAssignment_2_2_1" + // InternalRos2Parser.g:15205:1: rule__RelativeNamespace_Impl__PartsAssignment_2_2_1 : ( ruleGraphName ) ; + public final void rule__RelativeNamespace_Impl__PartsAssignment_2_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15209:1: ( ( ruleGraphName ) ) + // InternalRos2Parser.g:15210:2: ( ruleGraphName ) + { + // InternalRos2Parser.g:15210:2: ( ruleGraphName ) + // InternalRos2Parser.g:15211:3: ruleGraphName + { + before(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelativeNamespace_Impl__PartsAssignment_2_2_1" + + + // $ANTLR start "rule__PrivateNamespace__PartsAssignment_2_1" + // InternalRos2Parser.g:15220:1: rule__PrivateNamespace__PartsAssignment_2_1 : ( ruleGraphName ) ; + public final void rule__PrivateNamespace__PartsAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15224:1: ( ( ruleGraphName ) ) + // InternalRos2Parser.g:15225:2: ( ruleGraphName ) + { + // InternalRos2Parser.g:15225:2: ( ruleGraphName ) + // InternalRos2Parser.g:15226:3: ruleGraphName + { + before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__PartsAssignment_2_1" + + + // $ANTLR start "rule__PrivateNamespace__PartsAssignment_2_2_1" + // InternalRos2Parser.g:15235:1: rule__PrivateNamespace__PartsAssignment_2_2_1 : ( ruleGraphName ) ; + public final void rule__PrivateNamespace__PartsAssignment_2_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15239:1: ( ( ruleGraphName ) ) + // InternalRos2Parser.g:15240:2: ( ruleGraphName ) + { + // InternalRos2Parser.g:15240:2: ( ruleGraphName ) + // InternalRos2Parser.g:15241:3: ruleGraphName + { + before(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + pushFollow(FOLLOW_2); + ruleGraphName(); + + state._fsp--; + + after(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PrivateNamespace__PartsAssignment_2_2_1" + + + // $ANTLR start "rule__ParameterListType__SequenceAssignment_3" + // InternalRos2Parser.g:15250:1: rule__ParameterListType__SequenceAssignment_3 : ( ruleParameterType ) ; + public final void rule__ParameterListType__SequenceAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15254:1: ( ( ruleParameterType ) ) + // InternalRos2Parser.g:15255:2: ( ruleParameterType ) + { + // InternalRos2Parser.g:15255:2: ( ruleParameterType ) + // InternalRos2Parser.g:15256:3: ruleParameterType + { + before(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); + pushFollow(FOLLOW_2); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__SequenceAssignment_3" + + + // $ANTLR start "rule__ParameterListType__SequenceAssignment_4_1" + // InternalRos2Parser.g:15265:1: rule__ParameterListType__SequenceAssignment_4_1 : ( ruleParameterType ) ; + public final void rule__ParameterListType__SequenceAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15269:1: ( ( ruleParameterType ) ) + // InternalRos2Parser.g:15270:2: ( ruleParameterType ) + { + // InternalRos2Parser.g:15270:2: ( ruleParameterType ) + // InternalRos2Parser.g:15271:3: ruleParameterType + { + before(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); + pushFollow(FOLLOW_2); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterListType__SequenceAssignment_4_1" + + + // $ANTLR start "rule__ParameterStructType__ParameterstructypetmemberAssignment_3" + // InternalRos2Parser.g:15280:1: rule__ParameterStructType__ParameterstructypetmemberAssignment_3 : ( ruleParameterStructTypeMember ) ; + public final void rule__ParameterStructType__ParameterstructypetmemberAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15284:1: ( ( ruleParameterStructTypeMember ) ) + // InternalRos2Parser.g:15285:2: ( ruleParameterStructTypeMember ) + { + // InternalRos2Parser.g:15285:2: ( ruleParameterStructTypeMember ) + // InternalRos2Parser.g:15286:3: ruleParameterStructTypeMember + { + before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); + pushFollow(FOLLOW_2); + ruleParameterStructTypeMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__ParameterstructypetmemberAssignment_3" + + + // $ANTLR start "rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1" + // InternalRos2Parser.g:15295:1: rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1 : ( ruleParameterStructTypeMember ) ; + public final void rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15299:1: ( ( ruleParameterStructTypeMember ) ) + // InternalRos2Parser.g:15300:2: ( ruleParameterStructTypeMember ) + { + // InternalRos2Parser.g:15300:2: ( ruleParameterStructTypeMember ) + // InternalRos2Parser.g:15301:3: ruleParameterStructTypeMember + { + before(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); + pushFollow(FOLLOW_2); + ruleParameterStructTypeMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructType__ParameterstructypetmemberAssignment_4_1" + + + // $ANTLR start "rule__ParameterIntegerType__DefaultAssignment_2_1" + // InternalRos2Parser.g:15310:1: rule__ParameterIntegerType__DefaultAssignment_2_1 : ( ruleParameterInteger ) ; + public final void rule__ParameterIntegerType__DefaultAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15314:1: ( ( ruleParameterInteger ) ) + // InternalRos2Parser.g:15315:2: ( ruleParameterInteger ) + { + // InternalRos2Parser.g:15315:2: ( ruleParameterInteger ) + // InternalRos2Parser.g:15316:3: ruleParameterInteger + { + before(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleParameterInteger(); + + state._fsp--; + + after(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterIntegerType__DefaultAssignment_2_1" + + + // $ANTLR start "rule__ParameterStringType__DefaultAssignment_2_1" + // InternalRos2Parser.g:15325:1: rule__ParameterStringType__DefaultAssignment_2_1 : ( ruleParameterString ) ; + public final void rule__ParameterStringType__DefaultAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15329:1: ( ( ruleParameterString ) ) + // InternalRos2Parser.g:15330:2: ( ruleParameterString ) + { + // InternalRos2Parser.g:15330:2: ( ruleParameterString ) + // InternalRos2Parser.g:15331:3: ruleParameterString + { + before(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleParameterString(); + + state._fsp--; + + after(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStringType__DefaultAssignment_2_1" + + + // $ANTLR start "rule__ParameterDoubleType__DefaultAssignment_2_1" + // InternalRos2Parser.g:15340:1: rule__ParameterDoubleType__DefaultAssignment_2_1 : ( ruleParameterDouble ) ; + public final void rule__ParameterDoubleType__DefaultAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15344:1: ( ( ruleParameterDouble ) ) + // InternalRos2Parser.g:15345:2: ( ruleParameterDouble ) + { + // InternalRos2Parser.g:15345:2: ( ruleParameterDouble ) + // InternalRos2Parser.g:15346:3: ruleParameterDouble + { + before(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleParameterDouble(); + + state._fsp--; + + after(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDoubleType__DefaultAssignment_2_1" + + + // $ANTLR start "rule__ParameterBooleanType__DefaultAssignment_2_1" + // InternalRos2Parser.g:15355:1: rule__ParameterBooleanType__DefaultAssignment_2_1 : ( ruleParameterBoolean ) ; + public final void rule__ParameterBooleanType__DefaultAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15359:1: ( ( ruleParameterBoolean ) ) + // InternalRos2Parser.g:15360:2: ( ruleParameterBoolean ) + { + // InternalRos2Parser.g:15360:2: ( ruleParameterBoolean ) + // InternalRos2Parser.g:15361:3: ruleParameterBoolean + { + before(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleParameterBoolean(); + + state._fsp--; + + after(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBooleanType__DefaultAssignment_2_1" + + + // $ANTLR start "rule__ParameterBase64Type__DefaultAssignment_2_1" + // InternalRos2Parser.g:15370:1: rule__ParameterBase64Type__DefaultAssignment_2_1 : ( ruleParameterBase64 ) ; + public final void rule__ParameterBase64Type__DefaultAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15374:1: ( ( ruleParameterBase64 ) ) + // InternalRos2Parser.g:15375:2: ( ruleParameterBase64 ) + { + // InternalRos2Parser.g:15375:2: ( ruleParameterBase64 ) + // InternalRos2Parser.g:15376:3: ruleParameterBase64 + { + before(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleParameterBase64(); + + state._fsp--; + + after(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64Type__DefaultAssignment_2_1" + + + // $ANTLR start "rule__ParameterArrayType__TypeAssignment_3" + // InternalRos2Parser.g:15385:1: rule__ParameterArrayType__TypeAssignment_3 : ( ruleParameterType ) ; + public final void rule__ParameterArrayType__TypeAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15389:1: ( ( ruleParameterType ) ) + // InternalRos2Parser.g:15390:2: ( ruleParameterType ) + { + // InternalRos2Parser.g:15390:2: ( ruleParameterType ) + // InternalRos2Parser.g:15391:3: ruleParameterType + { + before(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); + pushFollow(FOLLOW_2); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__TypeAssignment_3" + + + // $ANTLR start "rule__ParameterArrayType__DefaultAssignment_4_1" + // InternalRos2Parser.g:15400:1: rule__ParameterArrayType__DefaultAssignment_4_1 : ( ruleParameterList ) ; + public final void rule__ParameterArrayType__DefaultAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15404:1: ( ( ruleParameterList ) ) + // InternalRos2Parser.g:15405:2: ( ruleParameterList ) + { + // InternalRos2Parser.g:15405:2: ( ruleParameterList ) + // InternalRos2Parser.g:15406:3: ruleParameterList + { + before(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); + pushFollow(FOLLOW_2); + ruleParameterList(); + + state._fsp--; + + after(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterArrayType__DefaultAssignment_4_1" + + + // $ANTLR start "rule__ParameterList__ValueAssignment_2" + // InternalRos2Parser.g:15415:1: rule__ParameterList__ValueAssignment_2 : ( ruleParameterValue ) ; + public final void rule__ParameterList__ValueAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15419:1: ( ( ruleParameterValue ) ) + // InternalRos2Parser.g:15420:2: ( ruleParameterValue ) + { + // InternalRos2Parser.g:15420:2: ( ruleParameterValue ) + // InternalRos2Parser.g:15421:3: ruleParameterValue + { + before(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); + pushFollow(FOLLOW_2); + ruleParameterValue(); + + state._fsp--; + + after(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__ValueAssignment_2" + + + // $ANTLR start "rule__ParameterList__ValueAssignment_3_1" + // InternalRos2Parser.g:15430:1: rule__ParameterList__ValueAssignment_3_1 : ( ruleParameterValue ) ; + public final void rule__ParameterList__ValueAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15434:1: ( ( ruleParameterValue ) ) + // InternalRos2Parser.g:15435:2: ( ruleParameterValue ) + { + // InternalRos2Parser.g:15435:2: ( ruleParameterValue ) + // InternalRos2Parser.g:15436:3: ruleParameterValue + { + before(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); + pushFollow(FOLLOW_2); + ruleParameterValue(); + + state._fsp--; + + after(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterList__ValueAssignment_3_1" + + + // $ANTLR start "rule__ParameterAny__ValueAssignment_2_1" + // InternalRos2Parser.g:15445:1: rule__ParameterAny__ValueAssignment_2_1 : ( ruleEString ) ; + public final void rule__ParameterAny__ValueAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15449:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:15450:2: ( ruleEString ) + { + // InternalRos2Parser.g:15450:2: ( ruleEString ) + // InternalRos2Parser.g:15451:3: ruleEString + { + before(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterAny__ValueAssignment_2_1" + + + // $ANTLR start "rule__ParameterString__ValueAssignment" + // InternalRos2Parser.g:15460:1: rule__ParameterString__ValueAssignment : ( ruleEString ) ; + public final void rule__ParameterString__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15464:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:15465:2: ( ruleEString ) + { + // InternalRos2Parser.g:15465:2: ( ruleEString ) + // InternalRos2Parser.g:15466:3: ruleEString + { + before(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterString__ValueAssignment" + + + // $ANTLR start "rule__ParameterBase64__ValueAssignment" + // InternalRos2Parser.g:15475:1: rule__ParameterBase64__ValueAssignment : ( ruleBase64Binary ) ; + public final void rule__ParameterBase64__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15479:1: ( ( ruleBase64Binary ) ) + // InternalRos2Parser.g:15480:2: ( ruleBase64Binary ) + { + // InternalRos2Parser.g:15480:2: ( ruleBase64Binary ) + // InternalRos2Parser.g:15481:3: ruleBase64Binary + { + before(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleBase64Binary(); + + state._fsp--; + + after(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBase64__ValueAssignment" + + + // $ANTLR start "rule__ParameterInteger__ValueAssignment" + // InternalRos2Parser.g:15490:1: rule__ParameterInteger__ValueAssignment : ( ruleInteger0 ) ; + public final void rule__ParameterInteger__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15494:1: ( ( ruleInteger0 ) ) + // InternalRos2Parser.g:15495:2: ( ruleInteger0 ) + { + // InternalRos2Parser.g:15495:2: ( ruleInteger0 ) + // InternalRos2Parser.g:15496:3: ruleInteger0 + { + before(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleInteger0(); + + state._fsp--; + + after(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterInteger__ValueAssignment" + + + // $ANTLR start "rule__ParameterDouble__ValueAssignment" + // InternalRos2Parser.g:15505:1: rule__ParameterDouble__ValueAssignment : ( ruleDouble0 ) ; + public final void rule__ParameterDouble__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15509:1: ( ( ruleDouble0 ) ) + // InternalRos2Parser.g:15510:2: ( ruleDouble0 ) + { + // InternalRos2Parser.g:15510:2: ( ruleDouble0 ) + // InternalRos2Parser.g:15511:3: ruleDouble0 + { + before(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleDouble0(); + + state._fsp--; + + after(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDouble__ValueAssignment" + + + // $ANTLR start "rule__ParameterBoolean__ValueAssignment" + // InternalRos2Parser.g:15520:1: rule__ParameterBoolean__ValueAssignment : ( ruleboolean0 ) ; + public final void rule__ParameterBoolean__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15524:1: ( ( ruleboolean0 ) ) + // InternalRos2Parser.g:15525:2: ( ruleboolean0 ) + { + // InternalRos2Parser.g:15525:2: ( ruleboolean0 ) + // InternalRos2Parser.g:15526:3: ruleboolean0 + { + before(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleboolean0(); + + state._fsp--; + + after(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterBoolean__ValueAssignment" + + + // $ANTLR start "rule__ParameterStruct__ValueAssignment_1_1" + // InternalRos2Parser.g:15535:1: rule__ParameterStruct__ValueAssignment_1_1 : ( ruleParameterStructMember ) ; + public final void rule__ParameterStruct__ValueAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15539:1: ( ( ruleParameterStructMember ) ) + // InternalRos2Parser.g:15540:2: ( ruleParameterStructMember ) + { + // InternalRos2Parser.g:15540:2: ( ruleParameterStructMember ) + // InternalRos2Parser.g:15541:3: ruleParameterStructMember + { + before(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); + pushFollow(FOLLOW_2); + ruleParameterStructMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__ValueAssignment_1_1" + + + // $ANTLR start "rule__ParameterStruct__ValueAssignment_1_2_2" + // InternalRos2Parser.g:15550:1: rule__ParameterStruct__ValueAssignment_1_2_2 : ( ruleParameterStructMember ) ; + public final void rule__ParameterStruct__ValueAssignment_1_2_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15554:1: ( ( ruleParameterStructMember ) ) + // InternalRos2Parser.g:15555:2: ( ruleParameterStructMember ) + { + // InternalRos2Parser.g:15555:2: ( ruleParameterStructMember ) + // InternalRos2Parser.g:15556:3: ruleParameterStructMember + { + before(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); + pushFollow(FOLLOW_2); + ruleParameterStructMember(); + + state._fsp--; + + after(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStruct__ValueAssignment_1_2_2" + + + // $ANTLR start "rule__ParameterDate__ValueAssignment" + // InternalRos2Parser.g:15565:1: rule__ParameterDate__ValueAssignment : ( ruleDateTime0 ) ; + public final void rule__ParameterDate__ValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15569:1: ( ( ruleDateTime0 ) ) + // InternalRos2Parser.g:15570:2: ( ruleDateTime0 ) + { + // InternalRos2Parser.g:15570:2: ( ruleDateTime0 ) + // InternalRos2Parser.g:15571:3: ruleDateTime0 + { + before(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleDateTime0(); + + state._fsp--; + + after(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterDate__ValueAssignment" + + + // $ANTLR start "rule__ParameterStructMember__NameAssignment_1" + // InternalRos2Parser.g:15580:1: rule__ParameterStructMember__NameAssignment_1 : ( ruleEString ) ; + public final void rule__ParameterStructMember__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15584:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:15585:2: ( ruleEString ) + { + // InternalRos2Parser.g:15585:2: ( ruleEString ) + // InternalRos2Parser.g:15586:3: ruleEString + { + before(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__NameAssignment_1" + + + // $ANTLR start "rule__ParameterStructMember__ValueAssignment_4" + // InternalRos2Parser.g:15595:1: rule__ParameterStructMember__ValueAssignment_4 : ( ruleParameterValue ) ; + public final void rule__ParameterStructMember__ValueAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15599:1: ( ( ruleParameterValue ) ) + // InternalRos2Parser.g:15600:2: ( ruleParameterValue ) + { + // InternalRos2Parser.g:15600:2: ( ruleParameterValue ) + // InternalRos2Parser.g:15601:3: ruleParameterValue + { + before(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); + pushFollow(FOLLOW_2); + ruleParameterValue(); + + state._fsp--; + + after(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructMember__ValueAssignment_4" + + + // $ANTLR start "rule__ParameterStructTypeMember__NameAssignment_0" + // InternalRos2Parser.g:15610:1: rule__ParameterStructTypeMember__NameAssignment_0 : ( ruleEString ) ; + public final void rule__ParameterStructTypeMember__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15614:1: ( ( ruleEString ) ) + // InternalRos2Parser.g:15615:2: ( ruleEString ) + { + // InternalRos2Parser.g:15615:2: ( ruleEString ) + // InternalRos2Parser.g:15616:3: ruleEString + { + before(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__NameAssignment_0" + + + // $ANTLR start "rule__ParameterStructTypeMember__TypeAssignment_1" + // InternalRos2Parser.g:15625:1: rule__ParameterStructTypeMember__TypeAssignment_1 : ( ruleParameterType ) ; + public final void rule__ParameterStructTypeMember__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15629:1: ( ( ruleParameterType ) ) + // InternalRos2Parser.g:15630:2: ( ruleParameterType ) + { + // InternalRos2Parser.g:15630:2: ( ruleParameterType ) + // InternalRos2Parser.g:15631:3: ruleParameterType + { + before(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleParameterType(); + + state._fsp--; + + after(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParameterStructTypeMember__TypeAssignment_1" + + + // $ANTLR start "rule__MessagePart__TypeAssignment_0" + // InternalRos2Parser.g:15640:1: rule__MessagePart__TypeAssignment_0 : ( ruleAbstractType ) ; + public final void rule__MessagePart__TypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15644:1: ( ( ruleAbstractType ) ) + // InternalRos2Parser.g:15645:2: ( ruleAbstractType ) + { + // InternalRos2Parser.g:15645:2: ( ruleAbstractType ) + // InternalRos2Parser.g:15646:3: ruleAbstractType + { + before(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); + pushFollow(FOLLOW_2); + ruleAbstractType(); + + state._fsp--; + + after(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__TypeAssignment_0" + + + // $ANTLR start "rule__MessagePart__DataAssignment_1" + // InternalRos2Parser.g:15655:1: rule__MessagePart__DataAssignment_1 : ( ( rule__MessagePart__DataAlternatives_1_0 ) ) ; + public final void rule__MessagePart__DataAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15659:1: ( ( ( rule__MessagePart__DataAlternatives_1_0 ) ) ) + // InternalRos2Parser.g:15660:2: ( ( rule__MessagePart__DataAlternatives_1_0 ) ) + { + // InternalRos2Parser.g:15660:2: ( ( rule__MessagePart__DataAlternatives_1_0 ) ) + // InternalRos2Parser.g:15661:3: ( rule__MessagePart__DataAlternatives_1_0 ) + { + before(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0()); + // InternalRos2Parser.g:15662:3: ( rule__MessagePart__DataAlternatives_1_0 ) + // InternalRos2Parser.g:15662:4: rule__MessagePart__DataAlternatives_1_0 + { + pushFollow(FOLLOW_2); + rule__MessagePart__DataAlternatives_1_0(); + + state._fsp--; + + + } + + after(grammarAccess.getMessagePartAccess().getDataAlternatives_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MessagePart__DataAssignment_1" + + + // $ANTLR start "rule__TopicSpecRef__TopicSpecAssignment" + // InternalRos2Parser.g:15670:1: rule__TopicSpecRef__TopicSpecAssignment : ( ( ruleEString ) ) ; + public final void rule__TopicSpecRef__TopicSpecAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15674:1: ( ( ( ruleEString ) ) ) + // InternalRos2Parser.g:15675:2: ( ( ruleEString ) ) + { + // InternalRos2Parser.g:15675:2: ( ( ruleEString ) ) + // InternalRos2Parser.g:15676:3: ( ruleEString ) + { + before(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); + // InternalRos2Parser.g:15677:3: ( ruleEString ) + // InternalRos2Parser.g:15678:4: ruleEString + { + before(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_1()); + + } + + after(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TopicSpecRef__TopicSpecAssignment" + + + // $ANTLR start "rule__ArrayTopicSpecRef__TopicSpecAssignment_0" + // InternalRos2Parser.g:15689:1: rule__ArrayTopicSpecRef__TopicSpecAssignment_0 : ( ( ruleEString ) ) ; + public final void rule__ArrayTopicSpecRef__TopicSpecAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos2Parser.g:15693:1: ( ( ( ruleEString ) ) ) + // InternalRos2Parser.g:15694:2: ( ( ruleEString ) ) + { + // InternalRos2Parser.g:15694:2: ( ( ruleEString ) ) + // InternalRos2Parser.g:15695:3: ( ruleEString ) + { + before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); + // InternalRos2Parser.g:15696:3: ( ruleEString ) + // InternalRos2Parser.g:15697:4: ruleEString + { + before(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecEStringParserRuleCall_0_0_1()); + + } + + after(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayTopicSpecRef__TopicSpecAssignment_0" + + // Delegated rules + + + protected DFA15 dfa15 = new DFA15(this); + static final String dfa_1s = "\42\uffff"; + static final String dfa_2s = "\36\uffff\2\40\2\uffff"; + static final String dfa_3s = "\1\36\35\uffff\2\42\2\uffff"; + static final String dfa_4s = "\1\157\35\uffff\2\175\2\uffff"; + static final String dfa_5s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\2\uffff\1\36\1\37"; + static final String dfa_6s = "\42\uffff}>"; + static final String[] dfa_7s = { + "\1\32\1\33\2\uffff\1\17\7\uffff\1\34\1\25\1\27\1\31\5\uffff\1\12\1\13\1\24\1\26\1\30\3\uffff\1\23\3\uffff\1\20\3\uffff\1\21\1\35\1\uffff\1\22\2\uffff\1\14\1\5\1\7\1\11\1\uffff\1\4\1\6\1\10\2\uffff\1\3\3\uffff\1\1\1\15\1\uffff\1\2\5\uffff\1\16\14\uffff\1\37\1\uffff\1\36", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\2\40\24\uffff\1\40\1\uffff\1\40\7\uffff\1\40\4\uffff\1\40\14\uffff\1\40\4\uffff\1\40\2\uffff\1\40\3\uffff\2\40\2\uffff\1\41\10\uffff\1\40\1\uffff\1\40\15\uffff\1\40", + "\2\40\24\uffff\1\40\1\uffff\1\40\7\uffff\1\40\4\uffff\1\40\14\uffff\1\40\4\uffff\1\40\2\uffff\1\40\3\uffff\2\40\2\uffff\1\41\10\uffff\1\40\1\uffff\1\40\15\uffff\1\40", + "", + "" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s); + static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s); + + class DFA15 extends DFA { + + public DFA15(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 15; + this.eot = dfa_1; + this.eof = dfa_2; + this.min = dfa_3; + this.max = dfa_4; + this.accept = dfa_5; + this.special = dfa_6; + this.transition = dfa_7; + } + public String getDescription() { + return "2788:1: rule__AbstractType__Alternatives : ( ( rulebool ) | ( ruleint8 ) | ( ruleuint8 ) | ( ruleint16 ) | ( ruleuint16 ) | ( ruleint32 ) | ( ruleuint32 ) | ( ruleint64 ) | ( ruleuint64 ) | ( rulefloat32 ) | ( rulefloat64 ) | ( rulestring0 ) | ( rulebyte ) | ( ruletime ) | ( ruleduration ) | ( ruleHeader ) | ( ruleboolArray ) | ( ruleint8Array ) | ( ruleuint8Array ) | ( ruleint16Array ) | ( ruleuint16Array ) | ( ruleint32Array ) | ( ruleuint32Array ) | ( ruleint64Array ) | ( ruleuint64Array ) | ( rulefloat32Array ) | ( rulefloat64Array ) | ( rulestring0Array ) | ( rulebyteArray ) | ( ruleTopicSpecRef ) | ( ruleArrayTopicSpecRef ) );"; + } + } + + + 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[]{0x0000000000000000L,0x0000600020000000L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000000L,0x0000004000000000L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000004024000L,0x0000080000000000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000000L,0x0000A00000000000L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000000L,0x0000680020000000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000002L,0x0000600020000000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000000L,0x0000008000000000L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000020L,0x0000A00000000000L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0000012000000000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000002L,0x0000002000000000L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000009000840000L,0x0000000000000020L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000008488000L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000002100000000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000010000200000L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000400000000200L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000000000L,0x0000080840000000L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x00000000000001C0L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000000000L,0x0000080000000000L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x7001800000000000L,0x0000000000400003L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000024000L,0x0000080000000100L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0002000000000000L,0x0000080088000000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0002000000000002L,0x0000000088000000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000000000000L,0x0000080000020000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000003103C00L,0x0000080000000000L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000003103C02L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000000000000L,0x0000A80000000000L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000002L,0x0000A00000000000L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x8000000000000000L,0x0000A00000000001L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000004000000000L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000000000L,0x00000C0000000000L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x88F83C04C0000000L,0x0000A0010589DE58L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000020000000000L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000200000000L,0x0000040000000000L}); + public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0002000000000000L,0x0000000088000000L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0200000000000000L,0x0000040000000000L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000020000000L,0x0000040000000000L}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x88F83C04C0000002L,0x0000A0010589DE58L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000000100L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000010000000L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000040L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); + public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); + public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0001000000000000L}); + public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0004000000000000L}); + public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x4000000000000000L}); + public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); + public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000800000000000L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000000L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x2000000000000000L}); + public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L}); + public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0004000000000000L,0x0000080000000000L}); + public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000000L,0x003CA08000000000L}); + public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000010000L}); + public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); + public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000000000000000L,0x0000010000000000L}); + public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0500000C00000000L,0x2000A00312100084L}); + public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L}); + public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); + public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); + public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); + public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); + public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); + public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L}); + public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); + public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); + public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0008000000000000L}); + public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0010000000000000L}); + public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); + public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); + public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L}); + public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000400000000L}); + public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); + public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); + public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0800000000000000L}); + public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0020000000000000L}); + public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000080000000000L}); + public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0040000000000000L}); + public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000100000000000L}); + public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0080000000000000L}); + public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0000200000000000L}); + public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000000040000000L}); + public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0000000080000000L}); + public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x0000040000000000L}); + public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); + public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x8000000000000000L}); + public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); + public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000009000840002L,0x0000000000000020L}); + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/internal/InternalRos2Parser.tokens b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/internal/InternalRos2Parser.tokens new file mode 100644 index 000000000..2c7871a75 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/internal/InternalRos2Parser.tokens @@ -0,0 +1,125 @@ +','=101 +':'=102 +'Any'=98 +'Array:'=60 +'Base64'=61 +'Boolean'=47 +'Date'=85 +'Double'=62 +'ExternalDependency'=5 +'GlobalNamespace'=8 +'GraphName'=28 +'Header'=63 +'Integer'=48 +'List'=86 +'ParameterAny'=16 +'ParameterStructMember'=4 +'PrivateNamespace'=7 +'RelativeNamespace'=6 +'String'=64 +'Struct'=65 +'['=103 +'[]'=100 +']'=104 +'action'=66 +'action:'=49 +'actionclient:'=12 +'actionserver:'=13 +'artifacts:'=26 +'best_effort'=21 +'bool'=87 +'bool[]'=67 +'byte'=88 +'byte[]'=68 +'default'=50 +'default_qos'=22 +'dependencies:'=14 +'depth:'=69 +'durability:'=23 +'duration'=34 +'feedback'=35 +'feedback:'=29 +'float32'=51 +'float32[]'=30 +'float64'=52 +'float64[]'=31 +'fromGitRepo:'=17 +'goal'=89 +'goal:'=77 +'history:'=36 +'int16'=78 +'int16[]'=53 +'int32'=79 +'int32[]'=54 +'int64'=80 +'int64[]'=55 +'int8'=90 +'int8[]'=70 +'keep_all'=37 +'keep_last'=32 +'message'=56 +'message:'=38 +'msg:'=91 +'name'=92 +'node'=93 +'node:'=81 +'ns:'=99 +'parameter_qos'=15 +'parameters:'=24 +'profile:'=39 +'publishers:'=25 +'qos:'=94 +'reliability:'=18 +'reliable'=40 +'request:'=41 +'response:'=33 +'result'=71 +'result:'=57 +'sensor_qos'=27 +'service'=58 +'serviceclient:'=10 +'services_qos'=19 +'serviceserver:'=11 +'specs:'=72 +'srv:'=95 +'string'=73 +'string[]'=42 +'subscribers:'=20 +'time'=96 +'transient_local'=9 +'type'=97 +'type:'=82 +'uint16'=74 +'uint16[]'=43 +'uint32'=75 +'uint32[]'=44 +'uint64'=76 +'uint64[]'=45 +'uint8'=83 +'uint8[]'=59 +'value'=84 +'volatile'=46 +'}'=105 +RULE_ANY_OTHER=128 +RULE_BEGIN=106 +RULE_BINARY=114 +RULE_BOOLEAN=115 +RULE_DATE_TIME=123 +RULE_DAY=118 +RULE_DECINT=116 +RULE_DIGIT=113 +RULE_DOUBLE=117 +RULE_END=107 +RULE_HOUR=121 +RULE_ID=109 +RULE_INT=124 +RULE_MESSAGE_ASIGMENT=125 +RULE_MIN_SEC=122 +RULE_ML_COMMENT=126 +RULE_MONTH=119 +RULE_ROS_CONVENTION_A=110 +RULE_ROS_CONVENTION_PARAM=112 +RULE_SL_COMMENT=108 +RULE_STRING=111 +RULE_WS=127 +RULE_YEAR=120 diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/lexer/InternalRos2Lexer.g b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/lexer/InternalRos2Lexer.g new file mode 100644 index 000000000..d3ca9aae4 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/lexer/InternalRos2Lexer.g @@ -0,0 +1,262 @@ +/* + * generated by Xtext 2.25.0 + */ +lexer grammar InternalRos2Lexer; + +@header { +package de.fraunhofer.ipa.ros2.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; +} + +ParameterStructMember : 'ParameterStructMember'; + +ExternalDependency : 'ExternalDependency'; + +RelativeNamespace : 'RelativeNamespace'; + +PrivateNamespace : 'PrivateNamespace'; + +GlobalNamespace : 'GlobalNamespace'; + +Transient_local : 'transient_local'; + +Serviceclient : 'serviceclient:'; + +Serviceserver : 'serviceserver:'; + +Actionclient : 'actionclient:'; + +Actionserver : 'actionserver:'; + +Dependencies : 'dependencies:'; + +Parameter_qos : 'parameter_qos'; + +ParameterAny : 'ParameterAny'; + +FromGitRepo : 'fromGitRepo:'; + +Reliability : 'reliability:'; + +Services_qos : 'services_qos'; + +Subscribers : 'subscribers:'; + +Best_effort : 'best_effort'; + +Default_qos : 'default_qos'; + +Durability : 'durability:'; + +Parameters : 'parameters:'; + +Publishers : 'publishers:'; + +Artifacts : 'artifacts:'; + +Sensor_qos : 'sensor_qos'; + +GraphName : 'GraphName'; + +Feedback_1 : 'feedback:'; + +Float32_1 : 'float32[]'; + +Float64_1 : 'float64[]'; + +Keep_last : 'keep_last'; + +Response : 'response:'; + +Duration : 'duration'; + +Feedback : 'feedback'; + +History : 'history:'; + +Keep_all : 'keep_all'; + +Message_1 : 'message:'; + +Profile : 'profile:'; + +Reliable : 'reliable'; + +Request : 'request:'; + +String_2 : 'string[]'; + +Uint16_1 : 'uint16[]'; + +Uint32_1 : 'uint32[]'; + +Uint64_1 : 'uint64[]'; + +Volatile : 'volatile'; + +Boolean : 'Boolean'; + +Integer : 'Integer'; + +Action_1 : 'action:'; + +Default : 'default'; + +Float32 : 'float32'; + +Float64 : 'float64'; + +Int16_1 : 'int16[]'; + +Int32_1 : 'int32[]'; + +Int64_1 : 'int64[]'; + +Message : 'message'; + +Result_1 : 'result:'; + +Service : 'service'; + +Uint8_1 : 'uint8[]'; + +Array : 'Array:'; + +Base64 : 'Base64'; + +Double : 'Double'; + +Header : 'Header'; + +String : 'String'; + +Struct : 'Struct'; + +Action : 'action'; + +Bool_1 : 'bool[]'; + +Byte_1 : 'byte[]'; + +Depth : 'depth:'; + +Int8_1 : 'int8[]'; + +Result : 'result'; + +Specs : 'specs:'; + +String_1 : 'string'; + +Uint16 : 'uint16'; + +Uint32 : 'uint32'; + +Uint64 : 'uint64'; + +Goal_1 : 'goal:'; + +Int16 : 'int16'; + +Int32 : 'int32'; + +Int64 : 'int64'; + +Node_1 : 'node:'; + +Type_1 : 'type:'; + +Uint8 : 'uint8'; + +Value : 'value'; + +Date : 'Date'; + +List : 'List'; + +Bool : 'bool'; + +Byte : 'byte'; + +Goal : 'goal'; + +Int8 : 'int8'; + +Msg : 'msg:'; + +Name : 'name'; + +Node : 'node'; + +Qos : 'qos:'; + +Srv : 'srv:'; + +Time : 'time'; + +Type : 'type'; + +Any : 'Any'; + +Ns : 'ns:'; + +LeftSquareBracketRightSquareBracket : '[]'; + +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)*; + +fragment RULE_DIGIT : '0'..'9'; + +RULE_BINARY : ('0b'|'0B') ('0'|'1')+; + +RULE_BOOLEAN : ('true'|'false'); + +RULE_DOUBLE : RULE_DIGIT ('.' RULE_DECINT*|('.' RULE_DIGIT*)? ('E'|'e') ('-'|'+')? RULE_DIGIT); + +RULE_DECINT : ('0'|'1'..'9' RULE_DIGIT*|'-' '0'..'9' RULE_DIGIT*); + +fragment RULE_DAY : ('1'..'9'|'1'..'3' '0'..'9'); + +fragment RULE_MONTH : ('1'..'9'|'1' '0'..'2'); + +fragment RULE_YEAR : '0'..'2' '0'..'9' '0'..'9' '0'..'9'; + +fragment RULE_HOUR : ('0'..'1' '0'..'9'|'2' '0'..'3'); + +fragment RULE_MIN_SEC : '0'..'5' '0'..'9'; + +RULE_DATE_TIME : RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC; + +RULE_MESSAGE_ASIGMENT : (RULE_ID|RULE_STRING) '=' (RULE_ID|RULE_STRING|RULE_INT|'-' RULE_INT); + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + +fragment 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.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/lexer/InternalRos2Lexer.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/lexer/InternalRos2Lexer.java new file mode 100644 index 000000000..fdf37b94a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/lexer/InternalRos2Lexer.java @@ -0,0 +1,5509 @@ +package de.fraunhofer.ipa.ros2.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 InternalRos2Lexer extends Lexer { + public static final int Float32_1=30; + public static final int Node=93; + public static final int RULE_DATE_TIME=123; + public static final int Uint64_1=45; + public static final int String=64; + public static final int History=36; + public static final int Int16=78; + public static final int Float32=51; + public static final int Goal=89; + public static final int Bool=87; + public static final int Uint16=74; + public static final int Boolean=47; + public static final int ExternalDependency=5; + public static final int Uint8=83; + public static final int Parameters=24; + public static final int RULE_ID=109; + public static final int Actionclient=12; + public static final int RULE_DIGIT=113; + public static final int GlobalNamespace=8; + public static final int Artifacts=26; + public static final int Node_1=81; + public static final int Int16_1=53; + public static final int Header=63; + public static final int RULE_INT=124; + public static final int Byte=88; + public static final int RULE_ML_COMMENT=126; + public static final int LeftSquareBracket=103; + public static final int Specs=72; + public static final int Base64=61; + public static final int Message_1=38; + public static final int Profile=39; + public static final int Depth=69; + public static final int Comma=101; + public static final int RULE_MESSAGE_ASIGMENT=125; + public static final int Goal_1=77; + public static final int LeftSquareBracketRightSquareBracket=100; + public static final int Int32=79; + public static final int Publishers=25; + public static final int Serviceserver=11; + public static final int Parameter_qos=15; + public static final int RightCurlyBracket=105; + public static final int RULE_DECINT=116; + public static final int Reliable=40; + public static final int Uint32=75; + public static final int FromGitRepo=17; + public static final int Msg=91; + public static final int RULE_HOUR=121; + public static final int Int8=90; + public static final int Default=50; + public static final int Actionserver=13; + public static final int Int8_1=70; + public static final int Uint16_1=43; + public static final int Type=97; + public static final int Float64=52; + public static final int Int32_1=54; + public static final int Result_1=57; + public static final int Keep_all=37; + public static final int RULE_BINARY=114; + public static final int String_1=73; + public static final int Subscribers=20; + public static final int String_2=42; + public static final int RULE_BEGIN=106; + public static final int RULE_DAY=118; + public static final int Services_qos=19; + public static final int RULE_BOOLEAN=115; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=120; + public static final int Feedback_1=29; + public static final int Result=71; + public static final int Name=92; + public static final int RULE_MIN_SEC=122; + public static final int Default_qos=22; + public static final int ParameterAny=16; + public static final int List=86; + public static final int Dependencies=14; + public static final int RightSquareBracket=104; + public static final int PrivateNamespace=7; + public static final int GraphName=28; + public static final int Byte_1=68; + public static final int Float64_1=31; + public static final int Durability=23; + public static final int Duration=34; + public static final int Uint32_1=44; + public static final int Action_1=49; + public static final int Double=62; + public static final int Keep_last=32; + public static final int Type_1=82; + public static final int Value=84; + public static final int Transient_local=9; + public static final int Uint64=76; + public static final int Action=66; + public static final int RULE_END=107; + public static final int Message=56; + public static final int Time=96; + public static final int RULE_STRING=111; + public static final int Best_effort=21; + public static final int Bool_1=67; + public static final int Any=98; + public static final int Struct=65; + public static final int RULE_SL_COMMENT=108; + public static final int Uint8_1=59; + public static final int RULE_DOUBLE=117; + public static final int Feedback=35; + public static final int ParameterStructMember=4; + public static final int Srv=95; + public static final int RULE_ROS_CONVENTION_A=110; + public static final int RULE_ROS_CONVENTION_PARAM=112; + public static final int Colon=102; + public static final int EOF=-1; + public static final int Ns=99; + public static final int RULE_WS=127; + public static final int Request=41; + public static final int Int64_1=55; + public static final int Service=58; + public static final int Sensor_qos=27; + public static final int RULE_ANY_OTHER=128; + public static final int Volatile=46; + public static final int Date=85; + public static final int Response=33; + public static final int Integer=48; + public static final int Array=60; + public static final int Serviceclient=10; + public static final int Qos=94; + public static final int Int64=80; + public static final int RULE_MONTH=119; + public static final int Reliability=18; + + // delegates + // delegators + + public InternalRos2Lexer() {;} + public InternalRos2Lexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public InternalRos2Lexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "InternalRos2Lexer.g"; } + + // $ANTLR start "ParameterStructMember" + public final void mParameterStructMember() throws RecognitionException { + try { + int _type = ParameterStructMember; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:14:23: ( 'ParameterStructMember' ) + // InternalRos2Lexer.g:14:25: 'ParameterStructMember' + { + match("ParameterStructMember"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterStructMember" + + // $ANTLR start "ExternalDependency" + public final void mExternalDependency() throws RecognitionException { + try { + int _type = ExternalDependency; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:16:20: ( 'ExternalDependency' ) + // InternalRos2Lexer.g:16:22: 'ExternalDependency' + { + match("ExternalDependency"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ExternalDependency" + + // $ANTLR start "RelativeNamespace" + public final void mRelativeNamespace() throws RecognitionException { + try { + int _type = RelativeNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:18:19: ( 'RelativeNamespace' ) + // InternalRos2Lexer.g:18:21: 'RelativeNamespace' + { + match("RelativeNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RelativeNamespace" + + // $ANTLR start "PrivateNamespace" + public final void mPrivateNamespace() throws RecognitionException { + try { + int _type = PrivateNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:20:18: ( 'PrivateNamespace' ) + // InternalRos2Lexer.g:20:20: 'PrivateNamespace' + { + match("PrivateNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PrivateNamespace" + + // $ANTLR start "GlobalNamespace" + public final void mGlobalNamespace() throws RecognitionException { + try { + int _type = GlobalNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:22:17: ( 'GlobalNamespace' ) + // InternalRos2Lexer.g:22:19: 'GlobalNamespace' + { + match("GlobalNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GlobalNamespace" + + // $ANTLR start "Transient_local" + public final void mTransient_local() throws RecognitionException { + try { + int _type = Transient_local; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:24:17: ( 'transient_local' ) + // InternalRos2Lexer.g:24:19: 'transient_local' + { + match("transient_local"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Transient_local" + + // $ANTLR start "Serviceclient" + public final void mServiceclient() throws RecognitionException { + try { + int _type = Serviceclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:26:15: ( 'serviceclient:' ) + // InternalRos2Lexer.g:26:17: 'serviceclient:' + { + match("serviceclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceclient" + + // $ANTLR start "Serviceserver" + public final void mServiceserver() throws RecognitionException { + try { + int _type = Serviceserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:28:15: ( 'serviceserver:' ) + // InternalRos2Lexer.g:28:17: 'serviceserver:' + { + match("serviceserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceserver" + + // $ANTLR start "Actionclient" + public final void mActionclient() throws RecognitionException { + try { + int _type = Actionclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:30:14: ( 'actionclient:' ) + // InternalRos2Lexer.g:30:16: 'actionclient:' + { + match("actionclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionclient" + + // $ANTLR start "Actionserver" + public final void mActionserver() throws RecognitionException { + try { + int _type = Actionserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:32:14: ( 'actionserver:' ) + // InternalRos2Lexer.g:32:16: 'actionserver:' + { + match("actionserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionserver" + + // $ANTLR start "Dependencies" + public final void mDependencies() throws RecognitionException { + try { + int _type = Dependencies; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:34:14: ( 'dependencies:' ) + // InternalRos2Lexer.g:34:16: 'dependencies:' + { + match("dependencies:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Dependencies" + + // $ANTLR start "Parameter_qos" + public final void mParameter_qos() throws RecognitionException { + try { + int _type = Parameter_qos; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:36:15: ( 'parameter_qos' ) + // InternalRos2Lexer.g:36:17: 'parameter_qos' + { + match("parameter_qos"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Parameter_qos" + + // $ANTLR start "ParameterAny" + public final void mParameterAny() throws RecognitionException { + try { + int _type = ParameterAny; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:38:14: ( 'ParameterAny' ) + // InternalRos2Lexer.g:38:16: 'ParameterAny' + { + match("ParameterAny"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterAny" + + // $ANTLR start "FromGitRepo" + public final void mFromGitRepo() throws RecognitionException { + try { + int _type = FromGitRepo; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:40:13: ( 'fromGitRepo:' ) + // InternalRos2Lexer.g:40:15: 'fromGitRepo:' + { + match("fromGitRepo:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FromGitRepo" + + // $ANTLR start "Reliability" + public final void mReliability() throws RecognitionException { + try { + int _type = Reliability; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:42:13: ( 'reliability:' ) + // InternalRos2Lexer.g:42:15: 'reliability:' + { + match("reliability:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Reliability" + + // $ANTLR start "Services_qos" + public final void mServices_qos() throws RecognitionException { + try { + int _type = Services_qos; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:44:14: ( 'services_qos' ) + // InternalRos2Lexer.g:44:16: 'services_qos' + { + match("services_qos"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Services_qos" + + // $ANTLR start "Subscribers" + public final void mSubscribers() throws RecognitionException { + try { + int _type = Subscribers; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:46:13: ( 'subscribers:' ) + // InternalRos2Lexer.g:46:15: 'subscribers:' + { + match("subscribers:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Subscribers" + + // $ANTLR start "Best_effort" + public final void mBest_effort() throws RecognitionException { + try { + int _type = Best_effort; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:48:13: ( 'best_effort' ) + // InternalRos2Lexer.g:48:15: 'best_effort' + { + match("best_effort"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Best_effort" + + // $ANTLR start "Default_qos" + public final void mDefault_qos() throws RecognitionException { + try { + int _type = Default_qos; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:50:13: ( 'default_qos' ) + // InternalRos2Lexer.g:50:15: 'default_qos' + { + match("default_qos"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Default_qos" + + // $ANTLR start "Durability" + public final void mDurability() throws RecognitionException { + try { + int _type = Durability; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:52:12: ( 'durability:' ) + // InternalRos2Lexer.g:52:14: 'durability:' + { + match("durability:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Durability" + + // $ANTLR start "Parameters" + public final void mParameters() throws RecognitionException { + try { + int _type = Parameters; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:54:12: ( 'parameters:' ) + // InternalRos2Lexer.g:54: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; + // InternalRos2Lexer.g:56:12: ( 'publishers:' ) + // InternalRos2Lexer.g:56: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; + // InternalRos2Lexer.g:58:11: ( 'artifacts:' ) + // InternalRos2Lexer.g:58:13: 'artifacts:' + { + match("artifacts:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Artifacts" + + // $ANTLR start "Sensor_qos" + public final void mSensor_qos() throws RecognitionException { + try { + int _type = Sensor_qos; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:60:12: ( 'sensor_qos' ) + // InternalRos2Lexer.g:60:14: 'sensor_qos' + { + match("sensor_qos"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Sensor_qos" + + // $ANTLR start "GraphName" + public final void mGraphName() throws RecognitionException { + try { + int _type = GraphName; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:62:11: ( 'GraphName' ) + // InternalRos2Lexer.g:62:13: 'GraphName' + { + match("GraphName"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GraphName" + + // $ANTLR start "Feedback_1" + public final void mFeedback_1() throws RecognitionException { + try { + int _type = Feedback_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:64:12: ( 'feedback:' ) + // InternalRos2Lexer.g:64:14: 'feedback:' + { + match("feedback:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback_1" + + // $ANTLR start "Float32_1" + public final void mFloat32_1() throws RecognitionException { + try { + int _type = Float32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:66:11: ( 'float32[]' ) + // InternalRos2Lexer.g:66:13: 'float32[]' + { + match("float32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32_1" + + // $ANTLR start "Float64_1" + public final void mFloat64_1() throws RecognitionException { + try { + int _type = Float64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:68:11: ( 'float64[]' ) + // InternalRos2Lexer.g:68:13: 'float64[]' + { + match("float64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64_1" + + // $ANTLR start "Keep_last" + public final void mKeep_last() throws RecognitionException { + try { + int _type = Keep_last; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:70:11: ( 'keep_last' ) + // InternalRos2Lexer.g:70:13: 'keep_last' + { + match("keep_last"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Keep_last" + + // $ANTLR start "Response" + public final void mResponse() throws RecognitionException { + try { + int _type = Response; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:72:10: ( 'response:' ) + // InternalRos2Lexer.g:72:12: 'response:' + { + match("response:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Response" + + // $ANTLR start "Duration" + public final void mDuration() throws RecognitionException { + try { + int _type = Duration; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:74:10: ( 'duration' ) + // InternalRos2Lexer.g:74:12: 'duration' + { + match("duration"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Duration" + + // $ANTLR start "Feedback" + public final void mFeedback() throws RecognitionException { + try { + int _type = Feedback; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:76:10: ( 'feedback' ) + // InternalRos2Lexer.g:76:12: 'feedback' + { + match("feedback"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback" + + // $ANTLR start "History" + public final void mHistory() throws RecognitionException { + try { + int _type = History; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:78:9: ( 'history:' ) + // InternalRos2Lexer.g:78:11: 'history:' + { + match("history:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "History" + + // $ANTLR start "Keep_all" + public final void mKeep_all() throws RecognitionException { + try { + int _type = Keep_all; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:80:10: ( 'keep_all' ) + // InternalRos2Lexer.g:80:12: 'keep_all' + { + match("keep_all"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Keep_all" + + // $ANTLR start "Message_1" + public final void mMessage_1() throws RecognitionException { + try { + int _type = Message_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:82:11: ( 'message:' ) + // InternalRos2Lexer.g:82:13: 'message:' + { + match("message:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message_1" + + // $ANTLR start "Profile" + public final void mProfile() throws RecognitionException { + try { + int _type = Profile; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:84:9: ( 'profile:' ) + // InternalRos2Lexer.g:84:11: 'profile:' + { + match("profile:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Profile" + + // $ANTLR start "Reliable" + public final void mReliable() throws RecognitionException { + try { + int _type = Reliable; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:86:10: ( 'reliable' ) + // InternalRos2Lexer.g:86:12: 'reliable' + { + match("reliable"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Reliable" + + // $ANTLR start "Request" + public final void mRequest() throws RecognitionException { + try { + int _type = Request; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:88:9: ( 'request:' ) + // InternalRos2Lexer.g:88:11: 'request:' + { + match("request:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Request" + + // $ANTLR start "String_2" + public final void mString_2() throws RecognitionException { + try { + int _type = String_2; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:90:10: ( 'string[]' ) + // InternalRos2Lexer.g:90:12: 'string[]' + { + match("string[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_2" + + // $ANTLR start "Uint16_1" + public final void mUint16_1() throws RecognitionException { + try { + int _type = Uint16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:92:10: ( 'uint16[]' ) + // InternalRos2Lexer.g:92:12: 'uint16[]' + { + match("uint16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16_1" + + // $ANTLR start "Uint32_1" + public final void mUint32_1() throws RecognitionException { + try { + int _type = Uint32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:94:10: ( 'uint32[]' ) + // InternalRos2Lexer.g:94:12: 'uint32[]' + { + match("uint32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32_1" + + // $ANTLR start "Uint64_1" + public final void mUint64_1() throws RecognitionException { + try { + int _type = Uint64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:96:10: ( 'uint64[]' ) + // InternalRos2Lexer.g:96:12: 'uint64[]' + { + match("uint64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64_1" + + // $ANTLR start "Volatile" + public final void mVolatile() throws RecognitionException { + try { + int _type = Volatile; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:98:10: ( 'volatile' ) + // InternalRos2Lexer.g:98:12: 'volatile' + { + match("volatile"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Volatile" + + // $ANTLR start "Boolean" + public final void mBoolean() throws RecognitionException { + try { + int _type = Boolean; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:100:9: ( 'Boolean' ) + // InternalRos2Lexer.g:100:11: 'Boolean' + { + match("Boolean"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Boolean" + + // $ANTLR start "Integer" + public final void mInteger() throws RecognitionException { + try { + int _type = Integer; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:102:9: ( 'Integer' ) + // InternalRos2Lexer.g:102:11: 'Integer' + { + match("Integer"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Integer" + + // $ANTLR start "Action_1" + public final void mAction_1() throws RecognitionException { + try { + int _type = Action_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:104:10: ( 'action:' ) + // InternalRos2Lexer.g:104:12: 'action:' + { + match("action:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action_1" + + // $ANTLR start "Default" + public final void mDefault() throws RecognitionException { + try { + int _type = Default; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:106:9: ( 'default' ) + // InternalRos2Lexer.g:106:11: 'default' + { + match("default"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Default" + + // $ANTLR start "Float32" + public final void mFloat32() throws RecognitionException { + try { + int _type = Float32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:108:9: ( 'float32' ) + // InternalRos2Lexer.g:108:11: 'float32' + { + match("float32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32" + + // $ANTLR start "Float64" + public final void mFloat64() throws RecognitionException { + try { + int _type = Float64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:110:9: ( 'float64' ) + // InternalRos2Lexer.g:110:11: 'float64' + { + match("float64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64" + + // $ANTLR start "Int16_1" + public final void mInt16_1() throws RecognitionException { + try { + int _type = Int16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:112:9: ( 'int16[]' ) + // InternalRos2Lexer.g:112:11: 'int16[]' + { + match("int16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16_1" + + // $ANTLR start "Int32_1" + public final void mInt32_1() throws RecognitionException { + try { + int _type = Int32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:114:9: ( 'int32[]' ) + // InternalRos2Lexer.g:114:11: 'int32[]' + { + match("int32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32_1" + + // $ANTLR start "Int64_1" + public final void mInt64_1() throws RecognitionException { + try { + int _type = Int64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:116:9: ( 'int64[]' ) + // InternalRos2Lexer.g:116:11: 'int64[]' + { + match("int64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64_1" + + // $ANTLR start "Message" + public final void mMessage() throws RecognitionException { + try { + int _type = Message; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:118:9: ( 'message' ) + // InternalRos2Lexer.g:118:11: 'message' + { + match("message"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message" + + // $ANTLR start "Result_1" + public final void mResult_1() throws RecognitionException { + try { + int _type = Result_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:120:10: ( 'result:' ) + // InternalRos2Lexer.g:120:12: 'result:' + { + match("result:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result_1" + + // $ANTLR start "Service" + public final void mService() throws RecognitionException { + try { + int _type = Service; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:122:9: ( 'service' ) + // InternalRos2Lexer.g:122:11: 'service' + { + match("service"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Service" + + // $ANTLR start "Uint8_1" + public final void mUint8_1() throws RecognitionException { + try { + int _type = Uint8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:124:9: ( 'uint8[]' ) + // InternalRos2Lexer.g:124:11: 'uint8[]' + { + match("uint8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8_1" + + // $ANTLR start "Array" + public final void mArray() throws RecognitionException { + try { + int _type = Array; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:126:7: ( 'Array:' ) + // InternalRos2Lexer.g:126:9: 'Array:' + { + match("Array:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Array" + + // $ANTLR start "Base64" + public final void mBase64() throws RecognitionException { + try { + int _type = Base64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:128:8: ( 'Base64' ) + // InternalRos2Lexer.g:128:10: 'Base64' + { + match("Base64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Base64" + + // $ANTLR start "Double" + public final void mDouble() throws RecognitionException { + try { + int _type = Double; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:130:8: ( 'Double' ) + // InternalRos2Lexer.g:130:10: 'Double' + { + match("Double"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Double" + + // $ANTLR start "Header" + public final void mHeader() throws RecognitionException { + try { + int _type = Header; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:132:8: ( 'Header' ) + // InternalRos2Lexer.g:132:10: 'Header' + { + match("Header"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Header" + + // $ANTLR start "String" + public final void mString() throws RecognitionException { + try { + int _type = String; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:134:8: ( 'String' ) + // InternalRos2Lexer.g:134:10: 'String' + { + match("String"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String" + + // $ANTLR start "Struct" + public final void mStruct() throws RecognitionException { + try { + int _type = Struct; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:136:8: ( 'Struct' ) + // InternalRos2Lexer.g:136:10: 'Struct' + { + match("Struct"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Struct" + + // $ANTLR start "Action" + public final void mAction() throws RecognitionException { + try { + int _type = Action; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:138:8: ( 'action' ) + // InternalRos2Lexer.g:138:10: 'action' + { + match("action"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action" + + // $ANTLR start "Bool_1" + public final void mBool_1() throws RecognitionException { + try { + int _type = Bool_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:140:8: ( 'bool[]' ) + // InternalRos2Lexer.g:140:10: 'bool[]' + { + match("bool[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool_1" + + // $ANTLR start "Byte_1" + public final void mByte_1() throws RecognitionException { + try { + int _type = Byte_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:142:8: ( 'byte[]' ) + // InternalRos2Lexer.g:142:10: 'byte[]' + { + match("byte[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte_1" + + // $ANTLR start "Depth" + public final void mDepth() throws RecognitionException { + try { + int _type = Depth; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:144:7: ( 'depth:' ) + // InternalRos2Lexer.g:144:9: 'depth:' + { + match("depth:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Depth" + + // $ANTLR start "Int8_1" + public final void mInt8_1() throws RecognitionException { + try { + int _type = Int8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:146:8: ( 'int8[]' ) + // InternalRos2Lexer.g:146:10: 'int8[]' + { + match("int8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8_1" + + // $ANTLR start "Result" + public final void mResult() throws RecognitionException { + try { + int _type = Result; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:148:8: ( 'result' ) + // InternalRos2Lexer.g:148:10: 'result' + { + match("result"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result" + + // $ANTLR start "Specs" + public final void mSpecs() throws RecognitionException { + try { + int _type = Specs; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:150:7: ( 'specs:' ) + // InternalRos2Lexer.g:150:9: 'specs:' + { + match("specs:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Specs" + + // $ANTLR start "String_1" + public final void mString_1() throws RecognitionException { + try { + int _type = String_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:152:10: ( 'string' ) + // InternalRos2Lexer.g:152:12: 'string' + { + match("string"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_1" + + // $ANTLR start "Uint16" + public final void mUint16() throws RecognitionException { + try { + int _type = Uint16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:154:8: ( 'uint16' ) + // InternalRos2Lexer.g:154:10: 'uint16' + { + match("uint16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16" + + // $ANTLR start "Uint32" + public final void mUint32() throws RecognitionException { + try { + int _type = Uint32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:156:8: ( 'uint32' ) + // InternalRos2Lexer.g:156:10: 'uint32' + { + match("uint32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32" + + // $ANTLR start "Uint64" + public final void mUint64() throws RecognitionException { + try { + int _type = Uint64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:158:8: ( 'uint64' ) + // InternalRos2Lexer.g:158:10: 'uint64' + { + match("uint64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64" + + // $ANTLR start "Goal_1" + public final void mGoal_1() throws RecognitionException { + try { + int _type = Goal_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:160:8: ( 'goal:' ) + // InternalRos2Lexer.g:160:10: 'goal:' + { + match("goal:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal_1" + + // $ANTLR start "Int16" + public final void mInt16() throws RecognitionException { + try { + int _type = Int16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:162:7: ( 'int16' ) + // InternalRos2Lexer.g:162:9: 'int16' + { + match("int16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16" + + // $ANTLR start "Int32" + public final void mInt32() throws RecognitionException { + try { + int _type = Int32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:164:7: ( 'int32' ) + // InternalRos2Lexer.g:164:9: 'int32' + { + match("int32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32" + + // $ANTLR start "Int64" + public final void mInt64() throws RecognitionException { + try { + int _type = Int64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:166:7: ( 'int64' ) + // InternalRos2Lexer.g:166:9: 'int64' + { + match("int64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64" + + // $ANTLR start "Node_1" + public final void mNode_1() throws RecognitionException { + try { + int _type = Node_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:168:8: ( 'node:' ) + // InternalRos2Lexer.g:168:10: 'node:' + { + match("node:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node_1" + + // $ANTLR start "Type_1" + public final void mType_1() throws RecognitionException { + try { + int _type = Type_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:170:8: ( 'type:' ) + // InternalRos2Lexer.g:170:10: 'type:' + { + match("type:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type_1" + + // $ANTLR start "Uint8" + public final void mUint8() throws RecognitionException { + try { + int _type = Uint8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:172:7: ( 'uint8' ) + // InternalRos2Lexer.g:172:9: 'uint8' + { + match("uint8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8" + + // $ANTLR start "Value" + public final void mValue() throws RecognitionException { + try { + int _type = Value; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:174:7: ( 'value' ) + // InternalRos2Lexer.g:174:9: 'value' + { + match("value"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Value" + + // $ANTLR start "Date" + public final void mDate() throws RecognitionException { + try { + int _type = Date; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:176:6: ( 'Date' ) + // InternalRos2Lexer.g:176:8: 'Date' + { + match("Date"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Date" + + // $ANTLR start "List" + public final void mList() throws RecognitionException { + try { + int _type = List; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:178:6: ( 'List' ) + // InternalRos2Lexer.g:178:8: 'List' + { + match("List"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "List" + + // $ANTLR start "Bool" + public final void mBool() throws RecognitionException { + try { + int _type = Bool; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:180:6: ( 'bool' ) + // InternalRos2Lexer.g:180:8: 'bool' + { + match("bool"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool" + + // $ANTLR start "Byte" + public final void mByte() throws RecognitionException { + try { + int _type = Byte; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:182:6: ( 'byte' ) + // InternalRos2Lexer.g:182:8: 'byte' + { + match("byte"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte" + + // $ANTLR start "Goal" + public final void mGoal() throws RecognitionException { + try { + int _type = Goal; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:184:6: ( 'goal' ) + // InternalRos2Lexer.g:184:8: 'goal' + { + match("goal"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal" + + // $ANTLR start "Int8" + public final void mInt8() throws RecognitionException { + try { + int _type = Int8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:186:6: ( 'int8' ) + // InternalRos2Lexer.g:186:8: 'int8' + { + match("int8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8" + + // $ANTLR start "Msg" + public final void mMsg() throws RecognitionException { + try { + int _type = Msg; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:188:5: ( 'msg:' ) + // InternalRos2Lexer.g:188:7: 'msg:' + { + match("msg:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Msg" + + // $ANTLR start "Name" + public final void mName() throws RecognitionException { + try { + int _type = Name; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:190:6: ( 'name' ) + // InternalRos2Lexer.g:190:8: 'name' + { + match("name"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Name" + + // $ANTLR start "Node" + public final void mNode() throws RecognitionException { + try { + int _type = Node; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:192:6: ( 'node' ) + // InternalRos2Lexer.g:192:8: 'node' + { + match("node"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node" + + // $ANTLR start "Qos" + public final void mQos() throws RecognitionException { + try { + int _type = Qos; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:194:5: ( 'qos:' ) + // InternalRos2Lexer.g:194:7: 'qos:' + { + match("qos:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Qos" + + // $ANTLR start "Srv" + public final void mSrv() throws RecognitionException { + try { + int _type = Srv; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:196:5: ( 'srv:' ) + // InternalRos2Lexer.g:196:7: 'srv:' + { + match("srv:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Srv" + + // $ANTLR start "Time" + public final void mTime() throws RecognitionException { + try { + int _type = Time; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:198:6: ( 'time' ) + // InternalRos2Lexer.g:198:8: 'time' + { + match("time"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Time" + + // $ANTLR start "Type" + public final void mType() throws RecognitionException { + try { + int _type = Type; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:200:6: ( 'type' ) + // InternalRos2Lexer.g:200:8: 'type' + { + match("type"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type" + + // $ANTLR start "Any" + public final void mAny() throws RecognitionException { + try { + int _type = Any; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:202:5: ( 'Any' ) + // InternalRos2Lexer.g:202:7: 'Any' + { + match("Any"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Any" + + // $ANTLR start "Ns" + public final void mNs() throws RecognitionException { + try { + int _type = Ns; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:204:4: ( 'ns:' ) + // InternalRos2Lexer.g:204:6: 'ns:' + { + match("ns:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Ns" + + // $ANTLR start "LeftSquareBracketRightSquareBracket" + public final void mLeftSquareBracketRightSquareBracket() throws RecognitionException { + try { + int _type = LeftSquareBracketRightSquareBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:206:37: ( '[]' ) + // InternalRos2Lexer.g:206:39: '[]' + { + match("[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LeftSquareBracketRightSquareBracket" + + // $ANTLR start "Comma" + public final void mComma() throws RecognitionException { + try { + int _type = Comma; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:208:7: ( ',' ) + // InternalRos2Lexer.g:208: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; + // InternalRos2Lexer.g:210:7: ( ':' ) + // InternalRos2Lexer.g:210: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; + // InternalRos2Lexer.g:212:19: ( '[' ) + // InternalRos2Lexer.g:212: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; + // InternalRos2Lexer.g:214:20: ( ']' ) + // InternalRos2Lexer.g:214: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; + // InternalRos2Lexer.g:216:19: ( '}' ) + // InternalRos2Lexer.g:216:21: '}' + { + match('}'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RightCurlyBracket" + + // $ANTLR start "RULE_BEGIN" + public final void mRULE_BEGIN() throws RecognitionException { + try { + // InternalRos2Lexer.g:218:21: () + // InternalRos2Lexer.g:218:23: + { + } + + } + finally { + } + } + // $ANTLR end "RULE_BEGIN" + + // $ANTLR start "RULE_END" + public final void mRULE_END() throws RecognitionException { + try { + // InternalRos2Lexer.g:220:19: () + // InternalRos2Lexer.g:220: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; + // InternalRos2Lexer.g:222:17: ( '#' (~ ( ( '\\n' | '\\r' ) ) )* ) + // InternalRos2Lexer.g:222:19: '#' (~ ( ( '\\n' | '\\r' ) ) )* + { + match('#'); + // InternalRos2Lexer.g:222: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 : + // InternalRos2Lexer.g:222: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; + // InternalRos2Lexer.g:224:23: ( ( '/' RULE_ID | RULE_ID '/' )* ) + // InternalRos2Lexer.g:224:25: ( '/' RULE_ID | RULE_ID '/' )* + { + // InternalRos2Lexer.g:224: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 : + // InternalRos2Lexer.g:224:26: '/' RULE_ID + { + match('/'); + mRULE_ID(); + + } + break; + case 2 : + // InternalRos2Lexer.g:224: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; + // InternalRos2Lexer.g:226:27: ( ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* ) + // InternalRos2Lexer.g:226:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* + { + // InternalRos2Lexer.g:226: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 : + // InternalRos2Lexer.g:226:30: '/' RULE_STRING + { + match('/'); + mRULE_STRING(); + + } + break; + case 2 : + // InternalRos2Lexer.g:226:46: RULE_STRING '/' + { + mRULE_STRING(); + match('/'); + + } + break; + case 3 : + // InternalRos2Lexer.g:226: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_DIGIT" + public final void mRULE_DIGIT() throws RecognitionException { + try { + // InternalRos2Lexer.g:228:21: ( '0' .. '9' ) + // InternalRos2Lexer.g:228:23: '0' .. '9' + { + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_DIGIT" + + // $ANTLR start "RULE_BINARY" + public final void mRULE_BINARY() throws RecognitionException { + try { + int _type = RULE_BINARY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:230:13: ( ( '0b' | '0B' ) ( '0' | '1' )+ ) + // InternalRos2Lexer.g:230:15: ( '0b' | '0B' ) ( '0' | '1' )+ + { + // InternalRos2Lexer.g:230:15: ( '0b' | '0B' ) + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0=='0') ) { + int LA4_1 = input.LA(2); + + if ( (LA4_1=='b') ) { + alt4=1; + } + else if ( (LA4_1=='B') ) { + alt4=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + switch (alt4) { + case 1 : + // InternalRos2Lexer.g:230:16: '0b' + { + match("0b"); + + + } + break; + case 2 : + // InternalRos2Lexer.g:230:21: '0B' + { + match("0B"); + + + } + break; + + } + + // InternalRos2Lexer.g:230:27: ( '0' | '1' )+ + int cnt5=0; + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( ((LA5_0>='0' && LA5_0<='1')) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalRos2Lexer.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='1') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt5 >= 1 ) break loop5; + EarlyExitException eee = + new EarlyExitException(5, input); + throw eee; + } + cnt5++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BINARY" + + // $ANTLR start "RULE_BOOLEAN" + public final void mRULE_BOOLEAN() throws RecognitionException { + try { + int _type = RULE_BOOLEAN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:232:14: ( ( 'true' | 'false' ) ) + // InternalRos2Lexer.g:232:16: ( 'true' | 'false' ) + { + // InternalRos2Lexer.g:232:16: ( 'true' | 'false' ) + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='t') ) { + alt6=1; + } + else if ( (LA6_0=='f') ) { + alt6=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + switch (alt6) { + case 1 : + // InternalRos2Lexer.g:232:17: 'true' + { + match("true"); + + + } + break; + case 2 : + // InternalRos2Lexer.g:232:24: 'false' + { + match("false"); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BOOLEAN" + + // $ANTLR start "RULE_DOUBLE" + public final void mRULE_DOUBLE() throws RecognitionException { + try { + int _type = RULE_DOUBLE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:234:13: ( RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) ) + // InternalRos2Lexer.g:234:15: RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + { + mRULE_DIGIT(); + // InternalRos2Lexer.g:234:26: ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + int alt11=2; + alt11 = dfa11.predict(input); + switch (alt11) { + case 1 : + // InternalRos2Lexer.g:234:27: '.' ( RULE_DECINT )* + { + match('.'); + // InternalRos2Lexer.g:234:31: ( RULE_DECINT )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0=='-'||(LA7_0>='0' && LA7_0<='9')) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalRos2Lexer.g:234:31: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + + default : + break loop7; + } + } while (true); + + + } + break; + case 2 : + // InternalRos2Lexer.g:234:44: ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT + { + // InternalRos2Lexer.g:234:44: ( '.' ( RULE_DIGIT )* )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='.') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalRos2Lexer.g:234:45: '.' ( RULE_DIGIT )* + { + match('.'); + // InternalRos2Lexer.g:234:49: ( RULE_DIGIT )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( ((LA8_0>='0' && LA8_0<='9')) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // InternalRos2Lexer.g:234:49: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop8; + } + } while (true); + + + } + break; + + } + + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalRos2Lexer.g:234:73: ( '-' | '+' )? + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='+'||LA10_0=='-') ) { + alt10=1; + } + switch (alt10) { + case 1 : + // InternalRos2Lexer.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_DIGIT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DOUBLE" + + // $ANTLR start "RULE_DECINT" + public final void mRULE_DECINT() throws RecognitionException { + try { + int _type = RULE_DECINT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:236:13: ( ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) ) + // InternalRos2Lexer.g:236:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + { + // InternalRos2Lexer.g:236:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + int alt14=3; + switch ( input.LA(1) ) { + case '0': + { + alt14=1; + } + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt14=2; + } + break; + case '-': + { + alt14=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + + throw nvae; + } + + switch (alt14) { + case 1 : + // InternalRos2Lexer.g:236:16: '0' + { + match('0'); + + } + break; + case 2 : + // InternalRos2Lexer.g:236:20: '1' .. '9' ( RULE_DIGIT )* + { + matchRange('1','9'); + // InternalRos2Lexer.g:236:29: ( RULE_DIGIT )* + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( ((LA12_0>='0' && LA12_0<='9')) ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalRos2Lexer.g:236:29: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop12; + } + } while (true); + + + } + break; + case 3 : + // InternalRos2Lexer.g:236:41: '-' '0' .. '9' ( RULE_DIGIT )* + { + match('-'); + matchRange('0','9'); + // InternalRos2Lexer.g:236:54: ( RULE_DIGIT )* + loop13: + do { + int alt13=2; + int LA13_0 = input.LA(1); + + if ( ((LA13_0>='0' && LA13_0<='9')) ) { + alt13=1; + } + + + switch (alt13) { + case 1 : + // InternalRos2Lexer.g:236:54: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop13; + } + } while (true); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DECINT" + + // $ANTLR start "RULE_DAY" + public final void mRULE_DAY() throws RecognitionException { + try { + // InternalRos2Lexer.g:238:19: ( ( '1' .. '9' | '1' .. '3' '0' .. '9' ) ) + // InternalRos2Lexer.g:238:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + { + // InternalRos2Lexer.g:238:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + int alt15=2; + int LA15_0 = input.LA(1); + + if ( ((LA15_0>='1' && LA15_0<='3')) ) { + int LA15_1 = input.LA(2); + + if ( ((LA15_1>='0' && LA15_1<='9')) ) { + alt15=2; + } + else { + alt15=1;} + } + else if ( ((LA15_0>='4' && LA15_0<='9')) ) { + alt15=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + + throw nvae; + } + switch (alt15) { + case 1 : + // InternalRos2Lexer.g:238:22: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRos2Lexer.g:238:31: '1' .. '3' '0' .. '9' + { + matchRange('1','3'); + matchRange('0','9'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_DAY" + + // $ANTLR start "RULE_MONTH" + public final void mRULE_MONTH() throws RecognitionException { + try { + // InternalRos2Lexer.g:240:21: ( ( '1' .. '9' | '1' '0' .. '2' ) ) + // InternalRos2Lexer.g:240:23: ( '1' .. '9' | '1' '0' .. '2' ) + { + // InternalRos2Lexer.g:240:23: ( '1' .. '9' | '1' '0' .. '2' ) + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='1') ) { + int LA16_1 = input.LA(2); + + if ( ((LA16_1>='0' && LA16_1<='2')) ) { + alt16=2; + } + else { + alt16=1;} + } + else if ( ((LA16_0>='2' && LA16_0<='9')) ) { + alt16=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + + throw nvae; + } + switch (alt16) { + case 1 : + // InternalRos2Lexer.g:240:24: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRos2Lexer.g:240:33: '1' '0' .. '2' + { + match('1'); + matchRange('0','2'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_MONTH" + + // $ANTLR start "RULE_YEAR" + public final void mRULE_YEAR() throws RecognitionException { + try { + // InternalRos2Lexer.g:242:20: ( '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' ) + // InternalRos2Lexer.g:242:22: '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' + { + matchRange('0','2'); + matchRange('0','9'); + matchRange('0','9'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_YEAR" + + // $ANTLR start "RULE_HOUR" + public final void mRULE_HOUR() throws RecognitionException { + try { + // InternalRos2Lexer.g:244:20: ( ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) ) + // InternalRos2Lexer.g:244:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + { + // InternalRos2Lexer.g:244:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + int alt17=2; + int LA17_0 = input.LA(1); + + if ( ((LA17_0>='0' && LA17_0<='1')) ) { + alt17=1; + } + else if ( (LA17_0=='2') ) { + alt17=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); + + throw nvae; + } + switch (alt17) { + case 1 : + // InternalRos2Lexer.g:244:23: '0' .. '1' '0' .. '9' + { + matchRange('0','1'); + matchRange('0','9'); + + } + break; + case 2 : + // InternalRos2Lexer.g:244:41: '2' '0' .. '3' + { + match('2'); + matchRange('0','3'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_HOUR" + + // $ANTLR start "RULE_MIN_SEC" + public final void mRULE_MIN_SEC() throws RecognitionException { + try { + // InternalRos2Lexer.g:246:23: ( '0' .. '5' '0' .. '9' ) + // InternalRos2Lexer.g:246:25: '0' .. '5' '0' .. '9' + { + matchRange('0','5'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_MIN_SEC" + + // $ANTLR start "RULE_DATE_TIME" + public final void mRULE_DATE_TIME() throws RecognitionException { + try { + int _type = RULE_DATE_TIME; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:248:16: ( RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC ) + // InternalRos2Lexer.g:248:18: RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC + { + mRULE_YEAR(); + match('-'); + mRULE_MONTH(); + match('-'); + mRULE_DAY(); + match('T'); + mRULE_HOUR(); + match(':'); + mRULE_MIN_SEC(); + match(':'); + mRULE_MIN_SEC(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DATE_TIME" + + // $ANTLR start "RULE_MESSAGE_ASIGMENT" + public final void mRULE_MESSAGE_ASIGMENT() throws RecognitionException { + try { + int _type = RULE_MESSAGE_ASIGMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:250:23: ( ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) ) + // InternalRos2Lexer.g:250:25: ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + { + // InternalRos2Lexer.g:250:25: ( RULE_ID | RULE_STRING ) + int alt18=2; + int LA18_0 = input.LA(1); + + if ( ((LA18_0>='A' && LA18_0<='Z')||(LA18_0>='^' && LA18_0<='_')||(LA18_0>='a' && LA18_0<='z')) ) { + alt18=1; + } + else if ( (LA18_0=='\"'||LA18_0=='\'') ) { + alt18=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + + throw nvae; + } + switch (alt18) { + case 1 : + // InternalRos2Lexer.g:250:26: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRos2Lexer.g:250:34: RULE_STRING + { + mRULE_STRING(); + + } + break; + + } + + match('='); + // InternalRos2Lexer.g:250:51: ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + int alt19=4; + switch ( input.LA(1) ) { + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + case 'G': + case 'H': + case 'I': + case 'J': + case 'K': + case 'L': + case 'M': + case 'N': + case 'O': + case 'P': + case 'Q': + case 'R': + case 'S': + case 'T': + case 'U': + case 'V': + case 'W': + case 'X': + case 'Y': + case 'Z': + case '^': + case '_': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'g': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': + { + alt19=1; + } + break; + case '\"': + case '\'': + { + alt19=2; + } + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt19=3; + } + break; + case '-': + { + alt19=4; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 19, 0, input); + + throw nvae; + } + + switch (alt19) { + case 1 : + // InternalRos2Lexer.g:250:52: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRos2Lexer.g:250:60: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 3 : + // InternalRos2Lexer.g:250:72: RULE_INT + { + mRULE_INT(); + + } + break; + case 4 : + // InternalRos2Lexer.g:250:81: '-' RULE_INT + { + match('-'); + mRULE_INT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_MESSAGE_ASIGMENT" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:252:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // InternalRos2Lexer.g:252:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + // InternalRos2Lexer.g:252:11: ( '^' )? + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0=='^') ) { + alt20=1; + } + switch (alt20) { + case 1 : + // InternalRos2Lexer.g:252: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;} + + // InternalRos2Lexer.g:252:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop21: + do { + int alt21=2; + int LA21_0 = input.LA(1); + + if ( ((LA21_0>='0' && LA21_0<='9')||(LA21_0>='A' && LA21_0<='Z')||LA21_0=='_'||(LA21_0>='a' && LA21_0<='z')) ) { + alt21=1; + } + + + switch (alt21) { + case 1 : + // InternalRos2Lexer.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 loop21; + } + } 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 { + // InternalRos2Lexer.g:254:19: ( ( '0' .. '9' )+ ) + // InternalRos2Lexer.g:254:21: ( '0' .. '9' )+ + { + // InternalRos2Lexer.g:254:21: ( '0' .. '9' )+ + int cnt22=0; + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( ((LA22_0>='0' && LA22_0<='9')) ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalRos2Lexer.g:254:22: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt22 >= 1 ) break loop22; + EarlyExitException eee = + new EarlyExitException(22, input); + throw eee; + } + cnt22++; + } while (true); + + + } + + } + 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; + // InternalRos2Lexer.g:256:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) + // InternalRos2Lexer.g:256:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + { + // InternalRos2Lexer.g:256:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0=='\"') ) { + alt25=1; + } + else if ( (LA25_0=='\'') ) { + alt25=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); + + throw nvae; + } + switch (alt25) { + case 1 : + // InternalRos2Lexer.g:256:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + { + match('\"'); + // InternalRos2Lexer.g:256:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop23: + do { + int alt23=3; + int LA23_0 = input.LA(1); + + if ( (LA23_0=='\\') ) { + alt23=1; + } + else if ( ((LA23_0>='\u0000' && LA23_0<='!')||(LA23_0>='#' && LA23_0<='[')||(LA23_0>=']' && LA23_0<='\uFFFF')) ) { + alt23=2; + } + + + switch (alt23) { + case 1 : + // InternalRos2Lexer.g:256:21: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos2Lexer.g:256: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 loop23; + } + } while (true); + + match('\"'); + + } + break; + case 2 : + // InternalRos2Lexer.g:256:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + { + match('\''); + // InternalRos2Lexer.g:256:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop24: + do { + int alt24=3; + int LA24_0 = input.LA(1); + + if ( (LA24_0=='\\') ) { + alt24=1; + } + else if ( ((LA24_0>='\u0000' && LA24_0<='&')||(LA24_0>='(' && LA24_0<='[')||(LA24_0>=']' && LA24_0<='\uFFFF')) ) { + alt24=2; + } + + + switch (alt24) { + case 1 : + // InternalRos2Lexer.g:256:54: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos2Lexer.g:256: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 loop24; + } + } 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; + // InternalRos2Lexer.g:258:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalRos2Lexer.g:258:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalRos2Lexer.g:258:24: ( options {greedy=false; } : . )* + loop26: + do { + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0=='*') ) { + int LA26_1 = input.LA(2); + + if ( (LA26_1=='/') ) { + alt26=2; + } + else if ( ((LA26_1>='\u0000' && LA26_1<='.')||(LA26_1>='0' && LA26_1<='\uFFFF')) ) { + alt26=1; + } + + + } + else if ( ((LA26_0>='\u0000' && LA26_0<=')')||(LA26_0>='+' && LA26_0<='\uFFFF')) ) { + alt26=1; + } + + + switch (alt26) { + case 1 : + // InternalRos2Lexer.g:258:52: . + { + matchAny(); + + } + break; + + default : + break loop26; + } + } 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; + // InternalRos2Lexer.g:260:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalRos2Lexer.g:260:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalRos2Lexer.g:260:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt27=0; + loop27: + do { + int alt27=2; + int LA27_0 = input.LA(1); + + if ( ((LA27_0>='\t' && LA27_0<='\n')||LA27_0=='\r'||LA27_0==' ') ) { + alt27=1; + } + + + switch (alt27) { + case 1 : + // InternalRos2Lexer.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 ( cnt27 >= 1 ) break loop27; + EarlyExitException eee = + new EarlyExitException(27, input); + throw eee; + } + cnt27++; + } 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; + // InternalRos2Lexer.g:262:16: ( . ) + // InternalRos2Lexer.g:262:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalRos2Lexer.g:1:8: ( ParameterStructMember | ExternalDependency | RelativeNamespace | PrivateNamespace | GlobalNamespace | Transient_local | Serviceclient | Serviceserver | Actionclient | Actionserver | Dependencies | Parameter_qos | ParameterAny | FromGitRepo | Reliability | Services_qos | Subscribers | Best_effort | Default_qos | Durability | Parameters | Publishers | Artifacts | Sensor_qos | GraphName | Feedback_1 | Float32_1 | Float64_1 | Keep_last | Response | Duration | Feedback | History | Keep_all | Message_1 | Profile | Reliable | Request | String_2 | Uint16_1 | Uint32_1 | Uint64_1 | Volatile | Boolean | Integer | Action_1 | Default | Float32 | Float64 | Int16_1 | Int32_1 | Int64_1 | Message | Result_1 | Service | Uint8_1 | Array | Base64 | Double | Header | String | Struct | Action | Bool_1 | Byte_1 | Depth | Int8_1 | Result | Specs | String_1 | Uint16 | Uint32 | Uint64 | Goal_1 | Int16 | Int32 | Int64 | Node_1 | Type_1 | Uint8 | Value | Date | List | Bool | Byte | Goal | Int8 | Msg | Name | Node | Qos | Srv | Time | Type | Any | Ns | LeftSquareBracketRightSquareBracket | Comma | Colon | LeftSquareBracket | RightSquareBracket | RightCurlyBracket | RULE_SL_COMMENT | RULE_ROS_CONVENTION_A | RULE_ROS_CONVENTION_PARAM | RULE_BINARY | RULE_BOOLEAN | RULE_DOUBLE | RULE_DECINT | RULE_DATE_TIME | RULE_MESSAGE_ASIGMENT | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt28=116; + alt28 = dfa28.predict(input); + switch (alt28) { + case 1 : + // InternalRos2Lexer.g:1:10: ParameterStructMember + { + mParameterStructMember(); + + } + break; + case 2 : + // InternalRos2Lexer.g:1:32: ExternalDependency + { + mExternalDependency(); + + } + break; + case 3 : + // InternalRos2Lexer.g:1:51: RelativeNamespace + { + mRelativeNamespace(); + + } + break; + case 4 : + // InternalRos2Lexer.g:1:69: PrivateNamespace + { + mPrivateNamespace(); + + } + break; + case 5 : + // InternalRos2Lexer.g:1:86: GlobalNamespace + { + mGlobalNamespace(); + + } + break; + case 6 : + // InternalRos2Lexer.g:1:102: Transient_local + { + mTransient_local(); + + } + break; + case 7 : + // InternalRos2Lexer.g:1:118: Serviceclient + { + mServiceclient(); + + } + break; + case 8 : + // InternalRos2Lexer.g:1:132: Serviceserver + { + mServiceserver(); + + } + break; + case 9 : + // InternalRos2Lexer.g:1:146: Actionclient + { + mActionclient(); + + } + break; + case 10 : + // InternalRos2Lexer.g:1:159: Actionserver + { + mActionserver(); + + } + break; + case 11 : + // InternalRos2Lexer.g:1:172: Dependencies + { + mDependencies(); + + } + break; + case 12 : + // InternalRos2Lexer.g:1:185: Parameter_qos + { + mParameter_qos(); + + } + break; + case 13 : + // InternalRos2Lexer.g:1:199: ParameterAny + { + mParameterAny(); + + } + break; + case 14 : + // InternalRos2Lexer.g:1:212: FromGitRepo + { + mFromGitRepo(); + + } + break; + case 15 : + // InternalRos2Lexer.g:1:224: Reliability + { + mReliability(); + + } + break; + case 16 : + // InternalRos2Lexer.g:1:236: Services_qos + { + mServices_qos(); + + } + break; + case 17 : + // InternalRos2Lexer.g:1:249: Subscribers + { + mSubscribers(); + + } + break; + case 18 : + // InternalRos2Lexer.g:1:261: Best_effort + { + mBest_effort(); + + } + break; + case 19 : + // InternalRos2Lexer.g:1:273: Default_qos + { + mDefault_qos(); + + } + break; + case 20 : + // InternalRos2Lexer.g:1:285: Durability + { + mDurability(); + + } + break; + case 21 : + // InternalRos2Lexer.g:1:296: Parameters + { + mParameters(); + + } + break; + case 22 : + // InternalRos2Lexer.g:1:307: Publishers + { + mPublishers(); + + } + break; + case 23 : + // InternalRos2Lexer.g:1:318: Artifacts + { + mArtifacts(); + + } + break; + case 24 : + // InternalRos2Lexer.g:1:328: Sensor_qos + { + mSensor_qos(); + + } + break; + case 25 : + // InternalRos2Lexer.g:1:339: GraphName + { + mGraphName(); + + } + break; + case 26 : + // InternalRos2Lexer.g:1:349: Feedback_1 + { + mFeedback_1(); + + } + break; + case 27 : + // InternalRos2Lexer.g:1:360: Float32_1 + { + mFloat32_1(); + + } + break; + case 28 : + // InternalRos2Lexer.g:1:370: Float64_1 + { + mFloat64_1(); + + } + break; + case 29 : + // InternalRos2Lexer.g:1:380: Keep_last + { + mKeep_last(); + + } + break; + case 30 : + // InternalRos2Lexer.g:1:390: Response + { + mResponse(); + + } + break; + case 31 : + // InternalRos2Lexer.g:1:399: Duration + { + mDuration(); + + } + break; + case 32 : + // InternalRos2Lexer.g:1:408: Feedback + { + mFeedback(); + + } + break; + case 33 : + // InternalRos2Lexer.g:1:417: History + { + mHistory(); + + } + break; + case 34 : + // InternalRos2Lexer.g:1:425: Keep_all + { + mKeep_all(); + + } + break; + case 35 : + // InternalRos2Lexer.g:1:434: Message_1 + { + mMessage_1(); + + } + break; + case 36 : + // InternalRos2Lexer.g:1:444: Profile + { + mProfile(); + + } + break; + case 37 : + // InternalRos2Lexer.g:1:452: Reliable + { + mReliable(); + + } + break; + case 38 : + // InternalRos2Lexer.g:1:461: Request + { + mRequest(); + + } + break; + case 39 : + // InternalRos2Lexer.g:1:469: String_2 + { + mString_2(); + + } + break; + case 40 : + // InternalRos2Lexer.g:1:478: Uint16_1 + { + mUint16_1(); + + } + break; + case 41 : + // InternalRos2Lexer.g:1:487: Uint32_1 + { + mUint32_1(); + + } + break; + case 42 : + // InternalRos2Lexer.g:1:496: Uint64_1 + { + mUint64_1(); + + } + break; + case 43 : + // InternalRos2Lexer.g:1:505: Volatile + { + mVolatile(); + + } + break; + case 44 : + // InternalRos2Lexer.g:1:514: Boolean + { + mBoolean(); + + } + break; + case 45 : + // InternalRos2Lexer.g:1:522: Integer + { + mInteger(); + + } + break; + case 46 : + // InternalRos2Lexer.g:1:530: Action_1 + { + mAction_1(); + + } + break; + case 47 : + // InternalRos2Lexer.g:1:539: Default + { + mDefault(); + + } + break; + case 48 : + // InternalRos2Lexer.g:1:547: Float32 + { + mFloat32(); + + } + break; + case 49 : + // InternalRos2Lexer.g:1:555: Float64 + { + mFloat64(); + + } + break; + case 50 : + // InternalRos2Lexer.g:1:563: Int16_1 + { + mInt16_1(); + + } + break; + case 51 : + // InternalRos2Lexer.g:1:571: Int32_1 + { + mInt32_1(); + + } + break; + case 52 : + // InternalRos2Lexer.g:1:579: Int64_1 + { + mInt64_1(); + + } + break; + case 53 : + // InternalRos2Lexer.g:1:587: Message + { + mMessage(); + + } + break; + case 54 : + // InternalRos2Lexer.g:1:595: Result_1 + { + mResult_1(); + + } + break; + case 55 : + // InternalRos2Lexer.g:1:604: Service + { + mService(); + + } + break; + case 56 : + // InternalRos2Lexer.g:1:612: Uint8_1 + { + mUint8_1(); + + } + break; + case 57 : + // InternalRos2Lexer.g:1:620: Array + { + mArray(); + + } + break; + case 58 : + // InternalRos2Lexer.g:1:626: Base64 + { + mBase64(); + + } + break; + case 59 : + // InternalRos2Lexer.g:1:633: Double + { + mDouble(); + + } + break; + case 60 : + // InternalRos2Lexer.g:1:640: Header + { + mHeader(); + + } + break; + case 61 : + // InternalRos2Lexer.g:1:647: String + { + mString(); + + } + break; + case 62 : + // InternalRos2Lexer.g:1:654: Struct + { + mStruct(); + + } + break; + case 63 : + // InternalRos2Lexer.g:1:661: Action + { + mAction(); + + } + break; + case 64 : + // InternalRos2Lexer.g:1:668: Bool_1 + { + mBool_1(); + + } + break; + case 65 : + // InternalRos2Lexer.g:1:675: Byte_1 + { + mByte_1(); + + } + break; + case 66 : + // InternalRos2Lexer.g:1:682: Depth + { + mDepth(); + + } + break; + case 67 : + // InternalRos2Lexer.g:1:688: Int8_1 + { + mInt8_1(); + + } + break; + case 68 : + // InternalRos2Lexer.g:1:695: Result + { + mResult(); + + } + break; + case 69 : + // InternalRos2Lexer.g:1:702: Specs + { + mSpecs(); + + } + break; + case 70 : + // InternalRos2Lexer.g:1:708: String_1 + { + mString_1(); + + } + break; + case 71 : + // InternalRos2Lexer.g:1:717: Uint16 + { + mUint16(); + + } + break; + case 72 : + // InternalRos2Lexer.g:1:724: Uint32 + { + mUint32(); + + } + break; + case 73 : + // InternalRos2Lexer.g:1:731: Uint64 + { + mUint64(); + + } + break; + case 74 : + // InternalRos2Lexer.g:1:738: Goal_1 + { + mGoal_1(); + + } + break; + case 75 : + // InternalRos2Lexer.g:1:745: Int16 + { + mInt16(); + + } + break; + case 76 : + // InternalRos2Lexer.g:1:751: Int32 + { + mInt32(); + + } + break; + case 77 : + // InternalRos2Lexer.g:1:757: Int64 + { + mInt64(); + + } + break; + case 78 : + // InternalRos2Lexer.g:1:763: Node_1 + { + mNode_1(); + + } + break; + case 79 : + // InternalRos2Lexer.g:1:770: Type_1 + { + mType_1(); + + } + break; + case 80 : + // InternalRos2Lexer.g:1:777: Uint8 + { + mUint8(); + + } + break; + case 81 : + // InternalRos2Lexer.g:1:783: Value + { + mValue(); + + } + break; + case 82 : + // InternalRos2Lexer.g:1:789: Date + { + mDate(); + + } + break; + case 83 : + // InternalRos2Lexer.g:1:794: List + { + mList(); + + } + break; + case 84 : + // InternalRos2Lexer.g:1:799: Bool + { + mBool(); + + } + break; + case 85 : + // InternalRos2Lexer.g:1:804: Byte + { + mByte(); + + } + break; + case 86 : + // InternalRos2Lexer.g:1:809: Goal + { + mGoal(); + + } + break; + case 87 : + // InternalRos2Lexer.g:1:814: Int8 + { + mInt8(); + + } + break; + case 88 : + // InternalRos2Lexer.g:1:819: Msg + { + mMsg(); + + } + break; + case 89 : + // InternalRos2Lexer.g:1:823: Name + { + mName(); + + } + break; + case 90 : + // InternalRos2Lexer.g:1:828: Node + { + mNode(); + + } + break; + case 91 : + // InternalRos2Lexer.g:1:833: Qos + { + mQos(); + + } + break; + case 92 : + // InternalRos2Lexer.g:1:837: Srv + { + mSrv(); + + } + break; + case 93 : + // InternalRos2Lexer.g:1:841: Time + { + mTime(); + + } + break; + case 94 : + // InternalRos2Lexer.g:1:846: Type + { + mType(); + + } + break; + case 95 : + // InternalRos2Lexer.g:1:851: Any + { + mAny(); + + } + break; + case 96 : + // InternalRos2Lexer.g:1:855: Ns + { + mNs(); + + } + break; + case 97 : + // InternalRos2Lexer.g:1:858: LeftSquareBracketRightSquareBracket + { + mLeftSquareBracketRightSquareBracket(); + + } + break; + case 98 : + // InternalRos2Lexer.g:1:894: Comma + { + mComma(); + + } + break; + case 99 : + // InternalRos2Lexer.g:1:900: Colon + { + mColon(); + + } + break; + case 100 : + // InternalRos2Lexer.g:1:906: LeftSquareBracket + { + mLeftSquareBracket(); + + } + break; + case 101 : + // InternalRos2Lexer.g:1:924: RightSquareBracket + { + mRightSquareBracket(); + + } + break; + case 102 : + // InternalRos2Lexer.g:1:943: RightCurlyBracket + { + mRightCurlyBracket(); + + } + break; + case 103 : + // InternalRos2Lexer.g:1:961: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 104 : + // InternalRos2Lexer.g:1:977: RULE_ROS_CONVENTION_A + { + mRULE_ROS_CONVENTION_A(); + + } + break; + case 105 : + // InternalRos2Lexer.g:1:999: RULE_ROS_CONVENTION_PARAM + { + mRULE_ROS_CONVENTION_PARAM(); + + } + break; + case 106 : + // InternalRos2Lexer.g:1:1025: RULE_BINARY + { + mRULE_BINARY(); + + } + break; + case 107 : + // InternalRos2Lexer.g:1:1037: RULE_BOOLEAN + { + mRULE_BOOLEAN(); + + } + break; + case 108 : + // InternalRos2Lexer.g:1:1050: RULE_DOUBLE + { + mRULE_DOUBLE(); + + } + break; + case 109 : + // InternalRos2Lexer.g:1:1062: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + case 110 : + // InternalRos2Lexer.g:1:1074: RULE_DATE_TIME + { + mRULE_DATE_TIME(); + + } + break; + case 111 : + // InternalRos2Lexer.g:1:1089: RULE_MESSAGE_ASIGMENT + { + mRULE_MESSAGE_ASIGMENT(); + + } + break; + case 112 : + // InternalRos2Lexer.g:1:1111: RULE_ID + { + mRULE_ID(); + + } + break; + case 113 : + // InternalRos2Lexer.g:1:1119: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 114 : + // InternalRos2Lexer.g:1:1131: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 115 : + // InternalRos2Lexer.g:1:1147: RULE_WS + { + mRULE_WS(); + + } + break; + case 116 : + // InternalRos2Lexer.g:1:1155: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA11 dfa11 = new DFA11(this); + protected DFA28 dfa28 = new DFA28(this); + static final String DFA11_eotS = + "\1\uffff\1\5\1\uffff\2\5\1\uffff\2\5"; + static final String DFA11_eofS = + "\10\uffff"; + static final String DFA11_minS = + "\1\56\1\60\1\uffff\2\60\1\uffff\2\60"; + static final String DFA11_maxS = + "\2\145\1\uffff\2\145\1\uffff\2\145"; + static final String DFA11_acceptS = + "\2\uffff\1\2\2\uffff\1\1\2\uffff"; + static final String DFA11_specialS = + "\10\uffff}>"; + static final String[] DFA11_transitionS = { + "\1\1\26\uffff\1\2\37\uffff\1\2", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2" + }; + + static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); + static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); + static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); + static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); + static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); + static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); + static final short[][] DFA11_transition; + + static { + int numStates = DFA11_transitionS.length; + DFA11_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA28_transitionS = { + "\11\57\2\56\2\57\1\56\22\57\1\56\1\57\1\47\1\42\3\57\1\50\4\57\1\36\1\54\1\57\1\43\1\52\2\53\7\55\1\37\6\57\1\25\1\22\1\45\1\26\1\2\1\45\1\4\1\27\1\23\2\45\1\33\3\45\1\1\1\45\1\3\1\30\7\45\1\35\1\57\1\40\1\44\1\45\1\57\1\7\1\14\1\45\1\10\1\45\1\12\1\31\1\16\1\24\1\45\1\15\1\45\1\17\1\32\1\45\1\11\1\34\1\13\1\6\1\5\1\20\1\21\4\45\2\57\1\41\1\51\uff81\57", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\60\20\62\1\61\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\27\62\1\65\2\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\66\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\67\5\62\1\70\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\73\10\62\1\71\6\62\1\72\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\74\12\62\1\77\1\62\1\100\1\62\1\76\1\75\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\101\16\62\1\102\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\103\17\62\1\104\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\105\20\62\1\107\2\62\1\106\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\113\3\62\1\111\6\62\1\112\5\62\1\110\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\114\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\115\11\62\1\116\11\62\1\117\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\120\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\121\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\122\15\62\1\123\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\124\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\126\15\62\1\125\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\130\15\62\1\127\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\131\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\132\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\134\3\62\1\133\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\136\15\62\1\135\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\137\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\140\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\141\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\143\15\62\1\142\3\62\1\144\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\145\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\146\13\62", + "\1\147", + "", + "", + "", + "", + "", + "\1\157\4\uffff\1\157\2\uffff\1\156\26\uffff\32\46\3\uffff\2\46\1\uffff\32\46", + "\32\160\4\uffff\1\160\1\uffff\32\160", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\42\162\1\163\71\162\1\161\uffa3\162", + "\47\165\1\166\64\165\1\164\uffa3\165", + "\1\157\4\uffff\1\157", + "\1\172\1\uffff\12\170\10\uffff\1\167\2\uffff\1\172\34\uffff\1\167\2\uffff\1\172", + "\1\172\1\uffff\12\173\13\uffff\1\172\37\uffff\1\172", + "\12\171", + "\1\172\26\uffff\1\172\37\uffff\1\172", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\175\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\176\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\177\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0080\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0081\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0082\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0083\23\62\1\u0084\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0085\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u0086\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0088\3\62\1\u0087\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u0089\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u008a\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u008b\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u008c\4\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u008d\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u008e\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u0090\11\62\1\u008f\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0091\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0092\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u0093\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0094\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0095\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0096\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0097\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0098\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0099\4\62\1\u009b\1\62\1\u009a\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u009c\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u009d\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u009e\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u009f\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00a0\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00a1\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u00a2\23\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u00a3\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00a4\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00a5\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u00a6\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00a7\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00a8\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00a9\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u00aa\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u00ab\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u00ac\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00ad\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00ae\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u00af\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00b0\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u00b1\26\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u00b2\15\62", + "\1\46\12\62\1\u00b3\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00b4\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00b5\7\62", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\0\u00b6", + "\42\162\1\163\71\162\1\161\uffa3\162", + "\1\157\15\uffff\1\64", + "\0\u00b8", + "\47\165\1\166\64\165\1\164\uffa3\165", + "\1\157\15\uffff\1\64", + "", + "", + "", + "", + "\12\u00b9", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00ba\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u00bb\4\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00bc\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00bd\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u00be\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u00bf\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u00c0\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00c1\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00c2\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00c3\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u00c4\4\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00c5\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00c6\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00c7\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u00c8\27\62", + "\1\46\12\62\1\u00c9\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00ca\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00cb\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00cc\16\62\1\u00cd\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00ce\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00cf\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00d0\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00d1\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u00d2\24\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u00d3\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u00d4\26\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00d5\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00d6\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00d7\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u00d8\4\62\1\u00d9\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u00da\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00db\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00dc\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00dd\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u00de\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00df\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00e0\7\62", + "\1\46\12\62\1\u00e1\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00e2\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00e3\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u00e4\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00e5\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00e6\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00e7\25\62", + "\1\46\1\62\1\u00e8\1\62\1\u00e9\2\62\1\u00ea\1\62\1\u00eb\1\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00ec\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u00ee\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00ef\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u00f0\26\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00f1\13\62\1\u00f2\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00f3\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00f4\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00f5\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00f6\6\62", + "\1\46\12\62\1\u00f7\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\42\162\1\163\71\162\1\161\uffa3\162", + "", + "\47\165\1\166\64\165\1\164\uffa3\165", + "\12\u00f8", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u00f9\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00fa\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u00fb\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00fc\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00fd\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\7\62\1\u00fe\22\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00ff\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0101\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0104\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0105\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0106\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0107\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0108\7\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0109\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u010a\24\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u010b\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\7\62\1\u010c\22\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u010d\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u010e\21\62\1\u010f\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u0110\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0111\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0112\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\6\62\1\u0113\23\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u0114\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0115\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0116\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0117\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0118\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0119\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u011a\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u011b\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u011c\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u011e\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u0120\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0121\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0122\31\62", + "", + "\1\46\1\62\1\u0123\1\62\1\u0124\2\62\1\u0125\1\62\1\u0126\1\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0127\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0128\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0129\25\62", + "\1\46\6\62\1\u012a\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u012b\23\62", + "\1\46\6\62\1\u012c\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\2\62\1\u012d\7\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\4\62\1\u012e\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u012f\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u0131\1\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0132\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0134\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0135\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0136\27\62", + "\1\46\12\62\1\u0137\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0139\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\170", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u013d\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u013e\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u013f\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0140\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0141\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\15\62\1\u0142\14\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0143\21\62", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0144\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0145\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0146\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u0147\23\62", + "\1\46\12\62\1\u0148\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0149\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u014a\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u014b\26\62", + "\1\46\12\62\1\u014c\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u014d\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u014e\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u014f\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0150\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0151\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0152\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0153\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0154\31\62", + "\1\46\3\62\1\u0155\2\62\1\u0156\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u0157\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0158\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0159\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u015a\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u015b\25\62", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u015d\12\62\1\u015c\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u015e\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u015f\23\62", + "\1\46\6\62\1\u0160\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\2\62\1\u0161\7\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\4\62\1\u0162\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u0163\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0165\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0167\31\62", + "\1\46\4\62\1\u0168\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0169\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u016a\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u016c\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u016e\3\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\46\12\62\1\u0170\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0171\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0172\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u0173\23\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0174\6\62", + "", + "", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0175\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0176\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0177\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u0178\4\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\15\62\1\u0179\14\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u017a\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u017b\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u017c\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u017d\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u017e\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u017f\3\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\1\u0183\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0181\17\62\1\u0182\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0185\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0186\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0187\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0188\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0189\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u018a\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\7\62\1\u018b\22\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u018c\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u018d\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u018e\27\62", + "\1\46\2\62\1\u018f\7\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\4\62\1\u0190\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0191\2\62\1\u0192\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0193\7\62", + "\1\46\12\62\1\u0194\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0196\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u0197\24\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0198\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0199\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u019a\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u019b\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u019c\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u019e\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u01a0\3\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01a2\16\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01a3\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01a5\10\62", + "", + "", + "", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01aa\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\15\62\1\u01ab\14\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01ac\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01ad\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u01ae\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u01af\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01b0\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u01b1\17\62\1\u01b2\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\20\62\1\u01b4\11\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u01b5\30\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01b6\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01b7\25\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u01b8\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01b9\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u01ba\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u01bc\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01bd\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01be\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01bf\25\62", + "\1\46\12\62\1\u01c0\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\21\62\1\u01c1\10\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\12\62\1\u01c2\17\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u01c3\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u01c5\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01c7\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01c8\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01c9\25\62", + "", + "", + "\1\46\12\62\1\u01ca\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u01cb\24\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u01cc\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01cd\16\62", + "\1\46\12\62\1\u01ce\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u01cf\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01d1\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01d4\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u01d5\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\3\62\1\u01d6\26\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\15\62\1\u01d7\14\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u01d8\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01d9\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u01da\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01db\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u01dd\1\uffff\4\62\1\u01dc\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u01de\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01df\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u01e0\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01e1\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u01e2\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u01e3\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\20\62\1\u01e4\11\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u01e5\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01e7\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01e8\10\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01e9\25\62", + "\1\46\12\62\1\u01ea\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u01ec\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u01ee\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u01ef\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u01f0\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\1\u01f4\21\62\1\u01f3\7\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u01f5\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01f6\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u01f7\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01f8\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u01fa\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u01fb\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01fc\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\20\62\1\u01fd\11\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u01fe\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01ff\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0200\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u0201\4\62", + "\1\46\12\62\1\u0202\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0203\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0204\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u0205\1\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u0206\1\uffff\22\62\1\u0207\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0208\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0209\12\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u020a\6\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u020b\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u020d\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u020e\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u020f\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0210\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u0211\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0212\7\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0213\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0214\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u0215\4\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0216\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0218\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0219\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u021a\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u021b\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u021c\7\62", + "\1\46\12\62\1\u021d\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\20\62\1\u021e\11\62", + "\1\46\12\62\1\u021f\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0220\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0221\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u0222\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0223\6\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0224\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u0225\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0226\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0227\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0228\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0229\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u022a\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u022b\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u022c\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u022d\7\62", + "", + "\1\46\12\62\1\u022e\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u022f\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0230\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0231\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0233\13\62", + "", + "", + "\1\46\12\62\1\u0234\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0235\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u0237\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0239\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u023a\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u023b\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u023c\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u023d\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u023e\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u023f\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\1\u0241\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0242\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0243\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0244\7\62", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0245\27\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0246\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u0247\26\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0248\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0249\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u024a\31\62", + "\1\46\12\62\1\u024b\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u024c\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u024e\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u024f\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0250\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0251\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0252\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0253\16\62", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\14\62\1\u0254\15\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0255\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0256\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0257\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u025a\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u025c\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u025d\25\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u025e\15\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u025f\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u0261\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0263\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0264\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "" + }; + + static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS); + static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS); + static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS); + static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS); + static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS); + static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS); + static final short[][] DFA28_transition; + + static { + int numStates = DFA28_transitionS.length; + DFA28_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA28_114<='!')||(LA28_114>='#' && LA28_114<='[')||(LA28_114>=']' && LA28_114<='\uFFFF')) ) {s = 114;} + + if ( s>=0 ) return s; + break; + case 1 : + int LA28_40 = input.LA(1); + + s = -1; + if ( (LA28_40=='\\') ) {s = 116;} + + else if ( ((LA28_40>='\u0000' && LA28_40<='&')||(LA28_40>='(' && LA28_40<='[')||(LA28_40>=']' && LA28_40<='\uFFFF')) ) {s = 117;} + + else if ( (LA28_40=='\'') ) {s = 118;} + + else s = 47; + + if ( s>=0 ) return s; + break; + case 2 : + int LA28_184 = input.LA(1); + + s = -1; + if ( (LA28_184=='\'') ) {s = 118;} + + else if ( (LA28_184=='\\') ) {s = 116;} + + else if ( ((LA28_184>='\u0000' && LA28_184<='&')||(LA28_184>='(' && LA28_184<='[')||(LA28_184>=']' && LA28_184<='\uFFFF')) ) {s = 117;} + + if ( s>=0 ) return s; + break; + case 3 : + int LA28_117 = input.LA(1); + + s = -1; + if ( (LA28_117=='\'') ) {s = 118;} + + else if ( (LA28_117=='\\') ) {s = 116;} + + else if ( ((LA28_117>='\u0000' && LA28_117<='&')||(LA28_117>='(' && LA28_117<='[')||(LA28_117>=']' && LA28_117<='\uFFFF')) ) {s = 117;} + + if ( s>=0 ) return s; + break; + case 4 : + int LA28_113 = input.LA(1); + + s = -1; + if ( ((LA28_113>='\u0000' && LA28_113<='\uFFFF')) ) {s = 182;} + + if ( s>=0 ) return s; + break; + case 5 : + int LA28_0 = input.LA(1); + + s = -1; + if ( (LA28_0=='P') ) {s = 1;} + + else if ( (LA28_0=='E') ) {s = 2;} + + else if ( (LA28_0=='R') ) {s = 3;} + + else if ( (LA28_0=='G') ) {s = 4;} + + else if ( (LA28_0=='t') ) {s = 5;} + + else if ( (LA28_0=='s') ) {s = 6;} + + else if ( (LA28_0=='a') ) {s = 7;} + + else if ( (LA28_0=='d') ) {s = 8;} + + else if ( (LA28_0=='p') ) {s = 9;} + + else if ( (LA28_0=='f') ) {s = 10;} + + else if ( (LA28_0=='r') ) {s = 11;} + + else if ( (LA28_0=='b') ) {s = 12;} + + else if ( (LA28_0=='k') ) {s = 13;} + + else if ( (LA28_0=='h') ) {s = 14;} + + else if ( (LA28_0=='m') ) {s = 15;} + + else if ( (LA28_0=='u') ) {s = 16;} + + else if ( (LA28_0=='v') ) {s = 17;} + + else if ( (LA28_0=='B') ) {s = 18;} + + else if ( (LA28_0=='I') ) {s = 19;} + + else if ( (LA28_0=='i') ) {s = 20;} + + else if ( (LA28_0=='A') ) {s = 21;} + + else if ( (LA28_0=='D') ) {s = 22;} + + else if ( (LA28_0=='H') ) {s = 23;} + + else if ( (LA28_0=='S') ) {s = 24;} + + else if ( (LA28_0=='g') ) {s = 25;} + + else if ( (LA28_0=='n') ) {s = 26;} + + else if ( (LA28_0=='L') ) {s = 27;} + + else if ( (LA28_0=='q') ) {s = 28;} + + else if ( (LA28_0=='[') ) {s = 29;} + + else if ( (LA28_0==',') ) {s = 30;} + + else if ( (LA28_0==':') ) {s = 31;} + + else if ( (LA28_0==']') ) {s = 32;} + + else if ( (LA28_0=='}') ) {s = 33;} + + else if ( (LA28_0=='#') ) {s = 34;} + + else if ( (LA28_0=='/') ) {s = 35;} + + else if ( (LA28_0=='^') ) {s = 36;} + + else if ( (LA28_0=='C'||LA28_0=='F'||(LA28_0>='J' && LA28_0<='K')||(LA28_0>='M' && LA28_0<='O')||LA28_0=='Q'||(LA28_0>='T' && LA28_0<='Z')||LA28_0=='_'||LA28_0=='c'||LA28_0=='e'||LA28_0=='j'||LA28_0=='l'||LA28_0=='o'||(LA28_0>='w' && LA28_0<='z')) ) {s = 37;} + + else if ( (LA28_0=='\"') ) {s = 39;} + + else if ( (LA28_0=='\'') ) {s = 40;} + + else if ( (LA28_0=='~') ) {s = 41;} + + else if ( (LA28_0=='0') ) {s = 42;} + + else if ( ((LA28_0>='1' && LA28_0<='2')) ) {s = 43;} + + else if ( (LA28_0=='-') ) {s = 44;} + + else if ( ((LA28_0>='3' && LA28_0<='9')) ) {s = 45;} + + else if ( ((LA28_0>='\t' && LA28_0<='\n')||LA28_0=='\r'||LA28_0==' ') ) {s = 46;} + + else if ( ((LA28_0>='\u0000' && LA28_0<='\b')||(LA28_0>='\u000B' && LA28_0<='\f')||(LA28_0>='\u000E' && LA28_0<='\u001F')||LA28_0=='!'||(LA28_0>='$' && LA28_0<='&')||(LA28_0>='(' && LA28_0<='+')||LA28_0=='.'||(LA28_0>=';' && LA28_0<='@')||LA28_0=='\\'||LA28_0=='`'||(LA28_0>='{' && LA28_0<='|')||(LA28_0>='\u007F' && LA28_0<='\uFFFF')) ) {s = 47;} + + else s = 38; + + if ( s>=0 ) return s; + break; + case 6 : + int LA28_116 = input.LA(1); + + s = -1; + if ( ((LA28_116>='\u0000' && LA28_116<='\uFFFF')) ) {s = 184;} + + if ( s>=0 ) return s; + break; + case 7 : + int LA28_39 = input.LA(1); + + s = -1; + if ( (LA28_39=='\\') ) {s = 113;} + + else if ( ((LA28_39>='\u0000' && LA28_39<='!')||(LA28_39>='#' && LA28_39<='[')||(LA28_39>=']' && LA28_39<='\uFFFF')) ) {s = 114;} + + else if ( (LA28_39=='\"') ) {s = 115;} + + else s = 47; + + if ( s>=0 ) return s; + break; + case 8 : + int LA28_182 = input.LA(1); + + s = -1; + if ( (LA28_182=='\"') ) {s = 115;} + + else if ( (LA28_182=='\\') ) {s = 113;} + + else if ( ((LA28_182>='\u0000' && LA28_182<='!')||(LA28_182>='#' && LA28_182<='[')||(LA28_182>=']' && LA28_182<='\uFFFF')) ) {s = 114;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 28, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/lexer/InternalRos2Lexer.tokens b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/lexer/InternalRos2Lexer.tokens new file mode 100644 index 000000000..7e6b6a747 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src-gen/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/lexer/InternalRos2Lexer.tokens @@ -0,0 +1,125 @@ +Action=66 +Action_1=49 +Actionclient=12 +Actionserver=13 +Any=98 +Array=60 +Artifacts=26 +Base64=61 +Best_effort=21 +Bool=87 +Bool_1=67 +Boolean=47 +Byte=88 +Byte_1=68 +Colon=102 +Comma=101 +Date=85 +Default=50 +Default_qos=22 +Dependencies=14 +Depth=69 +Double=62 +Durability=23 +Duration=34 +ExternalDependency=5 +Feedback=35 +Feedback_1=29 +Float32=51 +Float32_1=30 +Float64=52 +Float64_1=31 +FromGitRepo=17 +GlobalNamespace=8 +Goal=89 +Goal_1=77 +GraphName=28 +Header=63 +History=36 +Int16=78 +Int16_1=53 +Int32=79 +Int32_1=54 +Int64=80 +Int64_1=55 +Int8=90 +Int8_1=70 +Integer=48 +Keep_all=37 +Keep_last=32 +LeftSquareBracket=103 +LeftSquareBracketRightSquareBracket=100 +List=86 +Message=56 +Message_1=38 +Msg=91 +Name=92 +Node=93 +Node_1=81 +Ns=99 +ParameterAny=16 +ParameterStructMember=4 +Parameter_qos=15 +Parameters=24 +PrivateNamespace=7 +Profile=39 +Publishers=25 +Qos=94 +RULE_ANY_OTHER=128 +RULE_BEGIN=106 +RULE_BINARY=114 +RULE_BOOLEAN=115 +RULE_DATE_TIME=123 +RULE_DAY=118 +RULE_DECINT=116 +RULE_DIGIT=113 +RULE_DOUBLE=117 +RULE_END=107 +RULE_HOUR=121 +RULE_ID=109 +RULE_INT=124 +RULE_MESSAGE_ASIGMENT=125 +RULE_MIN_SEC=122 +RULE_ML_COMMENT=126 +RULE_MONTH=119 +RULE_ROS_CONVENTION_A=110 +RULE_ROS_CONVENTION_PARAM=112 +RULE_SL_COMMENT=108 +RULE_STRING=111 +RULE_WS=127 +RULE_YEAR=120 +RelativeNamespace=6 +Reliability=18 +Reliable=40 +Request=41 +Response=33 +Result=71 +Result_1=57 +RightCurlyBracket=105 +RightSquareBracket=104 +Sensor_qos=27 +Service=58 +Serviceclient=10 +Services_qos=19 +Serviceserver=11 +Specs=72 +Srv=95 +String=64 +String_1=73 +String_2=42 +Struct=65 +Subscribers=20 +Time=96 +Transient_local=9 +Type=97 +Type_1=82 +Uint16=74 +Uint16_1=43 +Uint32=75 +Uint32_1=44 +Uint64=76 +Uint64_1=45 +Uint8=83 +Uint8_1=59 +Value=84 +Volatile=46 diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src/de/fraunhofer/ipa/ros2/ide/Ros2IdeModule.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src/de/fraunhofer/ipa/ros2/ide/Ros2IdeModule.java new file mode 100644 index 000000000..a2b4fc9db --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src/de/fraunhofer/ipa/ros2/ide/Ros2IdeModule.java @@ -0,0 +1,11 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.ide; + + +/** + * Use this class to register ide components. + */ +public class Ros2IdeModule extends AbstractRos2IdeModule { +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src/de/fraunhofer/ipa/ros2/ide/Ros2IdeSetup.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src/de/fraunhofer/ipa/ros2/ide/Ros2IdeSetup.java new file mode 100644 index 000000000..5d993567e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src/de/fraunhofer/ipa/ros2/ide/Ros2IdeSetup.java @@ -0,0 +1,22 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.ide; + +import com.google.inject.Guice; +import com.google.inject.Injector; +import de.fraunhofer.ipa.ros2.Ros2RuntimeModule; +import de.fraunhofer.ipa.ros2.Ros2StandaloneSetup; +import org.eclipse.xtext.util.Modules2; + +/** + * Initialization support for running Xtext languages as language servers. + */ +public class Ros2IdeSetup extends Ros2StandaloneSetup { + + @Override + public Injector createInjector() { + return Guice.createInjector(Modules2.mixin(new Ros2RuntimeModule(), new Ros2IdeModule())); + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/Ros2TokenSource.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/Ros2TokenSource.java new file mode 100644 index 000000000..f996bd061 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ide/src/de/fraunhofer/ipa/ros2/ide/contentassist/antlr/Ros2TokenSource.java @@ -0,0 +1,39 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.ide.contentassist.antlr; + +import de.fraunhofer.ipa.ros2.ide.contentassist.antlr.internal.InternalRos2Parser; +import org.antlr.runtime.Token; +import org.antlr.runtime.TokenSource; +import org.eclipse.xtext.parser.antlr.AbstractIndentationTokenSource; + +public class Ros2TokenSource extends AbstractIndentationTokenSource { + + public Ros2TokenSource(TokenSource delegate) { + super(delegate); + } + + @Override + protected boolean shouldSplitTokenImpl(Token token) { + // TODO Review assumption + return token.getType() == InternalRos2Parser.RULE_WS; + } + + @Override + protected int getBeginTokenType() { + // TODO Review assumption + return InternalRos2Parser.RULE_BEGIN; + } + + @Override + protected int getEndTokenType() { + // TODO Review assumption + return InternalRos2Parser.RULE_END; + } + + @Override + protected boolean shouldEmitPendingEndTokens() { + return false; + } +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/.classpath b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/.classpath new file mode 100644 index 000000000..a61354428 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/.classpath @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/.project b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/.project new file mode 100644 index 000000000..5cdc434b3 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/.project @@ -0,0 +1,34 @@ + + + de.fraunhofer.ipa.ros2.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.ros2.xtext.ui/.settings/org.eclipse.core.resources.prefs b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 000000000..99f26c020 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.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.ros2.xtext.ui/.settings/org.eclipse.jdt.core.prefs b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000..7adc0fb9a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.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.ros2.xtext.ui/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/META-INF/MANIFEST.MF new file mode 100644 index 000000000..2591c448c --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/META-INF/MANIFEST.MF @@ -0,0 +1,27 @@ +Manifest-Version: 1.0 +Automatic-Module-Name: de.fraunhofer.ipa.ros2.xtext.ui +Bundle-ManifestVersion: 2 +Bundle-Name: de.fraunhofer.ipa.ros2.xtext.ui +Bundle-Vendor: Fraunhofer IPA +Bundle-Version: 2.0.0.qualifier +Bundle-SymbolicName: de.fraunhofer.ipa.ros2.xtext.ui; singleton:=true +Bundle-ActivationPolicy: lazy +Require-Bundle: de.fraunhofer.ipa.ros2.xtext, + de.fraunhofer.ipa.ros2.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", + de.fraunhofer.ipa.ros.xtext;bundle-version="2.0.0", + de.fraunhofer.ipa.ros.xtext.ui;bundle-version="2.0.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.ros2.ui.quickfix, + de.fraunhofer.ipa.ros2.ui.contentassist, + de.fraunhofer.ipa.ros2.xtext.ui.internal +Bundle-Activator: de.fraunhofer.ipa.ros2.xtext.ui.internal.XtextActivator diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/build.properties b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/build.properties new file mode 100644 index 000000000..323f56c51 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.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.ros2.xtext.ui/plugin.xml b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/plugin.xml new file mode 100644 index 000000000..dd20cb901 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/plugin.xml @@ -0,0 +1,434 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/pom.xml b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/pom.xml new file mode 100644 index 000000000..8dd07eb24 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/pom.xml @@ -0,0 +1,33 @@ + + 4.0.0 + + de.fraunhofer.ipa.ros + de.fraunhofer.ipa.ros.parent + 2.0.0-SNAPSHOT + ../de.fraunhofer.ipa.ros.parent/pom.xml + + de.fraunhofer.ipa.ros2.xtext.ui + eclipse-plugin + + + + + org.eclipse.xtend + xtend-maven-plugin + + + org.apache.maven.plugins + maven-clean-plugin + + + xtend-gen-clean + clean + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/ui/AbstractRos2UiModule.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/ui/AbstractRos2UiModule.java new file mode 100644 index 000000000..cb16cc593 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/ui/AbstractRos2UiModule.java @@ -0,0 +1,307 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.ui; + +import com.google.inject.Binder; +import com.google.inject.Provider; +import com.google.inject.name.Names; +import de.fraunhofer.ipa.ros2.ide.contentassist.antlr.PartialRos2ContentAssistParser; +import de.fraunhofer.ipa.ros2.ide.contentassist.antlr.Ros2Parser; +import de.fraunhofer.ipa.ros2.ide.contentassist.antlr.lexer.InternalRos2Lexer; +import de.fraunhofer.ipa.ros2.ui.contentassist.Ros2ProposalProvider; +import de.fraunhofer.ipa.ros2.ui.labeling.Ros2DescriptionLabelProvider; +import de.fraunhofer.ipa.ros2.ui.labeling.Ros2LabelProvider; +import de.fraunhofer.ipa.ros2.ui.outline.Ros2OutlineTreeProvider; +import de.fraunhofer.ipa.ros2.ui.quickfix.Ros2QuickfixProvider; +import de.fraunhofer.ipa.ros2.validation.Ros2ValidatorConfigurationBlock; +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.formatting.IContentFormatterFactory; +import org.eclipse.xtext.ui.editor.formatting2.ContentFormatterFactory; +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 Ros2UiModule}. + */ +@SuppressWarnings("all") +public abstract class AbstractRos2UiModule extends DefaultUiModule { + + public AbstractRos2UiModule(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(InternalRos2Lexer.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.ros2.parser.antlr.lexer.InternalRos2Lexer.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 Ros2Parser.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public void configureContentAssistLexerProvider(Binder binder) { + binder.bind(InternalRos2Lexer.class).toProvider(LexerProvider.create(InternalRos2Lexer.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 Ros2ValidatorConfigurationBlock.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.formatting.Formatter2Fragment2 + public Class bindIContentFormatterFactory() { + return ContentFormatterFactory.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.labeling.LabelProviderFragment2 + public Class bindILabelProvider() { + return Ros2LabelProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.labeling.LabelProviderFragment2 + public void configureResourceUIServiceLabelProvider(Binder binder) { + binder.bind(ILabelProvider.class).annotatedWith(ResourceServiceDescriptionLabelProvider.class).to(Ros2DescriptionLabelProvider.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.outline.OutlineTreeProviderFragment2 + public Class bindIOutlineTreeProvider() { + return Ros2OutlineTreeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.outline.OutlineTreeProviderFragment2 + public Class bindIOutlineTreeStructureProvider() { + return Ros2OutlineTreeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.quickfix.QuickfixProviderFragment2 + public Class bindIssueResolutionProvider() { + return Ros2QuickfixProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.contentAssist.ContentAssistFragment2 + public Class bindIContentProposalProvider() { + return Ros2ProposalProvider.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 PartialRos2ContentAssistParser.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("Ros2 Compare"); + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/ui/Ros2ExecutableExtensionFactory.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/ui/Ros2ExecutableExtensionFactory.java new file mode 100644 index 000000000..101f284b4 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/ui/Ros2ExecutableExtensionFactory.java @@ -0,0 +1,29 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.ui; + +import com.google.inject.Injector; +import de.fraunhofer.ipa.ros2.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 Ros2ExecutableExtensionFactory 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_ROS2_ROS2) : null; + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/ui/contentassist/AbstractRos2ProposalProvider.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/ui/contentassist/AbstractRos2ProposalProvider.java new file mode 100644 index 000000000..b8d58ef99 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/ui/contentassist/AbstractRos2ProposalProvider.java @@ -0,0 +1,66 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.ui.contentassist; + +import de.fraunhofer.ipa.ros.ui.contentassist.RosProposalProvider; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.Assignment; +import org.eclipse.xtext.RuleCall; +import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext; +import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor; + +/** + * Represents a generated, default implementation of superclass {@link RosProposalProvider}. + * Methods are dynamically dispatched on the first parameter, i.e., you can override them + * with a more concrete subtype. + */ +public abstract class AbstractRos2ProposalProvider extends RosProposalProvider { + + public void completeQualityOfService_QoSProfile(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + // subclasses may override + // subclasses may override + // subclasses may override + } + public void completeQualityOfService_History(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + // subclasses may override + } + public void completeQualityOfService_Depth(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeQualityOfService_Reliability(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + // subclasses may override + } + public void completeQualityOfService_Durability(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + // subclasses may override + } + public void completePublisher_Qos(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeSubscriber_Qos(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeServiceServer_Qos(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeServiceClient_Qos(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeActionServer_Qos(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeActionClient_Qos(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeParameter_Qos(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + + public void complete_QualityOfService(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/validation/Ros2ValidatorConfigurationBlock.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/validation/Ros2ValidatorConfigurationBlock.java new file mode 100644 index 000000000..244a3d50e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/validation/Ros2ValidatorConfigurationBlock.java @@ -0,0 +1,35 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.validation; + +import org.eclipse.jface.dialogs.IDialogSettings; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.xtext.ui.validation.AbstractValidatorConfigurationBlock; + +@SuppressWarnings("restriction") +public class Ros2ValidatorConfigurationBlock extends AbstractValidatorConfigurationBlock { + + protected static final String SETTINGS_SECTION_NAME = "Ros2"; + + @Override + protected void fillSettingsPage(Composite composite, int nColumns, int defaultIndent) { + addComboBox(Ros2ConfigurableIssueCodesProvider.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.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/xtext/ui/internal/XtextActivator.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/xtext/ui/internal/XtextActivator.java new file mode 100644 index 000000000..1a7777718 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src-gen/de/fraunhofer/ipa/ros2/xtext/ui/internal/XtextActivator.java @@ -0,0 +1,94 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.xtext.ui.internal; + +import com.google.common.collect.Maps; +import com.google.inject.Guice; +import com.google.inject.Injector; +import de.fraunhofer.ipa.ros2.Ros2RuntimeModule; +import de.fraunhofer.ipa.ros2.ui.Ros2UiModule; +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.ros2.xtext.ui"; + public static final String DE_FRAUNHOFER_IPA_ROS2_ROS2 = "de.fraunhofer.ipa.ros2.Ros2"; + + 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_ROS2_ROS2.equals(grammar)) { + return new Ros2RuntimeModule(); + } + throw new IllegalArgumentException(grammar); + } + + protected com.google.inject.Module getUiModule(String grammar) { + if (DE_FRAUNHOFER_IPA_ROS2_ROS2.equals(grammar)) { + return new Ros2UiModule(this); + } + throw new IllegalArgumentException(grammar); + } + + protected com.google.inject.Module getSharedStateModule() { + return new SharedStateModule(); + } + + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/Ros2UiModule.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/Ros2UiModule.java new file mode 100644 index 000000000..9e3ff0d42 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/Ros2UiModule.java @@ -0,0 +1,28 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.ui; + +import org.eclipse.ui.plugin.AbstractUIPlugin; +import org.eclipse.xtext.ui.editor.contentassist.XtextContentAssistProcessor; + +import com.google.inject.Binder; + +/** + * Use this class to register components to be used within the Eclipse IDE. + */ +public class Ros2UiModule extends AbstractRos2UiModule { + + public Ros2UiModule(AbstractUIPlugin plugin) { + super(plugin); + } + + @Override + public void configure(Binder binder) { + super.configure(binder); + binder.bind(String.class) + .annotatedWith(com.google.inject.name.Names.named( + (XtextContentAssistProcessor.COMPLETION_AUTO_ACTIVATION_CHARS))) + .toInstance(".,:"); + } +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/contentassist/Ros2ProposalProvider.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/contentassist/Ros2ProposalProvider.java new file mode 100644 index 000000000..527de5c65 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/contentassist/Ros2ProposalProvider.java @@ -0,0 +1,12 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.ui.contentassist; + + +/** + * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#content-assist + * on how to customize the content assistant. + */ +public class Ros2ProposalProvider extends AbstractRos2ProposalProvider { +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/labeling/Ros2DescriptionLabelProvider.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/labeling/Ros2DescriptionLabelProvider.java new file mode 100644 index 000000000..745b013dd --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/labeling/Ros2DescriptionLabelProvider.java @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.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 Ros2DescriptionLabelProvider 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.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/labeling/Ros2LabelProvider.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/labeling/Ros2LabelProvider.java new file mode 100644 index 000000000..d53ddb6ad --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/labeling/Ros2LabelProvider.java @@ -0,0 +1,31 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.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 Ros2LabelProvider extends DefaultEObjectLabelProvider { + + @Inject + public Ros2LabelProvider(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.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/outline/Ros2OutlineTreeProvider.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/outline/Ros2OutlineTreeProvider.java new file mode 100644 index 000000000..afe267dc2 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/outline/Ros2OutlineTreeProvider.java @@ -0,0 +1,15 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.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 Ros2OutlineTreeProvider extends DefaultOutlineTreeProvider { + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/quickfix/Ros2QuickfixProvider.java b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/quickfix/Ros2QuickfixProvider.java new file mode 100644 index 000000000..fcc0c4988 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext.ui/src/de/fraunhofer/ipa/ros2/ui/quickfix/Ros2QuickfixProvider.java @@ -0,0 +1,26 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.ui.quickfix; + +import de.fraunhofer.ipa.ros.ui.quickfix.RosQuickfixProvider; + +/** + * Custom quickfixes. + * + * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#quick-fixes + */ +public class Ros2QuickfixProvider extends RosQuickfixProvider { + +// @Fix(Ros2Validator.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.ros2.xtext/.classpath b/plugins/de.fraunhofer.ipa.ros2.xtext/.classpath new file mode 100644 index 000000000..a61354428 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/.classpath @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/.launch/Generate Ros2 (ros2) Language Infrastructure.launch b/plugins/de.fraunhofer.ipa.ros2.xtext/.launch/Generate Ros2 (ros2) Language Infrastructure.launch new file mode 100644 index 000000000..5602c4193 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/.launch/Generate Ros2 (ros2) Language Infrastructure.launch @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/.launch/Launch Runtime Eclipse.launch b/plugins/de.fraunhofer.ipa.ros2.xtext/.launch/Launch Runtime Eclipse.launch new file mode 100644 index 000000000..5cb7fda33 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/.launch/Launch Runtime Eclipse.launch @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/.project b/plugins/de.fraunhofer.ipa.ros2.xtext/.project new file mode 100644 index 000000000..09c9fb56a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/.project @@ -0,0 +1,34 @@ + + + de.fraunhofer.ipa.ros2.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.ros2.xtext/.settings/org.eclipse.core.resources.prefs b/plugins/de.fraunhofer.ipa.ros2.xtext/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 000000000..99f26c020 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.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.ros2.xtext/.settings/org.eclipse.jdt.core.prefs b/plugins/de.fraunhofer.ipa.ros2.xtext/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000..7adc0fb9a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.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.ros2.xtext/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.ros2.xtext/META-INF/MANIFEST.MF new file mode 100644 index 000000000..4856d32af --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/META-INF/MANIFEST.MF @@ -0,0 +1,29 @@ +Manifest-Version: 1.0 +Automatic-Module-Name: de.fraunhofer.ipa.ros2.xtext +Bundle-ManifestVersion: 2 +Bundle-Name: de.fraunhofer.ipa.ros2.xtext +Bundle-Vendor: Fraunhofer IPA +Bundle-Version: 2.0.0.qualifier +Bundle-SymbolicName: de.fraunhofer.ipa.ros2.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", + de.fraunhofer.ipa.ros.xtext;bundle-version="2.0.0", + de.fraunhofer.ipa.ros.xtext.ui;bundle-version="2.0.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.ros2.parser.antlr, + de.fraunhofer.ipa.ros2.parser.antlr.lexer, + de.fraunhofer.ipa.ros2.parser.antlr.internal, + de.fraunhofer.ipa.ros2.scoping, + de.fraunhofer.ipa.ros2.formatting2, + de.fraunhofer.ipa.ros2.validation, + de.fraunhofer.ipa.ros2.generator, + de.fraunhofer.ipa.ros2, + de.fraunhofer.ipa.ros2.services, + de.fraunhofer.ipa.ros2.serializer +Import-Package: org.apache.log4j diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/build.properties b/plugins/de.fraunhofer.ipa.ros2.xtext/build.properties new file mode 100644 index 000000000..c24ff3680 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.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.ros2.xtext/pom.xml b/plugins/de.fraunhofer.ipa.ros2.xtext/pom.xml new file mode 100644 index 000000000..c7c305648 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/pom.xml @@ -0,0 +1,105 @@ + + 4.0.0 + + de.fraunhofer.ipa.ros + de.fraunhofer.ipa.ros.parent + 2.0.0-SNAPSHOT + ../de.fraunhofer.ipa.ros.parent/pom.xml + + de.fraunhofer.ipa.ros2.xtext + eclipse-plugin + + + + + org.codehaus.mojo + exec-maven-plugin + 1.4.0 + + + mwe2Launcher + generate-sources + + java + + + + + org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher + + /${project.basedir}/src/de/fraunhofer/ipa/ros2/GenerateRos2.mwe2 + -p + rootPath=/${project.basedir}/.. + + compile + true + false + + + + org.eclipse.emf + org.eclipse.emf.mwe2.launch + 2.9.1.201705291010 + + + org.eclipse.xtext + org.eclipse.xtext.common.types + ${xtextVersion} + + + org.eclipse.xtext + org.eclipse.xtext.xtext.generator + ${xtextVersion} + + + org.eclipse.xtext + org.eclipse.xtext.xbase + ${xtextVersion} + + + org.eclipse.xtext + xtext-antlr-generator + [2.1.1, 3) + + + + + org.eclipse.xtend + xtend-maven-plugin + + + + org.apache.maven.plugins + maven-clean-plugin + + + + ${basedir}/../de.fraunhofer.ipa.ros2.xtext/src-gen/ + + **/* + + + + ${basedir}/../de.fraunhofer.ipa.ros2.xtext.ide/src-gen/ + + **/* + + + + ${basedir}/../de.fraunhofer.ipa.ros2.xtext.ui/src-gen/ + + **/* + + + + ${basedir}/model/generated/ + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/AbstractRos2RuntimeModule.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/AbstractRos2RuntimeModule.java new file mode 100644 index 000000000..49075b290 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/AbstractRos2RuntimeModule.java @@ -0,0 +1,230 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2; + +import com.google.inject.Binder; +import com.google.inject.Provider; +import com.google.inject.name.Names; +import de.fraunhofer.ipa.ros2.formatting2.Ros2Formatter; +import de.fraunhofer.ipa.ros2.generator.Ros2Generator; +import de.fraunhofer.ipa.ros2.parser.antlr.Ros2AntlrTokenFileProvider; +import de.fraunhofer.ipa.ros2.parser.antlr.Ros2Parser; +import de.fraunhofer.ipa.ros2.parser.antlr.lexer.InternalRos2Lexer; +import de.fraunhofer.ipa.ros2.scoping.Ros2ScopeProvider; +import de.fraunhofer.ipa.ros2.serializer.Ros2SemanticSequencer; +import de.fraunhofer.ipa.ros2.serializer.Ros2SyntacticSequencer; +import de.fraunhofer.ipa.ros2.services.Ros2GrammarAccess; +import de.fraunhofer.ipa.ros2.validation.Ros2ConfigurableIssueCodesProvider; +import de.fraunhofer.ipa.ros2.validation.Ros2Validator; +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.formatting2.FormatterPreferenceValuesProvider; +import org.eclipse.xtext.formatting2.FormatterPreferences; +import org.eclipse.xtext.formatting2.IFormatter2; +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.IUnorderedGroupHelper; +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.parser.antlr.UnorderedGroupHelper; +import org.eclipse.xtext.preferences.IPreferenceValuesProvider; +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 Ros2RuntimeModule}. + */ +@SuppressWarnings("all") +public abstract class AbstractRos2RuntimeModule extends DefaultRuntimeModule { + + protected Properties properties = null; + + @Override + public void configure(Binder binder) { + properties = tryBindProperties(binder, "de/fraunhofer/ipa/ros2/Ros2.properties"); + super.configure(binder); + } + + public void configureLanguageName(Binder binder) { + binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("de.fraunhofer.ipa.ros2.Ros2"); + } + + 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("ros2"); + } + + // 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 Ros2GrammarAccess.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISemanticSequencer() { + return Ros2SemanticSequencer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISyntacticSequencer() { + return Ros2SyntacticSequencer.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 Ros2Parser.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 Ros2AntlrTokenFileProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindLexer() { + return InternalRos2Lexer.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 provideInternalRos2Lexer() { + return LexerProvider.create(InternalRos2Lexer.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(InternalRos2Lexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIUnorderedGroupHelper() { + return UnorderedGroupHelper.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 + @SingletonBinding(eager=true) + public Class bindRos2Validator() { + return Ros2Validator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 + public Class bindConfigurableIssueCodesProvider() { + return Ros2ConfigurableIssueCodesProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public Class bindIScopeProvider() { + return Ros2ScopeProvider.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 Ros2Generator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.formatting.Formatter2Fragment2 + public Class bindIFormatter2() { + return Ros2Formatter.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.formatting.Formatter2Fragment2 + public void configureFormatterPreferences(Binder binder) { + binder.bind(IPreferenceValuesProvider.class).annotatedWith(FormatterPreferences.class).to(FormatterPreferenceValuesProvider.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.ecore2xtext.Ecore2XtextValueConverterServiceFragment2 + public Class bindIValueConverterService() { + return Ecore2XtextTerminalConverters.class; + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/Ros2.xtextbin b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/Ros2.xtextbin new file mode 100644 index 000000000..14c08786e Binary files /dev/null and b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/Ros2.xtextbin differ diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/Ros2StandaloneSetupGenerated.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/Ros2StandaloneSetupGenerated.java new file mode 100644 index 000000000..3ff5f0298 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/Ros2StandaloneSetupGenerated.java @@ -0,0 +1,37 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2; + +import com.google.inject.Guice; +import com.google.inject.Injector; +import de.fraunhofer.ipa.ros.RosStandaloneSetup; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.xtext.ISetup; +import org.eclipse.xtext.resource.IResourceFactory; +import org.eclipse.xtext.resource.IResourceServiceProvider; + +@SuppressWarnings("all") +public class Ros2StandaloneSetupGenerated implements ISetup { + + @Override + public Injector createInjectorAndDoEMFRegistration() { + RosStandaloneSetup.doSetup(); + + Injector injector = createInjector(); + register(injector); + return injector; + } + + public Injector createInjector() { + return Guice.createInjector(new Ros2RuntimeModule()); + } + + public void register(Injector injector) { + IResourceFactory resourceFactory = injector.getInstance(IResourceFactory.class); + IResourceServiceProvider serviceProvider = injector.getInstance(IResourceServiceProvider.class); + + Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("ros2", resourceFactory); + IResourceServiceProvider.Registry.INSTANCE.getExtensionToFactoryMap().put("ros2", serviceProvider); + } +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/Ros2AntlrTokenFileProvider.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/Ros2AntlrTokenFileProvider.java new file mode 100644 index 000000000..f0a1b4f7f --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/Ros2AntlrTokenFileProvider.java @@ -0,0 +1,16 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.parser.antlr; + +import java.io.InputStream; +import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider; + +public class Ros2AntlrTokenFileProvider implements IAntlrTokenFileProvider { + + @Override + public InputStream getAntlrTokenFile() { + ClassLoader classLoader = getClass().getClassLoader(); + return classLoader.getResourceAsStream("de/fraunhofer/ipa/ros2/parser/antlr/internal/InternalRos2Parser.tokens"); + } +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/Ros2Parser.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/Ros2Parser.java new file mode 100644 index 000000000..b630c88c6 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/Ros2Parser.java @@ -0,0 +1,55 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.parser.antlr; + +import com.google.inject.Inject; +import de.fraunhofer.ipa.ros2.parser.antlr.internal.InternalRos2Parser; +import de.fraunhofer.ipa.ros2.services.Ros2GrammarAccess; +import org.antlr.runtime.CharStream; +import org.antlr.runtime.TokenSource; +import org.eclipse.xtext.parser.antlr.AbstractAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; + +public class Ros2Parser extends AbstractAntlrParser { + + @Inject + private Ros2GrammarAccess grammarAccess; + + @Override + protected void setInitialHiddenTokens(XtextTokenStream tokenStream) { + tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT"); + } + + @Override + protected TokenSource createLexer(CharStream stream) { + return new Ros2TokenSource(super.createLexer(stream)); + } + + /** + * Indentation aware languages do not support partial parsing since the lexer is inherently stateful. + * Override and return {@code true} if your terminal splitting is stateless. + */ + @Override + protected boolean isReparseSupported() { + return false; + } + + @Override + protected InternalRos2Parser createParser(XtextTokenStream stream) { + return new InternalRos2Parser(stream, getGrammarAccess()); + } + + @Override + protected String getDefaultRuleName() { + return "Package"; + } + + public Ros2GrammarAccess getGrammarAccess() { + return this.grammarAccess; + } + + public void setGrammarAccess(Ros2GrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } +} diff --git a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRos.g b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/internal/InternalRos2Parser.g similarity index 74% rename from plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRos.g rename to plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/internal/InternalRos2Parser.g index a1e2ef8ec..7cc7778bc 100644 --- a/plugins/de.fraunhofer.ipa.ros.xtext/src-gen/de/fraunhofer/ipa/ros/parser/antlr/internal/InternalRos.g +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/internal/InternalRos2Parser.g @@ -1,22 +1,15 @@ /* * generated by Xtext 2.25.0 */ -grammar InternalRos; +parser grammar InternalRos2Parser; options { + tokenVocab=InternalRos2Lexer; superClass=AbstractInternalAntlrParser; } -@lexer::header { -package de.fraunhofer.ipa.ros.parser.antlr.internal; - -// Hack: Use our own Lexer superclass by means of import. -// Currently there is no other way to specify the superclass for the lexer. -import org.eclipse.xtext.parser.antlr.Lexer; -} - -@parser::header { -package de.fraunhofer.ipa.ros.parser.antlr.internal; +@header { +package de.fraunhofer.ipa.ros2.parser.antlr.internal; import org.eclipse.xtext.*; import org.eclipse.xtext.parser.*; @@ -27,15 +20,15 @@ import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; import org.eclipse.xtext.parser.antlr.XtextTokenStream; import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; -import de.fraunhofer.ipa.ros.services.RosGrammarAccess; +import de.fraunhofer.ipa.ros2.services.Ros2GrammarAccess; } -@parser::members { +@members { - private RosGrammarAccess grammarAccess; + private Ros2GrammarAccess grammarAccess; - public InternalRosParser(TokenStream input, RosGrammarAccess grammarAccess) { + public InternalRos2Parser(TokenStream input, Ros2GrammarAccess grammarAccess) { this(input); this.grammarAccess = grammarAccess; registerRules(grammarAccess.getGrammar()); @@ -43,11 +36,11 @@ import de.fraunhofer.ipa.ros.services.RosGrammarAccess; @Override protected String getFirstRuleName() { - return "PackageSet"; + return "Package"; } @Override - protected RosGrammarAccess getGrammarAccess() { + protected Ros2GrammarAccess getGrammarAccess() { return grammarAccess; } @@ -60,90 +53,6 @@ import de.fraunhofer.ipa.ros.services.RosGrammarAccess; } } -// Entry rule entryRulePackageSet -entryRulePackageSet returns [EObject current=null]: - { newCompositeNode(grammarAccess.getPackageSetRule()); } - iv_rulePackageSet=rulePackageSet - { $current=$iv_rulePackageSet.current; } - EOF; - -// Rule PackageSet -rulePackageSet returns [EObject current=null] -@init { - enterRule(); -} -@after { - leaveRule(); -}: - ( - ( - { - $current = forceCreateModelElement( - grammarAccess.getPackageSetAccess().getPackageSetAction_0(), - $current); - } - ) - otherlv_1='PackageSet' - { - newLeafNode(otherlv_1, grammarAccess.getPackageSetAccess().getPackageSetKeyword_1()); - } - otherlv_2='{' - { - newLeafNode(otherlv_2, grammarAccess.getPackageSetAccess().getLeftCurlyBracketKeyword_2()); - } - ( - ( - ( - { - newCompositeNode(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_0_0()); - } - lv_package_3_0=rulePackage - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getPackageSetRule()); - } - add( - $current, - "package", - lv_package_3_0, - "de.fraunhofer.ipa.ros.Ros.Package"); - afterParserOrEnumRuleCall(); - } - ) - ) - ( - otherlv_4=',' - { - newLeafNode(otherlv_4, grammarAccess.getPackageSetAccess().getCommaKeyword_3_1_0()); - } - ( - ( - { - newCompositeNode(grammarAccess.getPackageSetAccess().getPackagePackageParserRuleCall_3_1_1_0()); - } - lv_package_5_0=rulePackage - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getPackageSetRule()); - } - add( - $current, - "package", - lv_package_5_0, - "de.fraunhofer.ipa.ros.Ros.Package"); - afterParserOrEnumRuleCall(); - } - ) - ) - )* - )? - otherlv_6='}' - { - newLeafNode(otherlv_6, grammarAccess.getPackageSetAccess().getRightCurlyBracketKeyword_4()); - } - ) -; - // Entry rule entryRulePackage entryRulePackage returns [EObject current=null]: { newCompositeNode(grammarAccess.getPackageRule()); } @@ -159,171 +68,25 @@ rulePackage returns [EObject current=null] @after { leaveRule(); }: - ( - { - newCompositeNode(grammarAccess.getPackageAccess().getPackage_ImplParserRuleCall_0()); - } - this_Package_Impl_0=rulePackage_Impl - { - $current = $this_Package_Impl_0.current; - afterParserOrEnumRuleCall(); - } - | - { - newCompositeNode(grammarAccess.getPackageAccess().getCatkinPackageParserRuleCall_1()); - } - this_CatkinPackage_1=ruleCatkinPackage - { - $current = $this_CatkinPackage_1.current; - afterParserOrEnumRuleCall(); - } - | - { - newCompositeNode(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall_2()); - } - this_AmentPackage_2=ruleAmentPackage - { - $current = $this_AmentPackage_2.current; - afterParserOrEnumRuleCall(); - } - ) -; - -// Entry rule entryRuleSpecBase -entryRuleSpecBase returns [EObject current=null]: - { newCompositeNode(grammarAccess.getSpecBaseRule()); } - iv_ruleSpecBase=ruleSpecBase - { $current=$iv_ruleSpecBase.current; } - EOF; - -// Rule SpecBase -ruleSpecBase returns [EObject current=null] -@init { - enterRule(); -} -@after { - leaveRule(); -}: - ( - { - newCompositeNode(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_0()); - } - this_ServiceSpec_0=ruleServiceSpec - { - $current = $this_ServiceSpec_0.current; - afterParserOrEnumRuleCall(); - } - | - { - newCompositeNode(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_1()); - } - this_TopicSpec_1=ruleTopicSpec - { - $current = $this_TopicSpec_1.current; - afterParserOrEnumRuleCall(); - } - | - { - newCompositeNode(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); - } - this_ActionSpec_2=ruleActionSpec - { - $current = $this_ActionSpec_2.current; - afterParserOrEnumRuleCall(); - } - ) -; - -// Entry rule entryRuleDependency -entryRuleDependency returns [EObject current=null]: - { newCompositeNode(grammarAccess.getDependencyRule()); } - iv_ruleDependency=ruleDependency - { $current=$iv_ruleDependency.current; } - EOF; - -// Rule Dependency -ruleDependency returns [EObject current=null] -@init { - enterRule(); -} -@after { - leaveRule(); -}: - ( - { - newCompositeNode(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); - } - this_PackageDependency_0=rulePackageDependency - { - $current = $this_PackageDependency_0.current; - afterParserOrEnumRuleCall(); - } - | - { - newCompositeNode(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); - } - this_ExternalDependency_1=ruleExternalDependency - { - $current = $this_ExternalDependency_1.current; - afterParserOrEnumRuleCall(); - } - ) -; - -// Entry rule entryRuleNamespace -entryRuleNamespace returns [EObject current=null]: - { newCompositeNode(grammarAccess.getNamespaceRule()); } - iv_ruleNamespace=ruleNamespace - { $current=$iv_ruleNamespace.current; } - EOF; - -// Rule Namespace -ruleNamespace returns [EObject current=null] -@init { - enterRule(); -} -@after { - leaveRule(); -}: - ( - { - newCompositeNode(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); - } - this_GlobalNamespace_0=ruleGlobalNamespace - { - $current = $this_GlobalNamespace_0.current; - afterParserOrEnumRuleCall(); - } - | - { - newCompositeNode(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); - } - this_RelativeNamespace_Impl_1=ruleRelativeNamespace_Impl - { - $current = $this_RelativeNamespace_Impl_1.current; - afterParserOrEnumRuleCall(); - } - | - { - newCompositeNode(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); - } - this_PrivateNamespace_2=rulePrivateNamespace - { - $current = $this_PrivateNamespace_2.current; - afterParserOrEnumRuleCall(); - } - ) + { + newCompositeNode(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall()); + } + this_AmentPackage_0=ruleAmentPackage + { + $current = $this_AmentPackage_0.current; + afterParserOrEnumRuleCall(); + } ; -// Entry rule entryRulePackage_Impl -entryRulePackage_Impl returns [EObject current=null]: - { newCompositeNode(grammarAccess.getPackage_ImplRule()); } - iv_rulePackage_Impl=rulePackage_Impl - { $current=$iv_rulePackage_Impl.current; } +// Entry rule entryRuleAmentPackage +entryRuleAmentPackage returns [EObject current=null]: + { newCompositeNode(grammarAccess.getAmentPackageRule()); } + iv_ruleAmentPackage=ruleAmentPackage + { $current=$iv_ruleAmentPackage.current; } EOF; -// Rule Package_Impl -rulePackage_Impl returns [EObject current=null] +// Rule AmentPackage +ruleAmentPackage returns [EObject current=null] @init { enterRule(); } @@ -334,51 +97,51 @@ rulePackage_Impl returns [EObject current=null] ( { $current = forceCreateModelElement( - grammarAccess.getPackage_ImplAccess().getPackageAction_0(), + grammarAccess.getAmentPackageAccess().getAmentPackageAction_0(), $current); } ) - otherlv_1='Package' - { - newLeafNode(otherlv_1, grammarAccess.getPackage_ImplAccess().getPackageKeyword_1()); - } ( ( { - newCompositeNode(grammarAccess.getPackage_ImplAccess().getNameEStringParserRuleCall_2_0()); + newCompositeNode(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_1_0()); } - lv_name_2_0=ruleEString + lv_name_1_0=ruleRosNames { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); } set( $current, "name", - lv_name_2_0, - "de.fraunhofer.ipa.ros.Ros.EString"); + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); afterParserOrEnumRuleCall(); } ) ) - otherlv_3='{' + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getAmentPackageAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN { - newLeafNode(otherlv_3, grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_3()); + newLeafNode(this_BEGIN_3, grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_3()); } ( - otherlv_4='FromGitRepo' + otherlv_4=FromGitRepo { - newLeafNode(otherlv_4, grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); + newLeafNode(otherlv_4, grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); } ( ( { - newCompositeNode(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + newCompositeNode(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } lv_fromGitRepo_5_0=ruleEString { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); } set( $current, @@ -391,159 +154,112 @@ rulePackage_Impl returns [EObject current=null] ) )? ( - otherlv_6='Specs' + otherlv_6=Artifacts { - newLeafNode(otherlv_6, grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + newLeafNode(otherlv_6, grammarAccess.getAmentPackageAccess().getArtifactsKeyword_5_0()); } - otherlv_7='{' + this_BEGIN_7=RULE_BEGIN { - newLeafNode(otherlv_7, grammarAccess.getPackage_ImplAccess().getLeftCurlyBracketKeyword_5_1()); + newLeafNode(this_BEGIN_7, grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_5_1()); } ( ( { - newCompositeNode(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); + newCompositeNode(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); } - lv_spec_8_0=ruleSpecBase + lv_artifact_8_0=ruleArtifact { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); } add( $current, - "spec", - lv_spec_8_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); + "artifact", + lv_artifact_8_0, + "de.fraunhofer.ipa.ros.Ros.Artifact"); afterParserOrEnumRuleCall(); } ) - ) - ( - otherlv_9=',' - { - newLeafNode(otherlv_9, grammarAccess.getPackage_ImplAccess().getCommaKeyword_5_3_0()); - } - ( - ( - { - newCompositeNode(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_3_1_0()); - } - lv_spec_10_0=ruleSpecBase - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); - } - add( - $current, - "spec", - lv_spec_10_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); - afterParserOrEnumRuleCall(); - } - ) - ) - )* - otherlv_11='}' - { - newLeafNode(otherlv_11, grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_5_4()); - } - )? - ( + )* + this_END_9=RULE_END + { + newLeafNode(this_END_9, grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_5_3()); + } + )? + ( + otherlv_10=Dependencies + { + newLeafNode(otherlv_10, grammarAccess.getAmentPackageAccess().getDependenciesKeyword_6_0()); + } + otherlv_11=LeftSquareBracket + { + newLeafNode(otherlv_11, grammarAccess.getAmentPackageAccess().getLeftSquareBracketKeyword_6_1()); + } ( ( { - newCompositeNode(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_0_0()); + newCompositeNode(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); } - lv_artifact_12_0=ruleArtifact + lv_dependency_12_0=ruleDependency { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); } add( $current, - "artifact", - lv_artifact_12_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); + "dependency", + lv_dependency_12_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); afterParserOrEnumRuleCall(); } ) ) ( - otherlv_13=',' + otherlv_13=Comma { - newLeafNode(otherlv_13, grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_1_0()); + newLeafNode(otherlv_13, grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); } ( ( { - newCompositeNode(grammarAccess.getPackage_ImplAccess().getArtifactArtifactParserRuleCall_6_1_1_0()); + newCompositeNode(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); } - lv_artifact_14_0=ruleArtifact + lv_dependency_14_0=ruleDependency { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); } add( $current, - "artifact", - lv_artifact_14_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); + "dependency", + lv_dependency_14_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); afterParserOrEnumRuleCall(); } ) ) )* + otherlv_15=RightSquareBracket + { + newLeafNode(otherlv_15, grammarAccess.getAmentPackageAccess().getRightSquareBracketKeyword_6_4()); + } )? - otherlv_15='}' - { - newLeafNode(otherlv_15, grammarAccess.getPackage_ImplAccess().getRightCurlyBracketKeyword_7()); - } - ) -; - -// Entry rule entryRuleEString -entryRuleEString returns [String current=null]: - { newCompositeNode(grammarAccess.getEStringRule()); } - iv_ruleEString=ruleEString - { $current=$iv_ruleEString.current.getText(); } - EOF; - -// Rule EString -ruleEString returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] -@init { - enterRule(); -} -@after { - leaveRule(); -}: - ( - this_STRING_0=RULE_STRING - { - $current.merge(this_STRING_0); - } - { - newLeafNode(this_STRING_0, grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); - } - | - this_ID_1=RULE_ID - { - $current.merge(this_ID_1); - } + this_END_16=RULE_END { - newLeafNode(this_ID_1, grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); + newLeafNode(this_END_16, grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_7()); } ) ; -// Entry rule entryRuleRosNames -entryRuleRosNames returns [String current=null]: - { newCompositeNode(grammarAccess.getRosNamesRule()); } - iv_ruleRosNames=ruleRosNames - { $current=$iv_ruleRosNames.current.getText(); } +// Entry rule entryRuleQualityOfService +entryRuleQualityOfService returns [EObject current=null]: + { newCompositeNode(grammarAccess.getQualityOfServiceRule()); } + iv_ruleQualityOfService=ruleQualityOfService + { $current=$iv_ruleQualityOfService.current; } EOF; -// Rule RosNames -ruleRosNames returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +// Rule QualityOfService +ruleQualityOfService returns [EObject current=null] @init { enterRule(); } @@ -551,39 +267,263 @@ ruleRosNames returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken( leaveRule(); }: ( - this_ROS_CONVENTION_A_0=RULE_ROS_CONVENTION_A - { - $current.merge(this_ROS_CONVENTION_A_0); - } - { - newLeafNode(this_ROS_CONVENTION_A_0, grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); - } - | - this_ID_1=RULE_ID - { - $current.merge(this_ID_1); - } - { - newLeafNode(this_ID_1, grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); - } - | - kw='node' - { - $current.merge(kw); - newLeafNode(kw, grammarAccess.getRosNamesAccess().getNodeKeyword_2()); - } + ( + { + $current = forceCreateModelElement( + grammarAccess.getQualityOfServiceAccess().getQualityOfServiceAction_0(), + $current); + } + ) + ( + ( + { + getUnorderedGroupHelper().enter(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + } + ( + ( + ( + {getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0)}?=>( + { + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0); + } + ({true}?=>(otherlv_2=Profile + { + newLeafNode(otherlv_2, grammarAccess.getQualityOfServiceAccess().getProfileKeyword_1_0_0()); + } + ( + ( + ( + lv_QoSProfile_3_1=Default_qos + { + newLeafNode(lv_QoSProfile_3_1, grammarAccess.getQualityOfServiceAccess().getQoSProfileDefault_qosKeyword_1_0_1_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed($current, "QoSProfile", lv_QoSProfile_3_1, null); + } + | + lv_QoSProfile_3_2=Services_qos + { + newLeafNode(lv_QoSProfile_3_2, grammarAccess.getQualityOfServiceAccess().getQoSProfileServices_qosKeyword_1_0_1_0_1()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed($current, "QoSProfile", lv_QoSProfile_3_2, null); + } + | + lv_QoSProfile_3_3=Sensor_qos + { + newLeafNode(lv_QoSProfile_3_3, grammarAccess.getQualityOfServiceAccess().getQoSProfileSensor_qosKeyword_1_0_1_0_2()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed($current, "QoSProfile", lv_QoSProfile_3_3, null); + } + | + lv_QoSProfile_3_4=Parameter_qos + { + newLeafNode(lv_QoSProfile_3_4, grammarAccess.getQualityOfServiceAccess().getQoSProfileParameter_qosKeyword_1_0_1_0_3()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed($current, "QoSProfile", lv_QoSProfile_3_4, null); + } + ) + ) + ) + )) + { + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + } + ) + )| + ( + {getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1)}?=>( + { + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1); + } + ({true}?=>(otherlv_4=History + { + newLeafNode(otherlv_4, grammarAccess.getQualityOfServiceAccess().getHistoryKeyword_1_1_0()); + } + ( + ( + ( + lv_History_5_1=Keep_last + { + newLeafNode(lv_History_5_1, grammarAccess.getQualityOfServiceAccess().getHistoryKeep_lastKeyword_1_1_1_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed($current, "History", lv_History_5_1, null); + } + | + lv_History_5_2=Keep_all + { + newLeafNode(lv_History_5_2, grammarAccess.getQualityOfServiceAccess().getHistoryKeep_allKeyword_1_1_1_0_1()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed($current, "History", lv_History_5_2, null); + } + ) + ) + ) + )) + { + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + } + ) + )| + ( + {getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2)}?=>( + { + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2); + } + ({true}?=>(otherlv_6=Depth + { + newLeafNode(otherlv_6, grammarAccess.getQualityOfServiceAccess().getDepthKeyword_1_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getQualityOfServiceAccess().getDepthInteger0ParserRuleCall_1_2_1_0()); + } + lv_Depth_7_0=ruleInteger0 + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getQualityOfServiceRule()); + } + set( + $current, + "Depth", + lv_Depth_7_0, + "de.fraunhofer.ipa.ros.Ros.Integer0"); + afterParserOrEnumRuleCall(); + } + ) + ) + )) + { + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + } + ) + )| + ( + {getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3)}?=>( + { + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3); + } + ({true}?=>(otherlv_8=Reliability + { + newLeafNode(otherlv_8, grammarAccess.getQualityOfServiceAccess().getReliabilityKeyword_1_3_0()); + } + ( + ( + ( + lv_Reliability_9_1=Best_effort + { + newLeafNode(lv_Reliability_9_1, grammarAccess.getQualityOfServiceAccess().getReliabilityBest_effortKeyword_1_3_1_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed($current, "Reliability", lv_Reliability_9_1, null); + } + | + lv_Reliability_9_2=Reliable + { + newLeafNode(lv_Reliability_9_2, grammarAccess.getQualityOfServiceAccess().getReliabilityReliableKeyword_1_3_1_0_1()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed($current, "Reliability", lv_Reliability_9_2, null); + } + ) + ) + ) + )) + { + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + } + ) + )| + ( + {getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4)}?=>( + { + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4); + } + ({true}?=>(otherlv_10=Durability + { + newLeafNode(otherlv_10, grammarAccess.getQualityOfServiceAccess().getDurabilityKeyword_1_4_0()); + } + ( + ( + ( + lv_Durability_11_1=Transient_local + { + newLeafNode(lv_Durability_11_1, grammarAccess.getQualityOfServiceAccess().getDurabilityTransient_localKeyword_1_4_1_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed($current, "Durability", lv_Durability_11_1, null); + } + | + lv_Durability_11_2=Volatile + { + newLeafNode(lv_Durability_11_2, grammarAccess.getQualityOfServiceAccess().getDurabilityVolatileKeyword_1_4_1_0_1()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed($current, "Durability", lv_Durability_11_2, null); + } + ) + ) + ) + )) + { + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + } + ) + ) + )* + ) + ) + { + getUnorderedGroupHelper().leave(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + } + ) ) ; -// Entry rule entryRuleArtifact -entryRuleArtifact returns [EObject current=null]: - { newCompositeNode(grammarAccess.getArtifactRule()); } - iv_ruleArtifact=ruleArtifact - { $current=$iv_ruleArtifact.current; } +// Entry rule entryRulePublisher +entryRulePublisher returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPublisherRule()); } + iv_rulePublisher=rulePublisher + { $current=$iv_rulePublisher.current; } EOF; -// Rule Artifact -ruleArtifact returns [EObject current=null] +// Rule Publisher +rulePublisher returns [EObject current=null] @init { enterRule(); } @@ -594,72 +534,131 @@ ruleArtifact returns [EObject current=null] ( { $current = forceCreateModelElement( - grammarAccess.getArtifactAccess().getArtifactAction_0(), + grammarAccess.getPublisherAccess().getPublisherAction_0(), $current); } ) - otherlv_1='Artifact' - { - newLeafNode(otherlv_1, grammarAccess.getArtifactAccess().getArtifactKeyword_1()); - } ( ( { - newCompositeNode(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_2_0()); + newCompositeNode(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); } - lv_name_2_0=ruleRosNames + lv_name_1_0=ruleEString { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getArtifactRule()); + $current = createModelElementForParent(grammarAccess.getPublisherRule()); } set( $current, "name", - lv_name_2_0, - "de.fraunhofer.ipa.ros.Ros.RosNames"); + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); } ) ) - otherlv_3='{' + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getPublisherAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN { - newLeafNode(otherlv_3, grammarAccess.getArtifactAccess().getLeftCurlyBracketKeyword_3()); + newLeafNode(this_BEGIN_3, grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getPublisherAccess().getTypeKeyword_4()); } ( ( - { - newCompositeNode(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); - } - lv_node_4_0=ruleNode { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getArtifactRule()); + $current = createModelElement(grammarAccess.getPublisherRule()); } - set( - $current, - "node", - lv_node_4_0, - "de.fraunhofer.ipa.ros.Ros.Node"); + } + { + newCompositeNode(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + } + ruleEString + { afterParserOrEnumRuleCall(); } ) + ) + ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getPublisherAccess().getNsKeyword_6_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + } + lv_namespace_7_0=ruleNamespace + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPublisherRule()); + } + set( + $current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ( + otherlv_8=Qos + { + newLeafNode(otherlv_8, grammarAccess.getPublisherAccess().getQosKeyword_7_0()); + } + this_BEGIN_9=RULE_BEGIN + { + newLeafNode(this_BEGIN_9, grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_7_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPublisherAccess().getQosQualityOfServiceParserRuleCall_7_2_0()); + } + lv_qos_10_0=ruleQualityOfService + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPublisherRule()); + } + set( + $current, + "qos", + lv_qos_10_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_11=RULE_END + { + newLeafNode(this_END_11, grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7_3()); + } )? - otherlv_5='}' + this_END_12=RULE_END { - newLeafNode(otherlv_5, grammarAccess.getArtifactAccess().getRightCurlyBracketKeyword_5()); + newLeafNode(this_END_12, grammarAccess.getPublisherAccess().getENDTerminalRuleCall_8()); } ) ; -// Entry rule entryRuleCatkinPackage -entryRuleCatkinPackage returns [EObject current=null]: - { newCompositeNode(grammarAccess.getCatkinPackageRule()); } - iv_ruleCatkinPackage=ruleCatkinPackage - { $current=$iv_ruleCatkinPackage.current; } +// Entry rule entryRuleSubscriber +entryRuleSubscriber returns [EObject current=null]: + { newCompositeNode(grammarAccess.getSubscriberRule()); } + iv_ruleSubscriber=ruleSubscriber + { $current=$iv_ruleSubscriber.current; } EOF; -// Rule CatkinPackage -ruleCatkinPackage returns [EObject current=null] +// Rule Subscriber +ruleSubscriber returns [EObject current=null] @init { enterRule(); } @@ -670,240 +669,250 @@ ruleCatkinPackage returns [EObject current=null] ( { $current = forceCreateModelElement( - grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0(), + grammarAccess.getSubscriberAccess().getSubscriberAction_0(), $current); } ) - otherlv_1='CatkinPackage' - { - newLeafNode(otherlv_1, grammarAccess.getCatkinPackageAccess().getCatkinPackageKeyword_1()); - } ( ( { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_2_0()); + newCompositeNode(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); } - lv_name_2_0=ruleRosNames + lv_name_1_0=ruleEString { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + $current = createModelElementForParent(grammarAccess.getSubscriberRule()); } set( $current, "name", - lv_name_2_0, - "de.fraunhofer.ipa.ros.Ros.RosNames"); + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); } ) ) - otherlv_3='{' + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getSubscriberAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 { - newLeafNode(otherlv_3, grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_3()); + newLeafNode(otherlv_4, grammarAccess.getSubscriberAccess().getTypeKeyword_4()); } ( - otherlv_4='FromGitRepo' + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getSubscriberRule()); + } + } + { + newCompositeNode(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns { - newLeafNode(otherlv_4, grammarAccess.getCatkinPackageAccess().getFromGitRepoKeyword_4_0()); + newLeafNode(otherlv_6, grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); } ( ( { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + newCompositeNode(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - lv_fromGitRepo_5_0=ruleEString + lv_namespace_7_0=ruleNamespace { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + $current = createModelElementForParent(grammarAccess.getSubscriberRule()); } set( $current, - "fromGitRepo", - lv_fromGitRepo_5_0, - "de.fraunhofer.ipa.ros.Ros.EString"); + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); afterParserOrEnumRuleCall(); } ) ) )? ( - otherlv_6='Dependencies' - { - newLeafNode(otherlv_6, grammarAccess.getCatkinPackageAccess().getDependenciesKeyword_5_0()); - } - otherlv_7='{' + otherlv_8=Qos { - newLeafNode(otherlv_7, grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_5_1()); + newLeafNode(otherlv_8, grammarAccess.getSubscriberAccess().getQosKeyword_7_0()); } ( ( { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); + newCompositeNode(grammarAccess.getSubscriberAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } - lv_dependency_8_0=ruleDependency + lv_qos_9_0=ruleQualityOfService { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + $current = createModelElementForParent(grammarAccess.getSubscriberRule()); } - add( + set( $current, - "dependency", - lv_dependency_8_0, - "de.fraunhofer.ipa.ros.Ros.Dependency"); + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); afterParserOrEnumRuleCall(); } ) ) - ( - otherlv_9=',' - { - newLeafNode(otherlv_9, grammarAccess.getCatkinPackageAccess().getCommaKeyword_5_3_0()); - } - ( - ( - { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); - } - lv_dependency_10_0=ruleDependency - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); - } - add( - $current, - "dependency", - lv_dependency_10_0, - "de.fraunhofer.ipa.ros.Ros.Dependency"); - afterParserOrEnumRuleCall(); - } - ) - ) - )* - otherlv_11='}' - { - newLeafNode(otherlv_11, grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_5_4()); - } )? + this_END_10=RULE_END + { + newLeafNode(this_END_10, grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_8()); + } + ) +; + +// Entry rule entryRuleServiceServer +entryRuleServiceServer returns [EObject current=null]: + { newCompositeNode(grammarAccess.getServiceServerRule()); } + iv_ruleServiceServer=ruleServiceServer + { $current=$iv_ruleServiceServer.current; } + EOF; + +// Rule ServiceServer +ruleServiceServer returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( ( - otherlv_12='Specs' { - newLeafNode(otherlv_12, grammarAccess.getCatkinPackageAccess().getSpecsKeyword_6_0()); + $current = forceCreateModelElement( + grammarAccess.getServiceServerAccess().getServiceServerAction_0(), + $current); } - otherlv_13='{' + ) + ( + ( + { + newCompositeNode(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceServerRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getServiceServerAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getServiceServerAccess().getTypeKeyword_4()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getServiceServerRule()); + } + } + { + newCompositeNode(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns { - newLeafNode(otherlv_13, grammarAccess.getCatkinPackageAccess().getLeftCurlyBracketKeyword_6_1()); + newLeafNode(otherlv_6, grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); } ( ( { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); + newCompositeNode(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - lv_spec_14_0=ruleSpecBase + lv_namespace_7_0=ruleNamespace { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + $current = createModelElementForParent(grammarAccess.getServiceServerRule()); } - add( + set( $current, - "spec", - lv_spec_14_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); afterParserOrEnumRuleCall(); } ) ) - ( - otherlv_15=',' - { - newLeafNode(otherlv_15, grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); - } - ( - ( - { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); - } - lv_spec_16_0=ruleSpecBase - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); - } - add( - $current, - "spec", - lv_spec_16_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); - afterParserOrEnumRuleCall(); - } - ) - ) - )* - otherlv_17='}' - { - newLeafNode(otherlv_17, grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_6_4()); - } )? ( + otherlv_8=Qos + { + newLeafNode(otherlv_8, grammarAccess.getServiceServerAccess().getQosKeyword_7_0()); + } ( ( { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); + newCompositeNode(grammarAccess.getServiceServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } - lv_artifact_18_0=ruleArtifact + lv_qos_9_0=ruleQualityOfService { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + $current = createModelElementForParent(grammarAccess.getServiceServerRule()); } - add( + set( $current, - "artifact", - lv_artifact_18_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); afterParserOrEnumRuleCall(); } ) ) - ( - otherlv_19=',' - { - newLeafNode(otherlv_19, grammarAccess.getCatkinPackageAccess().getCommaKeyword_7_1_0()); - } - ( - ( - { - newCompositeNode(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); - } - lv_artifact_20_0=ruleArtifact - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); - } - add( - $current, - "artifact", - lv_artifact_20_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); - afterParserOrEnumRuleCall(); - } - ) - ) - )* )? - otherlv_21='}' + this_END_10=RULE_END { - newLeafNode(otherlv_21, grammarAccess.getCatkinPackageAccess().getRightCurlyBracketKeyword_8()); + newLeafNode(this_END_10, grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_8()); } ) ; -// Entry rule entryRuleAmentPackage -entryRuleAmentPackage returns [EObject current=null]: - { newCompositeNode(grammarAccess.getAmentPackageRule()); } - iv_ruleAmentPackage=ruleAmentPackage - { $current=$iv_ruleAmentPackage.current; } +// Entry rule entryRuleServiceClient +entryRuleServiceClient returns [EObject current=null]: + { newCompositeNode(grammarAccess.getServiceClientRule()); } + iv_ruleServiceClient=ruleServiceClient + { $current=$iv_ruleServiceClient.current; } EOF; -// Rule AmentPackage -ruleAmentPackage returns [EObject current=null] +// Rule ServiceClient +ruleServiceClient returns [EObject current=null] @init { enterRule(); } @@ -914,240 +923,250 @@ ruleAmentPackage returns [EObject current=null] ( { $current = forceCreateModelElement( - grammarAccess.getAmentPackageAccess().getAmentPackageAction_0(), + grammarAccess.getServiceClientAccess().getServiceClientAction_0(), $current); } ) - otherlv_1='AmentPackage' - { - newLeafNode(otherlv_1, grammarAccess.getAmentPackageAccess().getAmentPackageKeyword_1()); - } ( ( { - newCompositeNode(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_2_0()); + newCompositeNode(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); } - lv_name_2_0=ruleRosNames + lv_name_1_0=ruleEString { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); + $current = createModelElementForParent(grammarAccess.getServiceClientRule()); } set( $current, "name", - lv_name_2_0, - "de.fraunhofer.ipa.ros.Ros.RosNames"); + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); } ) ) - otherlv_3='{' + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getServiceClientAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 { - newLeafNode(otherlv_3, grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_3()); + newLeafNode(otherlv_4, grammarAccess.getServiceClientAccess().getTypeKeyword_4()); } ( - otherlv_4='FromGitRepo' + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getServiceClientRule()); + } + } + { + newCompositeNode(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns { - newLeafNode(otherlv_4, grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); + newLeafNode(otherlv_6, grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); } ( ( { - newCompositeNode(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + newCompositeNode(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - lv_fromGitRepo_5_0=ruleEString + lv_namespace_7_0=ruleNamespace { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); + $current = createModelElementForParent(grammarAccess.getServiceClientRule()); } set( $current, - "fromGitRepo", - lv_fromGitRepo_5_0, - "de.fraunhofer.ipa.ros.Ros.EString"); + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); afterParserOrEnumRuleCall(); } ) ) )? ( - otherlv_6='Dependencies' + otherlv_8=Qos { - newLeafNode(otherlv_6, grammarAccess.getAmentPackageAccess().getDependenciesKeyword_5_0()); - } - otherlv_7='{' - { - newLeafNode(otherlv_7, grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_5_1()); + newLeafNode(otherlv_8, grammarAccess.getServiceClientAccess().getQosKeyword_7_0()); } ( ( { - newCompositeNode(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_2_0()); + newCompositeNode(grammarAccess.getServiceClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } - lv_dependency_8_0=ruleDependency + lv_qos_9_0=ruleQualityOfService { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); + $current = createModelElementForParent(grammarAccess.getServiceClientRule()); } - add( + set( $current, - "dependency", - lv_dependency_8_0, - "de.fraunhofer.ipa.ros.Ros.Dependency"); + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); afterParserOrEnumRuleCall(); } ) ) + )? + this_END_10=RULE_END + { + newLeafNode(this_END_10, grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_8()); + } + ) +; + +// Entry rule entryRuleActionServer +entryRuleActionServer returns [EObject current=null]: + { newCompositeNode(grammarAccess.getActionServerRule()); } + iv_ruleActionServer=ruleActionServer + { $current=$iv_ruleActionServer.current; } + EOF; + +// Rule ActionServer +ruleActionServer returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getActionServerAccess().getActionServerAction_0(), + $current); + } + ) + ( ( - otherlv_9=',' { - newLeafNode(otherlv_9, grammarAccess.getAmentPackageAccess().getCommaKeyword_5_3_0()); + newCompositeNode(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); } - ( - ( - { - newCompositeNode(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_5_3_1_0()); - } - lv_dependency_10_0=ruleDependency - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); - } - add( - $current, - "dependency", - lv_dependency_10_0, - "de.fraunhofer.ipa.ros.Ros.Dependency"); - afterParserOrEnumRuleCall(); - } - ) - ) - )* - otherlv_11='}' - { - newLeafNode(otherlv_11, grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_5_4()); - } - )? + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionServerRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getActionServerAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 + { + newLeafNode(otherlv_4, grammarAccess.getActionServerAccess().getTypeKeyword_4()); + } ( - otherlv_12='Specs' - { - newLeafNode(otherlv_12, grammarAccess.getAmentPackageAccess().getSpecsKeyword_6_0()); - } - otherlv_13='{' + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getActionServerRule()); + } + } + { + newCompositeNode(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns { - newLeafNode(otherlv_13, grammarAccess.getAmentPackageAccess().getLeftCurlyBracketKeyword_6_1()); + newLeafNode(otherlv_6, grammarAccess.getActionServerAccess().getNsKeyword_6_0()); } ( ( { - newCompositeNode(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_2_0()); + newCompositeNode(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - lv_spec_14_0=ruleSpecBase + lv_namespace_7_0=ruleNamespace { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); + $current = createModelElementForParent(grammarAccess.getActionServerRule()); } - add( + set( $current, - "spec", - lv_spec_14_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); afterParserOrEnumRuleCall(); } ) ) - ( - otherlv_15=',' - { - newLeafNode(otherlv_15, grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); - } - ( - ( - { - newCompositeNode(grammarAccess.getAmentPackageAccess().getSpecSpecBaseParserRuleCall_6_3_1_0()); - } - lv_spec_16_0=ruleSpecBase - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); - } - add( - $current, - "spec", - lv_spec_16_0, - "de.fraunhofer.ipa.ros.Ros.SpecBase"); - afterParserOrEnumRuleCall(); - } - ) - ) - )* - otherlv_17='}' - { - newLeafNode(otherlv_17, grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_6_4()); - } )? ( + otherlv_8=Qos + { + newLeafNode(otherlv_8, grammarAccess.getActionServerAccess().getQosKeyword_7_0()); + } ( ( { - newCompositeNode(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_0_0()); + newCompositeNode(grammarAccess.getActionServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } - lv_artifact_18_0=ruleArtifact + lv_qos_9_0=ruleQualityOfService { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); + $current = createModelElementForParent(grammarAccess.getActionServerRule()); } - add( + set( $current, - "artifact", - lv_artifact_18_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); afterParserOrEnumRuleCall(); } ) ) - ( - otherlv_19=',' - { - newLeafNode(otherlv_19, grammarAccess.getAmentPackageAccess().getCommaKeyword_7_1_0()); - } - ( - ( - { - newCompositeNode(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_7_1_1_0()); - } - lv_artifact_20_0=ruleArtifact - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getAmentPackageRule()); - } - add( - $current, - "artifact", - lv_artifact_20_0, - "de.fraunhofer.ipa.ros.Ros.Artifact"); - afterParserOrEnumRuleCall(); - } - ) - ) - )* )? - otherlv_21='}' + this_END_10=RULE_END { - newLeafNode(otherlv_21, grammarAccess.getAmentPackageAccess().getRightCurlyBracketKeyword_8()); + newLeafNode(this_END_10, grammarAccess.getActionServerAccess().getENDTerminalRuleCall_8()); } ) ; -// Entry rule entryRuleServiceSpec -entryRuleServiceSpec returns [EObject current=null]: - { newCompositeNode(grammarAccess.getServiceSpecRule()); } - iv_ruleServiceSpec=ruleServiceSpec - { $current=$iv_ruleServiceSpec.current; } +// Entry rule entryRuleActionClient +entryRuleActionClient returns [EObject current=null]: + { newCompositeNode(grammarAccess.getActionClientRule()); } + iv_ruleActionClient=ruleActionClient + { $current=$iv_ruleActionClient.current; } EOF; -// Rule ServiceSpec -ruleServiceSpec returns [EObject current=null] +// Rule ActionClient +ruleActionClient returns [EObject current=null] @init { enterRule(); } @@ -1158,103 +1177,123 @@ ruleServiceSpec returns [EObject current=null] ( { $current = forceCreateModelElement( - grammarAccess.getServiceSpecAccess().getServiceSpecAction_0(), + grammarAccess.getActionClientAccess().getActionClientAction_0(), $current); } ) - otherlv_1='ServiceSpec' - { - newLeafNode(otherlv_1, grammarAccess.getServiceSpecAccess().getServiceSpecKeyword_1()); - } ( ( { - newCompositeNode(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); + newCompositeNode(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); } - lv_name_2_0=ruleEString + lv_name_1_0=ruleEString { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + $current = createModelElementForParent(grammarAccess.getActionClientRule()); } set( $current, "name", - lv_name_2_0, + lv_name_1_0, "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); } ) ) - otherlv_3='{' + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getActionClientAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Type_1 { - newLeafNode(otherlv_3, grammarAccess.getServiceSpecAccess().getLeftCurlyBracketKeyword_3()); + newLeafNode(otherlv_4, grammarAccess.getActionClientAccess().getTypeKeyword_4()); } ( - otherlv_4='request' + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getActionClientRule()); + } + } + { + newCompositeNode(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); + } + ruleEString + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=Ns { - newLeafNode(otherlv_4, grammarAccess.getServiceSpecAccess().getRequestKeyword_4_0()); + newLeafNode(otherlv_6, grammarAccess.getActionClientAccess().getNsKeyword_6_0()); } ( ( { - newCompositeNode(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_4_1_0()); + newCompositeNode(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - lv_request_5_0=ruleMessageDefinition + lv_namespace_7_0=ruleNamespace { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + $current = createModelElementForParent(grammarAccess.getActionClientRule()); } set( $current, - "request", - lv_request_5_0, - "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); afterParserOrEnumRuleCall(); } ) ) )? ( - otherlv_6='response' + otherlv_8=Qos { - newLeafNode(otherlv_6, grammarAccess.getServiceSpecAccess().getResponseKeyword_5_0()); + newLeafNode(otherlv_8, grammarAccess.getActionClientAccess().getQosKeyword_7_0()); } ( ( { - newCompositeNode(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_5_1_0()); + newCompositeNode(grammarAccess.getActionClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } - lv_response_7_0=ruleMessageDefinition + lv_qos_9_0=ruleQualityOfService { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + $current = createModelElementForParent(grammarAccess.getActionClientRule()); } set( $current, - "response", - lv_response_7_0, - "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); afterParserOrEnumRuleCall(); } ) ) )? - otherlv_8='}' + this_END_10=RULE_END { - newLeafNode(otherlv_8, grammarAccess.getServiceSpecAccess().getRightCurlyBracketKeyword_6()); + newLeafNode(this_END_10, grammarAccess.getActionClientAccess().getENDTerminalRuleCall_8()); } ) ; -// Entry rule entryRuleTopicSpec -entryRuleTopicSpec returns [EObject current=null]: - { newCompositeNode(grammarAccess.getTopicSpecRule()); } - iv_ruleTopicSpec=ruleTopicSpec - { $current=$iv_ruleTopicSpec.current; } +// Entry rule entryRuleParameter +entryRuleParameter returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterRule()); } + iv_ruleParameter=ruleParameter + { $current=$iv_ruleParameter.current; } EOF; -// Rule TopicSpec -ruleTopicSpec returns [EObject current=null] +// Rule Parameter +ruleParameter returns [EObject current=null] @init { enterRule(); } @@ -1265,102 +1304,204 @@ ruleTopicSpec returns [EObject current=null] ( { $current = forceCreateModelElement( - grammarAccess.getTopicSpecAccess().getTopicSpecAction_0(), + grammarAccess.getParameterAccess().getParameterAction_0(), $current); } ) - otherlv_1='TopicSpec' + ( + ( + { + newCompositeNode(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); + } + lv_name_1_0=ruleEString + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getParameterAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN { - newLeafNode(otherlv_1, grammarAccess.getTopicSpecAccess().getTopicSpecKeyword_1()); + newLeafNode(this_BEGIN_3, grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); } + otherlv_4=Type + { + newLeafNode(otherlv_4, grammarAccess.getParameterAccess().getTypeKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); + } + lv_type_5_0=ruleParameterType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + $current, + "type", + lv_type_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + } + ) + ) ( + otherlv_6=Ns + { + newLeafNode(otherlv_6, grammarAccess.getParameterAccess().getNsKeyword_6_0()); + } ( ( { - newCompositeNode(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + newCompositeNode(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); } - lv_name_2_1=ruleEString + lv_namespace_7_0=ruleNamespace { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getTopicSpecRule()); + $current = createModelElementForParent(grammarAccess.getParameterRule()); } set( $current, - "name", - lv_name_2_1, - "de.fraunhofer.ipa.ros.Ros.EString"); + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); afterParserOrEnumRuleCall(); } - | - lv_name_2_2='Header' - { - newLeafNode(lv_name_2_2, grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getTopicSpecRule()); - } - setWithLastConsumed($current, "name", lv_name_2_2, null); - } - | - lv_name_2_3='String' - { - newLeafNode(lv_name_2_3, grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getTopicSpecRule()); - } - setWithLastConsumed($current, "name", lv_name_2_3, null); - } ) ) - ) - otherlv_3='{' - { - newLeafNode(otherlv_3, grammarAccess.getTopicSpecAccess().getLeftCurlyBracketKeyword_3()); - } + )? ( - otherlv_4='message' + otherlv_8=Qos { - newLeafNode(otherlv_4, grammarAccess.getTopicSpecAccess().getMessageKeyword_4_0()); + newLeafNode(otherlv_8, grammarAccess.getParameterAccess().getQosKeyword_7_0()); } ( ( { - newCompositeNode(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_4_1_0()); + newCompositeNode(grammarAccess.getParameterAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); } - lv_message_5_0=ruleMessageDefinition + lv_qos_9_0=ruleQualityOfService { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getTopicSpecRule()); + $current = createModelElementForParent(grammarAccess.getParameterRule()); } set( $current, - "message", - lv_message_5_0, - "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); afterParserOrEnumRuleCall(); } ) ) )? - otherlv_6='}' + this_END_10=RULE_END + { + newLeafNode(this_END_10, grammarAccess.getParameterAccess().getENDTerminalRuleCall_8()); + } + otherlv_11=RightCurlyBracket { - newLeafNode(otherlv_6, grammarAccess.getTopicSpecAccess().getRightCurlyBracketKeyword_5()); + newLeafNode(otherlv_11, grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_9()); } ) ; -// Entry rule entryRuleActionSpec -entryRuleActionSpec returns [EObject current=null]: - { newCompositeNode(grammarAccess.getActionSpecRule()); } - iv_ruleActionSpec=ruleActionSpec - { $current=$iv_ruleActionSpec.current; } +// Entry rule entryRuleEString +entryRuleEString returns [String current=null]: + { newCompositeNode(grammarAccess.getEStringRule()); } + iv_ruleEString=ruleEString + { $current=$iv_ruleEString.current.getText(); } EOF; -// Rule ActionSpec -ruleActionSpec returns [EObject current=null] +// Rule EString +ruleEString returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + this_STRING_0=RULE_STRING + { + $current.merge(this_STRING_0); + } + { + newLeafNode(this_STRING_0, grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + } + | + this_ID_1=RULE_ID + { + $current.merge(this_ID_1); + } + { + newLeafNode(this_ID_1, grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); + } + ) +; + +// Entry rule entryRuleRosNames +entryRuleRosNames returns [String current=null]: + { newCompositeNode(grammarAccess.getRosNamesRule()); } + iv_ruleRosNames=ruleRosNames + { $current=$iv_ruleRosNames.current.getText(); } + EOF; + +// Rule RosNames +ruleRosNames returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + this_ROS_CONVENTION_A_0=RULE_ROS_CONVENTION_A + { + $current.merge(this_ROS_CONVENTION_A_0); + } + { + newLeafNode(this_ROS_CONVENTION_A_0, grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); + } + | + this_ID_1=RULE_ID + { + $current.merge(this_ID_1); + } + { + newLeafNode(this_ID_1, grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); + } + | + kw=Node + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getRosNamesAccess().getNodeKeyword_2()); + } + ) +; + +// Entry rule entryRulePackage_Impl +entryRulePackage_Impl returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPackage_ImplRule()); } + iv_rulePackage_Impl=rulePackage_Impl + { $current=$iv_rulePackage_Impl.current; } + EOF; + +// Rule Package_Impl +rulePackage_Impl returns [EObject current=null] @init { enterRule(); } @@ -1371,128 +1512,169 @@ ruleActionSpec returns [EObject current=null] ( { $current = forceCreateModelElement( - grammarAccess.getActionSpecAccess().getActionSpecAction_0(), + grammarAccess.getPackage_ImplAccess().getPackageAction_0(), $current); } ) - otherlv_1='ActionSpec' - { - newLeafNode(otherlv_1, grammarAccess.getActionSpecAccess().getActionSpecKeyword_1()); - } ( ( { - newCompositeNode(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + newCompositeNode(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); } - lv_name_2_0=ruleEString + lv_name_1_0=ruleRosNames { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); } set( $current, "name", - lv_name_2_0, - "de.fraunhofer.ipa.ros.Ros.EString"); + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); afterParserOrEnumRuleCall(); } ) ) - otherlv_3='{' + otherlv_2=Colon { - newLeafNode(otherlv_3, grammarAccess.getActionSpecAccess().getLeftCurlyBracketKeyword_3()); + newLeafNode(otherlv_2, grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); } ( - otherlv_4='goal' + otherlv_4=FromGitRepo { - newLeafNode(otherlv_4, grammarAccess.getActionSpecAccess().getGoalKeyword_4_0()); + newLeafNode(otherlv_4, grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); } ( ( { - newCompositeNode(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_4_1_0()); + newCompositeNode(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } - lv_goal_5_0=ruleMessageDefinition + lv_fromGitRepo_5_0=ruleEString { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); } set( $current, - "goal", - lv_goal_5_0, - "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + "fromGitRepo", + lv_fromGitRepo_5_0, + "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); } ) ) )? ( - otherlv_6='result' + otherlv_6=Specs { - newLeafNode(otherlv_6, grammarAccess.getActionSpecAccess().getResultKeyword_5_0()); + newLeafNode(otherlv_6, grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + } + this_BEGIN_7=RULE_BEGIN + { + newLeafNode(this_BEGIN_7, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); } ( ( { - newCompositeNode(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_5_1_0()); + newCompositeNode(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); } - lv_result_7_0=ruleMessageDefinition + lv_spec_8_0=ruleSpecBase { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); } - set( + add( $current, - "result", - lv_result_7_0, - "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + "spec", + lv_spec_8_0, + "de.fraunhofer.ipa.ros.Ros.SpecBase"); afterParserOrEnumRuleCall(); } ) - ) + )* + this_END_9=RULE_END + { + newLeafNode(this_END_9, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); + } )? ( - otherlv_8='feedback' + otherlv_10=Dependencies + { + newLeafNode(otherlv_10, grammarAccess.getPackage_ImplAccess().getDependenciesKeyword_6_0()); + } + otherlv_11=LeftSquareBracket { - newLeafNode(otherlv_8, grammarAccess.getActionSpecAccess().getFeedbackKeyword_6_0()); + newLeafNode(otherlv_11, grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); } ( ( { - newCompositeNode(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_6_1_0()); + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); } - lv_feedback_9_0=ruleMessageDefinition + lv_dependency_12_0=ruleDependency { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); } - set( + add( $current, - "feedback", - lv_feedback_9_0, - "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + "dependency", + lv_dependency_12_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); afterParserOrEnumRuleCall(); } ) ) + ( + otherlv_13=Comma + { + newLeafNode(otherlv_13, grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + } + lv_dependency_14_0=ruleDependency + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + $current, + "dependency", + lv_dependency_14_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_15=RightSquareBracket + { + newLeafNode(otherlv_15, grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); + } )? - otherlv_10='}' + this_END_16=RULE_END { - newLeafNode(otherlv_10, grammarAccess.getActionSpecAccess().getRightCurlyBracketKeyword_7()); + newLeafNode(this_END_16, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); } ) ; -// Entry rule entryRuleMessageDefinition -entryRuleMessageDefinition returns [EObject current=null]: - { newCompositeNode(grammarAccess.getMessageDefinitionRule()); } - iv_ruleMessageDefinition=ruleMessageDefinition - { $current=$iv_ruleMessageDefinition.current; } +// Entry rule entryRuleArtifact +entryRuleArtifact returns [EObject current=null]: + { newCompositeNode(grammarAccess.getArtifactRule()); } + iv_ruleArtifact=ruleArtifact + { $current=$iv_ruleArtifact.current; } EOF; -// Rule MessageDefinition -ruleMessageDefinition returns [EObject current=null] +// Rule Artifact +ruleArtifact returns [EObject current=null] @init { enterRule(); } @@ -1503,57 +1685,59 @@ ruleMessageDefinition returns [EObject current=null] ( { $current = forceCreateModelElement( - grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0(), + grammarAccess.getArtifactAccess().getArtifactAction_0(), $current); } ) - otherlv_1='{' - { - newLeafNode(otherlv_1, grammarAccess.getMessageDefinitionAccess().getLeftCurlyBracketKeyword_1()); - } ( ( - ( - { - newCompositeNode(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_0_0()); - } - lv_MessagePart_2_0=ruleMessagePart - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getMessageDefinitionRule()); - } - add( - $current, - "MessagePart", - lv_MessagePart_2_0, - "de.fraunhofer.ipa.ros.Ros.MessagePart"); - afterParserOrEnumRuleCall(); + { + newCompositeNode(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); + } + lv_name_1_0=ruleRosNames + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getArtifactRule()); } - ) + set( + $current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + } ) + ) + otherlv_2=Colon + { + newLeafNode(otherlv_2, grammarAccess.getArtifactAccess().getColonKeyword_2()); + } + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); + } + ( ( - ( - { - newCompositeNode(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_2_1_0()); - } - lv_MessagePart_3_0=ruleMessagePart - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getMessageDefinitionRule()); - } - add( - $current, - "MessagePart", - lv_MessagePart_3_0, - "de.fraunhofer.ipa.ros.Ros.MessagePart"); - afterParserOrEnumRuleCall(); + { + newCompositeNode(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); + } + lv_node_4_0=ruleNode + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getArtifactRule()); } - ) - )* + set( + $current, + "node", + lv_node_4_0, + "de.fraunhofer.ipa.ros.Ros.Node"); + afterParserOrEnumRuleCall(); + } + ) )? - otherlv_4='}' + this_END_5=RULE_END { - newLeafNode(otherlv_4, grammarAccess.getMessageDefinitionAccess().getRightCurlyBracketKeyword_3()); + newLeafNode(this_END_5, grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); } ) ; @@ -1574,24 +1758,16 @@ ruleNode returns [EObject current=null] leaveRule(); }: ( - otherlv_0='Node' + otherlv_0=Node_1 { newLeafNode(otherlv_0, grammarAccess.getNodeAccess().getNodeKeyword_0()); } - otherlv_1='{' - { - newLeafNode(otherlv_1, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_1()); - } - otherlv_2='name' - { - newLeafNode(otherlv_2, grammarAccess.getNodeAccess().getNameKeyword_2()); - } ( ( { - newCompositeNode(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_3_0()); + newCompositeNode(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); } - lv_name_3_0=ruleRosNames + lv_name_1_0=ruleRosNames { if ($current==null) { $current = createModelElementForParent(grammarAccess.getNodeRule()); @@ -1599,225 +1775,134 @@ ruleNode returns [EObject current=null] set( $current, "name", - lv_name_3_0, + lv_name_1_0, "de.fraunhofer.ipa.ros.Ros.RosNames"); afterParserOrEnumRuleCall(); } ) ) + this_BEGIN_2=RULE_BEGIN + { + newLeafNode(this_BEGIN_2, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); + } ( - otherlv_4='ServiceServers' - { - newLeafNode(otherlv_4, grammarAccess.getNodeAccess().getServiceServersKeyword_4_0()); - } - otherlv_5='{' - { - newLeafNode(otherlv_5, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_4_1()); - } ( - ( - { - newCompositeNode(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_2_0()); - } - lv_serviceserver_6_0=ruleServiceServer - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - $current, - "serviceserver", - lv_serviceserver_6_0, - "de.fraunhofer.ipa.ros.Ros.ServiceServer"); - afterParserOrEnumRuleCall(); - } - ) - ) - ( - otherlv_7=',' - { - newLeafNode(otherlv_7, grammarAccess.getNodeAccess().getCommaKeyword_4_3_0()); - } + otherlv_3=Publishers + { + newLeafNode(otherlv_3, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()); + } + this_BEGIN_4=RULE_BEGIN + { + newLeafNode(this_BEGIN_4, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); + } ( ( { - newCompositeNode(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_4_3_1_0()); + newCompositeNode(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); } - lv_serviceserver_8_0=ruleServiceServer + lv_publisher_5_0=rulePublisher { if ($current==null) { $current = createModelElementForParent(grammarAccess.getNodeRule()); } add( $current, - "serviceserver", - lv_serviceserver_8_0, - "de.fraunhofer.ipa.ros.Ros.ServiceServer"); + "publisher", + lv_publisher_5_0, + "de.fraunhofer.ipa.ros2.Ros2.Publisher"); afterParserOrEnumRuleCall(); } ) - ) - )* - otherlv_9='}' - { - newLeafNode(otherlv_9, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_4_4()); - } - )? - ( - otherlv_10='Publishers' - { - newLeafNode(otherlv_10, grammarAccess.getNodeAccess().getPublishersKeyword_5_0()); - } - otherlv_11='{' - { - newLeafNode(otherlv_11, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_5_1()); - } - ( - ( - { - newCompositeNode(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_2_0()); - } - lv_publisher_12_0=rulePublisher - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - $current, - "publisher", - lv_publisher_12_0, - "de.fraunhofer.ipa.ros.Ros.Publisher"); - afterParserOrEnumRuleCall(); - } - ) + )* + this_END_6=RULE_END + { + newLeafNode(this_END_6, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); + } ) + | ( - otherlv_13=',' + otherlv_7=Subscribers { - newLeafNode(otherlv_13, grammarAccess.getNodeAccess().getCommaKeyword_5_3_0()); + newLeafNode(otherlv_7, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()); + } + this_BEGIN_8=RULE_BEGIN + { + newLeafNode(this_BEGIN_8, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); } ( ( { - newCompositeNode(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_5_3_1_0()); + newCompositeNode(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); } - lv_publisher_14_0=rulePublisher + lv_subscriber_9_0=ruleSubscriber { if ($current==null) { $current = createModelElementForParent(grammarAccess.getNodeRule()); } add( $current, - "publisher", - lv_publisher_14_0, - "de.fraunhofer.ipa.ros.Ros.Publisher"); + "subscriber", + lv_subscriber_9_0, + "de.fraunhofer.ipa.ros2.Ros2.Subscriber"); afterParserOrEnumRuleCall(); } ) - ) - )* - otherlv_15='}' - { - newLeafNode(otherlv_15, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_5_4()); - } - )? - ( - otherlv_16='Subscribers' - { - newLeafNode(otherlv_16, grammarAccess.getNodeAccess().getSubscribersKeyword_6_0()); - } - otherlv_17='{' - { - newLeafNode(otherlv_17, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_6_1()); - } - ( - ( - { - newCompositeNode(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_2_0()); - } - lv_subscriber_18_0=ruleSubscriber - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - $current, - "subscriber", - lv_subscriber_18_0, - "de.fraunhofer.ipa.ros.Ros.Subscriber"); - afterParserOrEnumRuleCall(); - } - ) + )* + this_END_10=RULE_END + { + newLeafNode(this_END_10, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); + } ) + | ( - otherlv_19=',' + otherlv_11=Serviceserver + { + newLeafNode(otherlv_11, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); + } + this_BEGIN_12=RULE_BEGIN { - newLeafNode(otherlv_19, grammarAccess.getNodeAccess().getCommaKeyword_6_3_0()); + newLeafNode(this_BEGIN_12, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); } ( ( { - newCompositeNode(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_6_3_1_0()); + newCompositeNode(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); } - lv_subscriber_20_0=ruleSubscriber + lv_serviceserver_13_0=ruleServiceServer { if ($current==null) { $current = createModelElementForParent(grammarAccess.getNodeRule()); } add( $current, - "subscriber", - lv_subscriber_20_0, - "de.fraunhofer.ipa.ros.Ros.Subscriber"); + "serviceserver", + lv_serviceserver_13_0, + "de.fraunhofer.ipa.ros2.Ros2.ServiceServer"); afterParserOrEnumRuleCall(); } ) - ) - )* - otherlv_21='}' - { - newLeafNode(otherlv_21, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_6_4()); - } - )? - ( - otherlv_22='ServiceClients' - { - newLeafNode(otherlv_22, grammarAccess.getNodeAccess().getServiceClientsKeyword_7_0()); - } - otherlv_23='{' - { - newLeafNode(otherlv_23, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_7_1()); - } - ( - ( - { - newCompositeNode(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_2_0()); - } - lv_serviceclient_24_0=ruleServiceClient - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - $current, - "serviceclient", - lv_serviceclient_24_0, - "de.fraunhofer.ipa.ros.Ros.ServiceClient"); - afterParserOrEnumRuleCall(); - } - ) + )* + this_END_14=RULE_END + { + newLeafNode(this_END_14, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); + } ) + | ( - otherlv_25=',' + otherlv_15=Serviceclient + { + newLeafNode(otherlv_15, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); + } + this_BEGIN_16=RULE_BEGIN { - newLeafNode(otherlv_25, grammarAccess.getNodeAccess().getCommaKeyword_7_3_0()); + newLeafNode(this_BEGIN_16, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); } ( ( { - newCompositeNode(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_7_3_1_0()); + newCompositeNode(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); } - lv_serviceclient_26_0=ruleServiceClient + lv_serviceclient_17_0=ruleServiceClient { if ($current==null) { $current = createModelElementForParent(grammarAccess.getNodeRule()); @@ -1825,57 +1910,33 @@ ruleNode returns [EObject current=null] add( $current, "serviceclient", - lv_serviceclient_26_0, - "de.fraunhofer.ipa.ros.Ros.ServiceClient"); + lv_serviceclient_17_0, + "de.fraunhofer.ipa.ros2.Ros2.ServiceClient"); afterParserOrEnumRuleCall(); } ) - ) - )* - otherlv_27='}' - { - newLeafNode(otherlv_27, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_7_4()); - } - )? - ( - otherlv_28='ActionServers' - { - newLeafNode(otherlv_28, grammarAccess.getNodeAccess().getActionServersKeyword_8_0()); - } - otherlv_29='{' - { - newLeafNode(otherlv_29, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_8_1()); - } - ( - ( - { - newCompositeNode(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_2_0()); - } - lv_actionserver_30_0=ruleActionServer - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - $current, - "actionserver", - lv_actionserver_30_0, - "de.fraunhofer.ipa.ros.Ros.ActionServer"); - afterParserOrEnumRuleCall(); - } - ) + )* + this_END_18=RULE_END + { + newLeafNode(this_END_18, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); + } ) + | ( - otherlv_31=',' + otherlv_19=Actionserver { - newLeafNode(otherlv_31, grammarAccess.getNodeAccess().getCommaKeyword_8_3_0()); + newLeafNode(otherlv_19, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); + } + this_BEGIN_20=RULE_BEGIN + { + newLeafNode(this_BEGIN_20, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); } ( ( { - newCompositeNode(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_8_3_1_0()); + newCompositeNode(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); } - lv_actionserver_32_0=ruleActionServer + lv_actionserver_21_0=ruleActionServer { if ($current==null) { $current = createModelElementForParent(grammarAccess.getNodeRule()); @@ -1883,57 +1944,33 @@ ruleNode returns [EObject current=null] add( $current, "actionserver", - lv_actionserver_32_0, - "de.fraunhofer.ipa.ros.Ros.ActionServer"); + lv_actionserver_21_0, + "de.fraunhofer.ipa.ros2.Ros2.ActionServer"); afterParserOrEnumRuleCall(); } ) - ) - )* - otherlv_33='}' - { - newLeafNode(otherlv_33, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_8_4()); - } - )? - ( - otherlv_34='ActionClients' - { - newLeafNode(otherlv_34, grammarAccess.getNodeAccess().getActionClientsKeyword_9_0()); - } - otherlv_35='{' - { - newLeafNode(otherlv_35, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_9_1()); - } - ( - ( - { - newCompositeNode(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_2_0()); - } - lv_actionclient_36_0=ruleActionClient - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - $current, - "actionclient", - lv_actionclient_36_0, - "de.fraunhofer.ipa.ros.Ros.ActionClient"); - afterParserOrEnumRuleCall(); - } - ) + )* + this_END_22=RULE_END + { + newLeafNode(this_END_22, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); + } ) + | ( - otherlv_37=',' + otherlv_23=Actionclient + { + newLeafNode(otherlv_23, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); + } + this_BEGIN_24=RULE_BEGIN { - newLeafNode(otherlv_37, grammarAccess.getNodeAccess().getCommaKeyword_9_3_0()); + newLeafNode(this_BEGIN_24, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); } ( ( { - newCompositeNode(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_9_3_1_0()); + newCompositeNode(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); } - lv_actionclient_38_0=ruleActionClient + lv_actionclient_25_0=ruleActionClient { if ($current==null) { $current = createModelElementForParent(grammarAccess.getNodeRule()); @@ -1941,57 +1978,33 @@ ruleNode returns [EObject current=null] add( $current, "actionclient", - lv_actionclient_38_0, - "de.fraunhofer.ipa.ros.Ros.ActionClient"); + lv_actionclient_25_0, + "de.fraunhofer.ipa.ros2.Ros2.ActionClient"); afterParserOrEnumRuleCall(); } ) - ) - )* - otherlv_39='}' - { - newLeafNode(otherlv_39, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_9_4()); - } - )? - ( - otherlv_40='Parameters' - { - newLeafNode(otherlv_40, grammarAccess.getNodeAccess().getParametersKeyword_10_0()); - } - otherlv_41='{' - { - newLeafNode(otherlv_41, grammarAccess.getNodeAccess().getLeftCurlyBracketKeyword_10_1()); - } - ( - ( - { - newCompositeNode(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_2_0()); - } - lv_parameter_42_0=ruleParameter - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getNodeRule()); - } - add( - $current, - "parameter", - lv_parameter_42_0, - "de.fraunhofer.ipa.ros.Ros.Parameter"); - afterParserOrEnumRuleCall(); - } - ) + )* + this_END_26=RULE_END + { + newLeafNode(this_END_26, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); + } ) + | ( - otherlv_43=',' + otherlv_27=Parameters + { + newLeafNode(otherlv_27, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); + } + this_BEGIN_28=RULE_BEGIN { - newLeafNode(otherlv_43, grammarAccess.getNodeAccess().getCommaKeyword_10_3_0()); + newLeafNode(this_BEGIN_28, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); } ( ( { - newCompositeNode(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_10_3_1_0()); + newCompositeNode(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); } - lv_parameter_44_0=ruleParameter + lv_parameter_29_0=ruleParameter { if ($current==null) { $current = createModelElementForParent(grammarAccess.getNodeRule()); @@ -1999,34 +2012,34 @@ ruleNode returns [EObject current=null] add( $current, "parameter", - lv_parameter_44_0, - "de.fraunhofer.ipa.ros.Ros.Parameter"); + lv_parameter_29_0, + "de.fraunhofer.ipa.ros2.Ros2.Parameter"); afterParserOrEnumRuleCall(); } ) - ) - )* - otherlv_45='}' - { - newLeafNode(otherlv_45, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_10_4()); - } - )? - otherlv_46='}' + )* + this_END_30=RULE_END + { + newLeafNode(this_END_30, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); + } + ) + )* + this_END_31=RULE_END { - newLeafNode(otherlv_46, grammarAccess.getNodeAccess().getRightCurlyBracketKeyword_11()); + newLeafNode(this_END_31, grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); } ) ; -// Entry rule entryRuleServiceServer -entryRuleServiceServer returns [EObject current=null]: - { newCompositeNode(grammarAccess.getServiceServerRule()); } - iv_ruleServiceServer=ruleServiceServer - { $current=$iv_ruleServiceServer.current; } +// Entry rule entryRuleSpecBase +entryRuleSpecBase returns [EObject current=null]: + { newCompositeNode(grammarAccess.getSpecBaseRule()); } + iv_ruleSpecBase=ruleSpecBase + { $current=$iv_ruleSpecBase.current; } EOF; -// Rule ServiceServer -ruleServiceServer returns [EObject current=null] +// Rule SpecBase +ruleSpecBase returns [EObject current=null] @init { enterRule(); } @@ -2034,98 +2047,44 @@ ruleServiceServer returns [EObject current=null] leaveRule(); }: ( - otherlv_0='ServiceServer' { - newLeafNode(otherlv_0, grammarAccess.getServiceServerAccess().getServiceServerKeyword_0()); + newCompositeNode(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); } - otherlv_1='{' + this_TopicSpec_0=ruleTopicSpec { - newLeafNode(otherlv_1, grammarAccess.getServiceServerAccess().getLeftCurlyBracketKeyword_1()); + $current = $this_TopicSpec_0.current; + afterParserOrEnumRuleCall(); } - otherlv_2='name' + | { - newLeafNode(otherlv_2, grammarAccess.getServiceServerAccess().getNameKeyword_2()); + newCompositeNode(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); } - ( - ( - { - newCompositeNode(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_3_0()); - } - lv_name_3_0=ruleEString - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getServiceServerRule()); - } - set( - $current, - "name", - lv_name_3_0, - "de.fraunhofer.ipa.ros.Ros.EString"); - afterParserOrEnumRuleCall(); - } - ) - ) - otherlv_4='service' + this_ServiceSpec_1=ruleServiceSpec { - newLeafNode(otherlv_4, grammarAccess.getServiceServerAccess().getServiceKeyword_4()); + $current = $this_ServiceSpec_1.current; + afterParserOrEnumRuleCall(); } - ( - ( - { - if ($current==null) { - $current = createModelElement(grammarAccess.getServiceServerRule()); - } - } - { - newCompositeNode(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); - } - ruleEString - { - afterParserOrEnumRuleCall(); - } - ) - ) - ( - otherlv_6='namespace' - { - newLeafNode(otherlv_6, grammarAccess.getServiceServerAccess().getNamespaceKeyword_6_0()); - } - ( - ( - { - newCompositeNode(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); - } - lv_namespace_7_0=ruleNamespace - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getServiceServerRule()); - } - set( - $current, - "namespace", - lv_namespace_7_0, - "de.fraunhofer.ipa.ros.Ros.Namespace"); - afterParserOrEnumRuleCall(); - } - ) - ) - )? - otherlv_8='}' + | { - newLeafNode(otherlv_8, grammarAccess.getServiceServerAccess().getRightCurlyBracketKeyword_7()); + newCompositeNode(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); + } + this_ActionSpec_2=ruleActionSpec + { + $current = $this_ActionSpec_2.current; + afterParserOrEnumRuleCall(); } ) ; -// Entry rule entryRulePublisher -entryRulePublisher returns [EObject current=null]: - { newCompositeNode(grammarAccess.getPublisherRule()); } - iv_rulePublisher=rulePublisher - { $current=$iv_rulePublisher.current; } +// Entry rule entryRuleTopicSpec +entryRuleTopicSpec returns [EObject current=null]: + { newCompositeNode(grammarAccess.getTopicSpecRule()); } + iv_ruleTopicSpec=ruleTopicSpec + { $current=$iv_ruleTopicSpec.current; } EOF; -// Rule Publisher -rulePublisher returns [EObject current=null] +// Rule TopicSpec +ruleTopicSpec returns [EObject current=null] @init { enterRule(); } @@ -2133,197 +2092,113 @@ rulePublisher returns [EObject current=null] leaveRule(); }: ( - otherlv_0='Publisher' - { - newLeafNode(otherlv_0, grammarAccess.getPublisherAccess().getPublisherKeyword_0()); - } - otherlv_1='{' - { - newLeafNode(otherlv_1, grammarAccess.getPublisherAccess().getLeftCurlyBracketKeyword_1()); - } - otherlv_2='name' - { - newLeafNode(otherlv_2, grammarAccess.getPublisherAccess().getNameKeyword_2()); - } ( - ( - { - newCompositeNode(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_3_0()); - } - lv_name_3_0=ruleEString - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getPublisherRule()); - } - set( - $current, - "name", - lv_name_3_0, - "de.fraunhofer.ipa.ros.Ros.EString"); - afterParserOrEnumRuleCall(); - } - ) + { + $current = forceCreateModelElement( + grammarAccess.getTopicSpecAccess().getTopicSpecAction_0(), + $current); + } ) - otherlv_4='message' + otherlv_1=Msg { - newLeafNode(otherlv_4, grammarAccess.getPublisherAccess().getMessageKeyword_4()); + newLeafNode(otherlv_1, grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); } ( - ( - { - if ($current==null) { - $current = createModelElement(grammarAccess.getPublisherRule()); - } - } - { - newCompositeNode(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); - } - ruleEString - { - afterParserOrEnumRuleCall(); - } - ) - ) - ( - otherlv_6='namespace' - { - newLeafNode(otherlv_6, grammarAccess.getPublisherAccess().getNamespaceKeyword_6_0()); - } ( ( { - newCompositeNode(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + newCompositeNode(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); } - lv_namespace_7_0=ruleNamespace + lv_name_2_1=ruleEString { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getPublisherRule()); + $current = createModelElementForParent(grammarAccess.getTopicSpecRule()); } set( $current, - "namespace", - lv_namespace_7_0, - "de.fraunhofer.ipa.ros.Ros.Namespace"); + "name", + lv_name_2_1, + "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); } - ) - ) - )? - otherlv_8='}' - { - newLeafNode(otherlv_8, grammarAccess.getPublisherAccess().getRightCurlyBracketKeyword_7()); - } - ) -; - -// Entry rule entryRuleSubscriber -entryRuleSubscriber returns [EObject current=null]: - { newCompositeNode(grammarAccess.getSubscriberRule()); } - iv_ruleSubscriber=ruleSubscriber - { $current=$iv_ruleSubscriber.current; } - EOF; - -// Rule Subscriber -ruleSubscriber returns [EObject current=null] -@init { - enterRule(); -} -@after { - leaveRule(); -}: - ( - otherlv_0='Subscriber' - { - newLeafNode(otherlv_0, grammarAccess.getSubscriberAccess().getSubscriberKeyword_0()); - } - otherlv_1='{' - { - newLeafNode(otherlv_1, grammarAccess.getSubscriberAccess().getLeftCurlyBracketKeyword_1()); - } - otherlv_2='name' - { - newLeafNode(otherlv_2, grammarAccess.getSubscriberAccess().getNameKeyword_2()); - } - ( - ( - { - newCompositeNode(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_3_0()); - } - lv_name_3_0=ruleEString - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getSubscriberRule()); + | + lv_name_2_2=Header + { + newLeafNode(lv_name_2_2, grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); } - set( - $current, - "name", - lv_name_3_0, - "de.fraunhofer.ipa.ros.Ros.EString"); - afterParserOrEnumRuleCall(); - } - ) - ) - otherlv_4='message' - { - newLeafNode(otherlv_4, grammarAccess.getSubscriberAccess().getMessageKeyword_4()); - } - ( - ( - { - if ($current==null) { - $current = createModelElement(grammarAccess.getSubscriberRule()); + { + if ($current==null) { + $current = createModelElement(grammarAccess.getTopicSpecRule()); + } + setWithLastConsumed($current, "name", lv_name_2_2, null); } - } - { - newCompositeNode(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); - } - ruleEString - { - afterParserOrEnumRuleCall(); - } + | + lv_name_2_3=String + { + newLeafNode(lv_name_2_3, grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getTopicSpecRule()); + } + setWithLastConsumed($current, "name", lv_name_2_3, null); + } + ) ) ) + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Message_1 + { + newLeafNode(otherlv_4, grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); + } ( - otherlv_6='namespace' + this_BEGIN_5=RULE_BEGIN { - newLeafNode(otherlv_6, grammarAccess.getSubscriberAccess().getNamespaceKeyword_6_0()); + newLeafNode(this_BEGIN_5, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); } ( ( { - newCompositeNode(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + newCompositeNode(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); } - lv_namespace_7_0=ruleNamespace + lv_message_6_0=ruleMessageDefinition { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getSubscriberRule()); + $current = createModelElementForParent(grammarAccess.getTopicSpecRule()); } set( $current, - "namespace", - lv_namespace_7_0, - "de.fraunhofer.ipa.ros.Ros.Namespace"); + "message", + lv_message_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); afterParserOrEnumRuleCall(); } ) ) + this_END_7=RULE_END + { + newLeafNode(this_END_7, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); + } )? - otherlv_8='}' + this_END_8=RULE_END { - newLeafNode(otherlv_8, grammarAccess.getSubscriberAccess().getRightCurlyBracketKeyword_7()); + newLeafNode(this_END_8, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); } ) ; -// Entry rule entryRuleServiceClient -entryRuleServiceClient returns [EObject current=null]: - { newCompositeNode(grammarAccess.getServiceClientRule()); } - iv_ruleServiceClient=ruleServiceClient - { $current=$iv_ruleServiceClient.current; } +// Entry rule entryRuleServiceSpec +entryRuleServiceSpec returns [EObject current=null]: + { newCompositeNode(grammarAccess.getServiceSpecRule()); } + iv_ruleServiceSpec=ruleServiceSpec + { $current=$iv_ruleServiceSpec.current; } EOF; -// Rule ServiceClient -ruleServiceClient returns [EObject current=null] +// Rule ServiceSpec +ruleServiceSpec returns [EObject current=null] @init { enterRule(); } @@ -2331,98 +2206,122 @@ ruleServiceClient returns [EObject current=null] leaveRule(); }: ( - otherlv_0='ServiceClient' - { - newLeafNode(otherlv_0, grammarAccess.getServiceClientAccess().getServiceClientKeyword_0()); - } - otherlv_1='{' - { - newLeafNode(otherlv_1, grammarAccess.getServiceClientAccess().getLeftCurlyBracketKeyword_1()); - } - otherlv_2='name' + ( + { + $current = forceCreateModelElement( + grammarAccess.getServiceSpecAccess().getServiceSpecAction_0(), + $current); + } + ) + otherlv_1=Srv { - newLeafNode(otherlv_2, grammarAccess.getServiceClientAccess().getNameKeyword_2()); + newLeafNode(otherlv_1, grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); } ( ( { - newCompositeNode(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_3_0()); + newCompositeNode(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); } - lv_name_3_0=ruleEString + lv_name_2_0=ruleEString { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getServiceClientRule()); + $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); } set( $current, "name", - lv_name_3_0, + lv_name_2_0, "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); } ) ) - otherlv_4='service' + this_BEGIN_3=RULE_BEGIN + { + newLeafNode(this_BEGIN_3, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Request { - newLeafNode(otherlv_4, grammarAccess.getServiceClientAccess().getServiceKeyword_4()); + newLeafNode(otherlv_4, grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); } ( + this_BEGIN_5=RULE_BEGIN + { + newLeafNode(this_BEGIN_5, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); + } ( - { - if ($current==null) { - $current = createModelElement(grammarAccess.getServiceClientRule()); + ( + { + newCompositeNode(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); } - } - { - newCompositeNode(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); - } - ruleEString - { - afterParserOrEnumRuleCall(); - } + lv_request_6_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + $current, + "request", + lv_request_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) ) - ) + this_END_7=RULE_END + { + newLeafNode(this_END_7, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); + } + )? + otherlv_8=Response + { + newLeafNode(otherlv_8, grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); + } ( - otherlv_6='namespace' + this_BEGIN_9=RULE_BEGIN { - newLeafNode(otherlv_6, grammarAccess.getServiceClientAccess().getNamespaceKeyword_6_0()); + newLeafNode(this_BEGIN_9, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); } ( ( { - newCompositeNode(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + newCompositeNode(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); } - lv_namespace_7_0=ruleNamespace + lv_response_10_0=ruleMessageDefinition { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getServiceClientRule()); + $current = createModelElementForParent(grammarAccess.getServiceSpecRule()); } set( $current, - "namespace", - lv_namespace_7_0, - "de.fraunhofer.ipa.ros.Ros.Namespace"); + "response", + lv_response_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); afterParserOrEnumRuleCall(); } ) ) + this_END_11=RULE_END + { + newLeafNode(this_END_11, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); + } )? - otherlv_8='}' + this_END_12=RULE_END { - newLeafNode(otherlv_8, grammarAccess.getServiceClientAccess().getRightCurlyBracketKeyword_7()); + newLeafNode(this_END_12, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); } ) ; -// Entry rule entryRuleActionServer -entryRuleActionServer returns [EObject current=null]: - { newCompositeNode(grammarAccess.getActionServerRule()); } - iv_ruleActionServer=ruleActionServer - { $current=$iv_ruleActionServer.current; } +// Entry rule entryRuleActionSpec +entryRuleActionSpec returns [EObject current=null]: + { newCompositeNode(grammarAccess.getActionSpecRule()); } + iv_ruleActionSpec=ruleActionSpec + { $current=$iv_ruleActionSpec.current; } EOF; -// Rule ActionServer -ruleActionServer returns [EObject current=null] +// Rule ActionSpec +ruleActionSpec returns [EObject current=null] @init { enterRule(); } @@ -2430,98 +2329,155 @@ ruleActionServer returns [EObject current=null] leaveRule(); }: ( - otherlv_0='ActionServer' - { - newLeafNode(otherlv_0, grammarAccess.getActionServerAccess().getActionServerKeyword_0()); - } - otherlv_1='{' - { - newLeafNode(otherlv_1, grammarAccess.getActionServerAccess().getLeftCurlyBracketKeyword_1()); - } - otherlv_2='name' + ( + { + $current = forceCreateModelElement( + grammarAccess.getActionSpecAccess().getActionSpecAction_0(), + $current); + } + ) + otherlv_1=Action_1 { - newLeafNode(otherlv_2, grammarAccess.getActionServerAccess().getNameKeyword_2()); + newLeafNode(otherlv_1, grammarAccess.getActionSpecAccess().getActionKeyword_1()); } ( ( { - newCompositeNode(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_3_0()); + newCompositeNode(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); } - lv_name_3_0=ruleEString + lv_name_2_0=ruleEString { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getActionServerRule()); + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); } set( $current, "name", - lv_name_3_0, + lv_name_2_0, "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); } ) ) - otherlv_4='action' + this_BEGIN_3=RULE_BEGIN { - newLeafNode(otherlv_4, grammarAccess.getActionServerAccess().getActionKeyword_4()); + newLeafNode(this_BEGIN_3, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + } + otherlv_4=Goal_1 + { + newLeafNode(otherlv_4, grammarAccess.getActionSpecAccess().getGoalKeyword_4()); } ( + this_BEGIN_5=RULE_BEGIN + { + newLeafNode(this_BEGIN_5, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); + } ( - { - if ($current==null) { - $current = createModelElement(grammarAccess.getActionServerRule()); + ( + { + newCompositeNode(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); } - } - { - newCompositeNode(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); - } - ruleEString - { - afterParserOrEnumRuleCall(); - } + lv_goal_6_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + $current, + "goal", + lv_goal_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) ) - ) + this_END_7=RULE_END + { + newLeafNode(this_END_7, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); + } + )? + otherlv_8=Result_1 + { + newLeafNode(otherlv_8, grammarAccess.getActionSpecAccess().getResultKeyword_6()); + } ( - otherlv_6='namespace' + this_BEGIN_9=RULE_BEGIN { - newLeafNode(otherlv_6, grammarAccess.getActionServerAccess().getNamespaceKeyword_6_0()); + newLeafNode(this_BEGIN_9, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); } ( ( { - newCompositeNode(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + newCompositeNode(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); } - lv_namespace_7_0=ruleNamespace + lv_result_10_0=ruleMessageDefinition { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getActionServerRule()); + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); } set( $current, - "namespace", - lv_namespace_7_0, - "de.fraunhofer.ipa.ros.Ros.Namespace"); + "result", + lv_result_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + } + ) + ) + this_END_11=RULE_END + { + newLeafNode(this_END_11, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); + } + )? + otherlv_12=Feedback_1 + { + newLeafNode(otherlv_12, grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + } + ( + this_BEGIN_13=RULE_BEGIN + { + newLeafNode(this_BEGIN_13, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); + } + lv_feedback_14_0=ruleMessageDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + $current, + "feedback", + lv_feedback_14_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); afterParserOrEnumRuleCall(); } ) ) + this_END_15=RULE_END + { + newLeafNode(this_END_15, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); + } )? - otherlv_8='}' + this_END_16=RULE_END { - newLeafNode(otherlv_8, grammarAccess.getActionServerAccess().getRightCurlyBracketKeyword_7()); + newLeafNode(this_END_16, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); } ) ; -// Entry rule entryRuleActionClient -entryRuleActionClient returns [EObject current=null]: - { newCompositeNode(grammarAccess.getActionClientRule()); } - iv_ruleActionClient=ruleActionClient - { $current=$iv_ruleActionClient.current; } +// Entry rule entryRuleMessageDefinition +entryRuleMessageDefinition returns [EObject current=null]: + { newCompositeNode(grammarAccess.getMessageDefinitionRule()); } + iv_ruleMessageDefinition=ruleMessageDefinition + { $current=$iv_ruleMessageDefinition.current; } EOF; -// Rule ActionClient -ruleActionClient returns [EObject current=null] +// Rule MessageDefinition +ruleMessageDefinition returns [EObject current=null] @init { enterRule(); } @@ -2529,109 +2485,69 @@ ruleActionClient returns [EObject current=null] leaveRule(); }: ( - otherlv_0='ActionClient' - { - newLeafNode(otherlv_0, grammarAccess.getActionClientAccess().getActionClientKeyword_0()); - } - otherlv_1='{' - { - newLeafNode(otherlv_1, grammarAccess.getActionClientAccess().getLeftCurlyBracketKeyword_1()); - } - otherlv_2='name' - { - newLeafNode(otherlv_2, grammarAccess.getActionClientAccess().getNameKeyword_2()); - } - ( - ( - { - newCompositeNode(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_3_0()); - } - lv_name_3_0=ruleEString - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getActionClientRule()); - } - set( - $current, - "name", - lv_name_3_0, - "de.fraunhofer.ipa.ros.Ros.EString"); - afterParserOrEnumRuleCall(); - } - ) - ) - otherlv_4='action' - { - newLeafNode(otherlv_4, grammarAccess.getActionClientAccess().getActionKeyword_4()); - } - ( - ( - { - if ($current==null) { - $current = createModelElement(grammarAccess.getActionClientRule()); - } - } - { - newCompositeNode(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); - } - ruleEString - { - afterParserOrEnumRuleCall(); - } - ) - ) ( - otherlv_6='namespace' { - newLeafNode(otherlv_6, grammarAccess.getActionClientAccess().getNamespaceKeyword_6_0()); + $current = forceCreateModelElement( + grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0(), + $current); } + ) + ( ( - ( - { - newCompositeNode(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); - } - lv_namespace_7_0=ruleNamespace - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getActionClientRule()); - } - set( - $current, - "namespace", - lv_namespace_7_0, - "de.fraunhofer.ipa.ros.Ros.Namespace"); - afterParserOrEnumRuleCall(); + { + newCompositeNode(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); + } + lv_MessagePart_1_0=ruleMessagePart + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getMessageDefinitionRule()); } - ) + add( + $current, + "MessagePart", + lv_MessagePart_1_0, + "de.fraunhofer.ipa.ros.Ros.MessagePart"); + afterParserOrEnumRuleCall(); + } ) - )? - otherlv_8='}' - { - newLeafNode(otherlv_8, grammarAccess.getActionClientAccess().getRightCurlyBracketKeyword_7()); - } + )* ) ; -// Entry rule entryRuleGraphName -entryRuleGraphName returns [String current=null]: - { newCompositeNode(grammarAccess.getGraphNameRule()); } - iv_ruleGraphName=ruleGraphName - { $current=$iv_ruleGraphName.current.getText(); } +// Entry rule entryRuleDependency +entryRuleDependency returns [EObject current=null]: + { newCompositeNode(grammarAccess.getDependencyRule()); } + iv_ruleDependency=ruleDependency + { $current=$iv_ruleDependency.current; } EOF; -// Rule GraphName -ruleGraphName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +// Rule Dependency +ruleDependency returns [EObject current=null] @init { enterRule(); } @after { leaveRule(); }: - kw='GraphName' - { - $current.merge(kw); - newLeafNode(kw, grammarAccess.getGraphNameAccess().getGraphNameKeyword()); - } + ( + { + newCompositeNode(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + } + this_PackageDependency_0=rulePackageDependency + { + $current = $this_PackageDependency_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); + } + this_ExternalDependency_1=ruleExternalDependency + { + $current = $this_ExternalDependency_1.current; + afterParserOrEnumRuleCall(); + } + ) ; // Entry rule entryRulePackageDependency @@ -2690,7 +2606,7 @@ ruleExternalDependency returns [EObject current=null] $current); } ) - otherlv_1='ExternalDependency' + otherlv_1=ExternalDependency { newLeafNode(otherlv_1, grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); } @@ -2716,6 +2632,73 @@ ruleExternalDependency returns [EObject current=null] ) ; +// Entry rule entryRuleNamespace +entryRuleNamespace returns [EObject current=null]: + { newCompositeNode(grammarAccess.getNamespaceRule()); } + iv_ruleNamespace=ruleNamespace + { $current=$iv_ruleNamespace.current; } + EOF; + +// Rule Namespace +ruleNamespace returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + } + this_GlobalNamespace_0=ruleGlobalNamespace + { + $current = $this_GlobalNamespace_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + } + this_RelativeNamespace_Impl_1=ruleRelativeNamespace_Impl + { + $current = $this_RelativeNamespace_Impl_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + } + this_PrivateNamespace_2=rulePrivateNamespace + { + $current = $this_PrivateNamespace_2.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleGraphName +entryRuleGraphName returns [String current=null]: + { newCompositeNode(grammarAccess.getGraphNameRule()); } + iv_ruleGraphName=ruleGraphName + { $current=$iv_ruleGraphName.current.getText(); } + EOF; + +// Rule GraphName +ruleGraphName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw=GraphName + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + } +; + // Entry rule entryRuleGlobalNamespace entryRuleGlobalNamespace returns [EObject current=null]: { newCompositeNode(grammarAccess.getGlobalNamespaceRule()); } @@ -2739,29 +2722,21 @@ ruleGlobalNamespace returns [EObject current=null] $current); } ) - otherlv_1='GlobalNamespace' + otherlv_1=GlobalNamespace { newLeafNode(otherlv_1, grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); } - otherlv_2='{' - { - newLeafNode(otherlv_2, grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_2()); - } ( - otherlv_3='parts' - { - newLeafNode(otherlv_3, grammarAccess.getGlobalNamespaceAccess().getPartsKeyword_3_0()); - } - otherlv_4='{' + otherlv_2=LeftSquareBracket { - newLeafNode(otherlv_4, grammarAccess.getGlobalNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); + newLeafNode(otherlv_2, grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } ( ( { - newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } - lv_parts_5_0=ruleGraphName + lv_parts_3_0=ruleGraphName { if ($current==null) { $current = createModelElementForParent(grammarAccess.getGlobalNamespaceRule()); @@ -2769,23 +2744,23 @@ ruleGlobalNamespace returns [EObject current=null] add( $current, "parts", - lv_parts_5_0, + lv_parts_3_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); } ) ) ( - otherlv_6=',' + otherlv_4=Comma { - newLeafNode(otherlv_6, grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_3_3_0()); + newLeafNode(otherlv_4, grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); } ( ( { - newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } - lv_parts_7_0=ruleGraphName + lv_parts_5_0=ruleGraphName { if ($current==null) { $current = createModelElementForParent(grammarAccess.getGlobalNamespaceRule()); @@ -2793,22 +2768,18 @@ ruleGlobalNamespace returns [EObject current=null] add( $current, "parts", - lv_parts_7_0, + lv_parts_5_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); } ) ) )* - otherlv_8='}' + otherlv_6=RightSquareBracket { - newLeafNode(otherlv_8, grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_3_4()); + newLeafNode(otherlv_6, grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); } )? - otherlv_9='}' - { - newLeafNode(otherlv_9, grammarAccess.getGlobalNamespaceAccess().getRightCurlyBracketKeyword_4()); - } ) ; @@ -2835,29 +2806,21 @@ ruleRelativeNamespace_Impl returns [EObject current=null] $current); } ) - otherlv_1='RelativeNamespace' + otherlv_1=RelativeNamespace { newLeafNode(otherlv_1, grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); } - otherlv_2='{' - { - newLeafNode(otherlv_2, grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_2()); - } ( - otherlv_3='parts' - { - newLeafNode(otherlv_3, grammarAccess.getRelativeNamespace_ImplAccess().getPartsKeyword_3_0()); - } - otherlv_4='{' + otherlv_2=LeftSquareBracket { - newLeafNode(otherlv_4, grammarAccess.getRelativeNamespace_ImplAccess().getLeftCurlyBracketKeyword_3_1()); + newLeafNode(otherlv_2, grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); } ( ( { - newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_2_0()); + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); } - lv_parts_5_0=ruleGraphName + lv_parts_3_0=ruleGraphName { if ($current==null) { $current = createModelElementForParent(grammarAccess.getRelativeNamespace_ImplRule()); @@ -2865,23 +2828,23 @@ ruleRelativeNamespace_Impl returns [EObject current=null] add( $current, "parts", - lv_parts_5_0, + lv_parts_3_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); } ) ) ( - otherlv_6=',' + otherlv_4=Comma { - newLeafNode(otherlv_6, grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_3_3_0()); + newLeafNode(otherlv_4, grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); } ( ( { - newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } - lv_parts_7_0=ruleGraphName + lv_parts_5_0=ruleGraphName { if ($current==null) { $current = createModelElementForParent(grammarAccess.getRelativeNamespace_ImplRule()); @@ -2889,22 +2852,18 @@ ruleRelativeNamespace_Impl returns [EObject current=null] add( $current, "parts", - lv_parts_7_0, + lv_parts_5_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); } ) ) )* - otherlv_8='}' + otherlv_6=RightSquareBracket { - newLeafNode(otherlv_8, grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_3_4()); + newLeafNode(otherlv_6, grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); } )? - otherlv_9='}' - { - newLeafNode(otherlv_9, grammarAccess.getRelativeNamespace_ImplAccess().getRightCurlyBracketKeyword_4()); - } ) ; @@ -2931,29 +2890,21 @@ rulePrivateNamespace returns [EObject current=null] $current); } ) - otherlv_1='PrivateNamespace' + otherlv_1=PrivateNamespace { newLeafNode(otherlv_1, grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); } - otherlv_2='{' - { - newLeafNode(otherlv_2, grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_2()); - } ( - otherlv_3='parts' - { - newLeafNode(otherlv_3, grammarAccess.getPrivateNamespaceAccess().getPartsKeyword_3_0()); - } - otherlv_4='{' + otherlv_2=LeftSquareBracket { - newLeafNode(otherlv_4, grammarAccess.getPrivateNamespaceAccess().getLeftCurlyBracketKeyword_3_1()); + newLeafNode(otherlv_2, grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); } ( ( { - newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_2_0()); + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); } - lv_parts_5_0=ruleGraphName + lv_parts_3_0=ruleGraphName { if ($current==null) { $current = createModelElementForParent(grammarAccess.getPrivateNamespaceRule()); @@ -2961,23 +2912,23 @@ rulePrivateNamespace returns [EObject current=null] add( $current, "parts", - lv_parts_5_0, + lv_parts_3_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); } ) ) ( - otherlv_6=',' + otherlv_4=Comma { - newLeafNode(otherlv_6, grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_3_3_0()); + newLeafNode(otherlv_4, grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); } ( ( { - newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_3_3_1_0()); + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); } - lv_parts_7_0=ruleGraphName + lv_parts_5_0=ruleGraphName { if ($current==null) { $current = createModelElementForParent(grammarAccess.getPrivateNamespaceRule()); @@ -2985,124 +2936,18 @@ rulePrivateNamespace returns [EObject current=null] add( $current, "parts", - lv_parts_7_0, + lv_parts_5_0, "de.fraunhofer.ipa.ros.Ros.GraphName"); afterParserOrEnumRuleCall(); } ) ) )* - otherlv_8='}' - { - newLeafNode(otherlv_8, grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_3_4()); - } - )? - otherlv_9='}' - { - newLeafNode(otherlv_9, grammarAccess.getPrivateNamespaceAccess().getRightCurlyBracketKeyword_4()); - } - ) -; - -// Entry rule entryRuleParameter -entryRuleParameter returns [EObject current=null]: - { newCompositeNode(grammarAccess.getParameterRule()); } - iv_ruleParameter=ruleParameter - { $current=$iv_ruleParameter.current; } - EOF; - -// Rule Parameter -ruleParameter returns [EObject current=null] -@init { - enterRule(); -} -@after { - leaveRule(); -}: - ( - otherlv_0='Parameter' - { - newLeafNode(otherlv_0, grammarAccess.getParameterAccess().getParameterKeyword_0()); - } - otherlv_1='{' - { - newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getLeftCurlyBracketKeyword_1()); - } - otherlv_2='name' - { - newLeafNode(otherlv_2, grammarAccess.getParameterAccess().getNameKeyword_2()); - } - ( - ( - { - newCompositeNode(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_3_0()); - } - lv_name_3_0=ruleEString - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getParameterRule()); - } - set( - $current, - "name", - lv_name_3_0, - "de.fraunhofer.ipa.ros.Ros.EString"); - afterParserOrEnumRuleCall(); - } - ) - ) - ( - otherlv_4='namespace' + otherlv_6=RightSquareBracket { - newLeafNode(otherlv_4, grammarAccess.getParameterAccess().getNamespaceKeyword_4_0()); + newLeafNode(otherlv_6, grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); } - ( - ( - { - newCompositeNode(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_4_1_0()); - } - lv_namespace_5_0=ruleNamespace - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getParameterRule()); - } - set( - $current, - "namespace", - lv_namespace_5_0, - "de.fraunhofer.ipa.ros.Ros.Namespace"); - afterParserOrEnumRuleCall(); - } - ) - ) )? - otherlv_6='type' - { - newLeafNode(otherlv_6, grammarAccess.getParameterAccess().getTypeKeyword_5()); - } - ( - ( - { - newCompositeNode(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_6_0()); - } - lv_type_7_0=ruleParameterType - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getParameterRule()); - } - set( - $current, - "type", - lv_type_7_0, - "de.fraunhofer.ipa.ros.Ros.ParameterType"); - afterParserOrEnumRuleCall(); - } - ) - ) - otherlv_8='}' - { - newLeafNode(otherlv_8, grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_7()); - } ) ; @@ -3300,13 +3145,13 @@ ruleParameterListType returns [EObject current=null] $current); } ) - otherlv_1='List' + otherlv_1=List { newLeafNode(otherlv_1, grammarAccess.getParameterListTypeAccess().getListKeyword_1()); } - otherlv_2='{' + otherlv_2=LeftSquareBracket { - newLeafNode(otherlv_2, grammarAccess.getParameterListTypeAccess().getLeftCurlyBracketKeyword_2()); + newLeafNode(otherlv_2, grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); } ( ( @@ -3328,7 +3173,7 @@ ruleParameterListType returns [EObject current=null] ) ) ( - otherlv_4=',' + otherlv_4=Comma { newLeafNode(otherlv_4, grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); } @@ -3352,9 +3197,9 @@ ruleParameterListType returns [EObject current=null] ) ) )* - otherlv_6='}' + otherlv_6=RightSquareBracket { - newLeafNode(otherlv_6, grammarAccess.getParameterListTypeAccess().getRightCurlyBracketKeyword_5()); + newLeafNode(otherlv_6, grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); } ) ; @@ -3382,13 +3227,13 @@ ruleParameterStructType returns [EObject current=null] $current); } ) - otherlv_1='Struct' + otherlv_1=Struct { newLeafNode(otherlv_1, grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); } - otherlv_2='{' + otherlv_2=LeftSquareBracket { - newLeafNode(otherlv_2, grammarAccess.getParameterStructTypeAccess().getLeftCurlyBracketKeyword_2()); + newLeafNode(otherlv_2, grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); } ( ( @@ -3410,7 +3255,7 @@ ruleParameterStructType returns [EObject current=null] ) ) ( - otherlv_4=',' + otherlv_4=Comma { newLeafNode(otherlv_4, grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); } @@ -3434,9 +3279,9 @@ ruleParameterStructType returns [EObject current=null] ) ) )* - otherlv_6='}' + otherlv_6=RightSquareBracket { - newLeafNode(otherlv_6, grammarAccess.getParameterStructTypeAccess().getRightCurlyBracketKeyword_5()); + newLeafNode(otherlv_6, grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); } ) ; @@ -3464,12 +3309,12 @@ ruleParameterIntegerType returns [EObject current=null] $current); } ) - otherlv_1='Integer' + otherlv_1=Integer { newLeafNode(otherlv_1, grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); } ( - otherlv_2='default' + otherlv_2=Default { newLeafNode(otherlv_2, grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); } @@ -3519,12 +3364,12 @@ ruleParameterStringType returns [EObject current=null] $current); } ) - otherlv_1='String' + otherlv_1=String { newLeafNode(otherlv_1, grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); } ( - otherlv_2='default' + otherlv_2=Default { newLeafNode(otherlv_2, grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); } @@ -3574,12 +3419,12 @@ ruleParameterDoubleType returns [EObject current=null] $current); } ) - otherlv_1='Double' + otherlv_1=Double { newLeafNode(otherlv_1, grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); } ( - otherlv_2='default' + otherlv_2=Default { newLeafNode(otherlv_2, grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); } @@ -3629,12 +3474,12 @@ ruleParameterBooleanType returns [EObject current=null] $current); } ) - otherlv_1='Boolean' + otherlv_1=Boolean { newLeafNode(otherlv_1, grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); } ( - otherlv_2='default' + otherlv_2=Default { newLeafNode(otherlv_2, grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); } @@ -3684,12 +3529,12 @@ ruleParameterBase64Type returns [EObject current=null] $current); } ) - otherlv_1='Base64' + otherlv_1=Base64 { newLeafNode(otherlv_1, grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); } ( - otherlv_2='default' + otherlv_2=Default { newLeafNode(otherlv_2, grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); } @@ -3732,15 +3577,15 @@ ruleParameterArrayType returns [EObject current=null] leaveRule(); }: ( - otherlv_0='Array' + otherlv_0=Array { newLeafNode(otherlv_0, grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); } - otherlv_1='{' + this_BEGIN_1=RULE_BEGIN { - newLeafNode(otherlv_1, grammarAccess.getParameterArrayTypeAccess().getLeftCurlyBracketKeyword_1()); + newLeafNode(this_BEGIN_1, grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); } - otherlv_2='type' + otherlv_2=Type { newLeafNode(otherlv_2, grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); } @@ -3764,7 +3609,7 @@ ruleParameterArrayType returns [EObject current=null] ) ) ( - otherlv_4='default' + otherlv_4=Default { newLeafNode(otherlv_4, grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); } @@ -3788,9 +3633,9 @@ ruleParameterArrayType returns [EObject current=null] ) ) )? - otherlv_6='}' + this_END_6=RULE_END { - newLeafNode(otherlv_6, grammarAccess.getParameterArrayTypeAccess().getRightCurlyBracketKeyword_5()); + newLeafNode(this_END_6, grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); } ) ; @@ -3818,9 +3663,9 @@ ruleParameterList returns [EObject current=null] $current); } ) - otherlv_1='{' + otherlv_1=LeftSquareBracket { - newLeafNode(otherlv_1, grammarAccess.getParameterListAccess().getLeftCurlyBracketKeyword_1()); + newLeafNode(otherlv_1, grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); } ( ( @@ -3842,7 +3687,7 @@ ruleParameterList returns [EObject current=null] ) ) ( - otherlv_3=',' + otherlv_3=Comma { newLeafNode(otherlv_3, grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); } @@ -3866,9 +3711,9 @@ ruleParameterList returns [EObject current=null] ) ) )* - otherlv_5='}' + otherlv_5=RightSquareBracket { - newLeafNode(otherlv_5, grammarAccess.getParameterListAccess().getRightCurlyBracketKeyword_4()); + newLeafNode(otherlv_5, grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); } ) ; @@ -3896,25 +3741,21 @@ ruleParameterAny returns [EObject current=null] $current); } ) - otherlv_1='ParameterAny' + otherlv_1=ParameterAny { newLeafNode(otherlv_1, grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); } - otherlv_2='{' - { - newLeafNode(otherlv_2, grammarAccess.getParameterAnyAccess().getLeftCurlyBracketKeyword_2()); - } ( - otherlv_3='value' + otherlv_2=Value { - newLeafNode(otherlv_3, grammarAccess.getParameterAnyAccess().getValueKeyword_3_0()); + newLeafNode(otherlv_2, grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); } ( ( { - newCompositeNode(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_3_1_0()); + newCompositeNode(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); } - lv_value_4_0=ruleEString + lv_value_3_0=ruleEString { if ($current==null) { $current = createModelElementForParent(grammarAccess.getParameterAnyRule()); @@ -3922,17 +3763,13 @@ ruleParameterAny returns [EObject current=null] set( $current, "value", - lv_value_4_0, + lv_value_3_0, "de.fraunhofer.ipa.ros.Ros.EString"); afterParserOrEnumRuleCall(); } ) ) )? - otherlv_5='}' - { - newLeafNode(otherlv_5, grammarAccess.getParameterAnyAccess().getRightCurlyBracketKeyword_4()); - } ) ; @@ -4140,9 +3977,9 @@ ruleParameterStruct returns [EObject current=null] } ) ( - otherlv_1='{' + otherlv_1=LeftSquareBracket { - newLeafNode(otherlv_1, grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_0()); + newLeafNode(otherlv_1, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); } ( ( @@ -4164,13 +4001,13 @@ ruleParameterStruct returns [EObject current=null] ) ) ( - otherlv_3=',' + otherlv_3=Comma { newLeafNode(otherlv_3, grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); } - otherlv_4='{' + otherlv_4=LeftSquareBracket { - newLeafNode(otherlv_4, grammarAccess.getParameterStructAccess().getLeftCurlyBracketKeyword_1_2_1()); + newLeafNode(otherlv_4, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); } ( ( @@ -4191,14 +4028,14 @@ ruleParameterStruct returns [EObject current=null] } ) ) - otherlv_6='}' + otherlv_6=RightSquareBracket { - newLeafNode(otherlv_6, grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_2_3()); + newLeafNode(otherlv_6, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); } )* - otherlv_7='}' + otherlv_7=RightSquareBracket { - newLeafNode(otherlv_7, grammarAccess.getParameterStructAccess().getRightCurlyBracketKeyword_1_3()); + newLeafNode(otherlv_7, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); } )? ) @@ -4256,7 +4093,7 @@ ruleParameterStructMember returns [EObject current=null] leaveRule(); }: ( - otherlv_0='ParameterStructMember' + otherlv_0=ParameterStructMember { newLeafNode(otherlv_0, grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); } @@ -4279,13 +4116,13 @@ ruleParameterStructMember returns [EObject current=null] } ) ) - otherlv_2='{' + otherlv_2=Colon { - newLeafNode(otherlv_2, grammarAccess.getParameterStructMemberAccess().getLeftCurlyBracketKeyword_2()); + newLeafNode(otherlv_2, grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); } - otherlv_3='value' + this_BEGIN_3=RULE_BEGIN { - newLeafNode(otherlv_3, grammarAccess.getParameterStructMemberAccess().getValueKeyword_3()); + newLeafNode(this_BEGIN_3, grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); } ( ( @@ -4306,9 +4143,9 @@ ruleParameterStructMember returns [EObject current=null] } ) ) - otherlv_5='}' + this_END_5=RULE_END { - newLeafNode(otherlv_5, grammarAccess.getParameterStructMemberAccess().getRightCurlyBracketKeyword_5()); + newLeafNode(this_END_5, grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); } ) ; @@ -4900,7 +4737,7 @@ rulebool returns [EObject current=null] $current); } ) - otherlv_1='bool' + otherlv_1=Bool { newLeafNode(otherlv_1, grammarAccess.getBoolAccess().getBoolKeyword_1()); } @@ -4930,7 +4767,7 @@ ruleint8 returns [EObject current=null] $current); } ) - otherlv_1='int8' + otherlv_1=Int8 { newLeafNode(otherlv_1, grammarAccess.getInt8Access().getInt8Keyword_1()); } @@ -4960,7 +4797,7 @@ ruleuint8 returns [EObject current=null] $current); } ) - otherlv_1='uint8' + otherlv_1=Uint8 { newLeafNode(otherlv_1, grammarAccess.getUint8Access().getUint8Keyword_1()); } @@ -4990,7 +4827,7 @@ ruleint16 returns [EObject current=null] $current); } ) - otherlv_1='int16' + otherlv_1=Int16 { newLeafNode(otherlv_1, grammarAccess.getInt16Access().getInt16Keyword_1()); } @@ -5020,7 +4857,7 @@ ruleuint16 returns [EObject current=null] $current); } ) - otherlv_1='uint16' + otherlv_1=Uint16 { newLeafNode(otherlv_1, grammarAccess.getUint16Access().getUint16Keyword_1()); } @@ -5050,7 +4887,7 @@ ruleint32 returns [EObject current=null] $current); } ) - otherlv_1='int32' + otherlv_1=Int32 { newLeafNode(otherlv_1, grammarAccess.getInt32Access().getInt32Keyword_1()); } @@ -5080,7 +4917,7 @@ ruleuint32 returns [EObject current=null] $current); } ) - otherlv_1='uint32' + otherlv_1=Uint32 { newLeafNode(otherlv_1, grammarAccess.getUint32Access().getUint32Keyword_1()); } @@ -5110,7 +4947,7 @@ ruleint64 returns [EObject current=null] $current); } ) - otherlv_1='int64' + otherlv_1=Int64 { newLeafNode(otherlv_1, grammarAccess.getInt64Access().getInt64Keyword_1()); } @@ -5140,7 +4977,7 @@ ruleuint64 returns [EObject current=null] $current); } ) - otherlv_1='uint64' + otherlv_1=Uint64 { newLeafNode(otherlv_1, grammarAccess.getUint64Access().getUint64Keyword_1()); } @@ -5170,7 +5007,7 @@ rulefloat32 returns [EObject current=null] $current); } ) - otherlv_1='float32' + otherlv_1=Float32 { newLeafNode(otherlv_1, grammarAccess.getFloat32Access().getFloat32Keyword_1()); } @@ -5200,7 +5037,7 @@ rulefloat64 returns [EObject current=null] $current); } ) - otherlv_1='float64' + otherlv_1=Float64 { newLeafNode(otherlv_1, grammarAccess.getFloat64Access().getFloat64Keyword_1()); } @@ -5230,7 +5067,7 @@ rulestring0 returns [EObject current=null] $current); } ) - otherlv_1='string' + otherlv_1=String_1 { newLeafNode(otherlv_1, grammarAccess.getString0Access().getStringKeyword_1()); } @@ -5260,7 +5097,7 @@ rulebyte returns [EObject current=null] $current); } ) - otherlv_1='byte' + otherlv_1=Byte { newLeafNode(otherlv_1, grammarAccess.getByteAccess().getByteKeyword_1()); } @@ -5290,7 +5127,7 @@ ruletime returns [EObject current=null] $current); } ) - otherlv_1='time' + otherlv_1=Time { newLeafNode(otherlv_1, grammarAccess.getTimeAccess().getTimeKeyword_1()); } @@ -5320,7 +5157,7 @@ ruleduration returns [EObject current=null] $current); } ) - otherlv_1='duration' + otherlv_1=Duration { newLeafNode(otherlv_1, grammarAccess.getDurationAccess().getDurationKeyword_1()); } @@ -5350,7 +5187,7 @@ ruleboolArray returns [EObject current=null] $current); } ) - otherlv_1='bool[]' + otherlv_1=Bool_1 { newLeafNode(otherlv_1, grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); } @@ -5380,7 +5217,7 @@ ruleint8Array returns [EObject current=null] $current); } ) - otherlv_1='int8[]' + otherlv_1=Int8_1 { newLeafNode(otherlv_1, grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); } @@ -5410,7 +5247,7 @@ ruleuint8Array returns [EObject current=null] $current); } ) - otherlv_1='uint8[]' + otherlv_1=Uint8_1 { newLeafNode(otherlv_1, grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); } @@ -5440,7 +5277,7 @@ ruleint16Array returns [EObject current=null] $current); } ) - otherlv_1='int16[]' + otherlv_1=Int16_1 { newLeafNode(otherlv_1, grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); } @@ -5470,7 +5307,7 @@ ruleuint16Array returns [EObject current=null] $current); } ) - otherlv_1='uint16[]' + otherlv_1=Uint16_1 { newLeafNode(otherlv_1, grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); } @@ -5500,7 +5337,7 @@ ruleint32Array returns [EObject current=null] $current); } ) - otherlv_1='int32[]' + otherlv_1=Int32_1 { newLeafNode(otherlv_1, grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); } @@ -5530,7 +5367,7 @@ ruleuint32Array returns [EObject current=null] $current); } ) - otherlv_1='uint32[]' + otherlv_1=Uint32_1 { newLeafNode(otherlv_1, grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); } @@ -5560,7 +5397,7 @@ ruleint64Array returns [EObject current=null] $current); } ) - otherlv_1='int64[]' + otherlv_1=Int64_1 { newLeafNode(otherlv_1, grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); } @@ -5590,7 +5427,7 @@ ruleuint64Array returns [EObject current=null] $current); } ) - otherlv_1='uint64[]' + otherlv_1=Uint64_1 { newLeafNode(otherlv_1, grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); } @@ -5620,7 +5457,7 @@ rulefloat32Array returns [EObject current=null] $current); } ) - otherlv_1='float32[]' + otherlv_1=Float32_1 { newLeafNode(otherlv_1, grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); } @@ -5650,7 +5487,7 @@ rulefloat64Array returns [EObject current=null] $current); } ) - otherlv_1='float64[]' + otherlv_1=Float64_1 { newLeafNode(otherlv_1, grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); } @@ -5680,7 +5517,7 @@ rulestring0Array returns [EObject current=null] $current); } ) - otherlv_1='string[]' + otherlv_1=String_2 { newLeafNode(otherlv_1, grammarAccess.getString0ArrayAccess().getStringKeyword_1()); } @@ -5710,7 +5547,7 @@ rulebyteArray returns [EObject current=null] $current); } ) - otherlv_1='byte[]' + otherlv_1=Byte_1 { newLeafNode(otherlv_1, grammarAccess.getByteArrayAccess().getByteKeyword_1()); } @@ -5740,7 +5577,7 @@ ruleHeader returns [EObject current=null] $current); } ) - otherlv_1='Header' + otherlv_1=Header { newLeafNode(otherlv_1, grammarAccess.getHeaderAccess().getHeaderKeyword_1()); } @@ -5812,7 +5649,7 @@ ruleArrayTopicSpecRef returns [EObject current=null] } ) ) - otherlv_1='[]' + otherlv_1=LeftSquareBracketRightSquareBracket { newLeafNode(otherlv_1, grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); } @@ -5835,112 +5672,70 @@ ruleKEYWORD returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken() leaveRule(); }: ( - kw='goal' + kw=Goal { $current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); } | - kw='message' + kw=Message { $current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); } | - kw='result' + kw=Result { $current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getResultKeyword_2()); } | - kw='feedback' + kw=Feedback { $current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); } | - kw='name' + kw=Name { $current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getNameKeyword_4()); } | - kw='value' + kw=Value { $current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getValueKeyword_5()); } | - kw='service' + kw=Service { $current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); } | - kw='type' + kw=Type { $current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); } | - kw='action' + kw=Action { $current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getActionKeyword_8()); } | - kw='duration' + kw=Duration { $current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); } | - kw='time' + kw=Time { $current.merge(kw); newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); } ) ; - -RULE_ROS_CONVENTION_A : ('/' RULE_ID|RULE_ID '/')*; - -RULE_ROS_CONVENTION_PARAM : ('/' RULE_STRING|RULE_STRING '/'|'~' RULE_STRING)*; - -fragment RULE_DIGIT : '0'..'9'; - -RULE_BINARY : ('0b'|'0B') ('0'|'1')+; - -RULE_BOOLEAN : ('true'|'false'); - -RULE_DOUBLE : RULE_DECINT ('.' RULE_DIGIT*|('.' RULE_DIGIT*)? ('E'|'e') ('-'|'+')? RULE_DECINT); - -RULE_DECINT : ('0'|'1'..'9' RULE_DIGIT*|'-' '0'..'9' RULE_DIGIT*); - -fragment RULE_DAY : ('1'..'9'|'1'..'3' '0'..'9'); - -fragment RULE_MONTH : ('1'..'9'|'1' '0'..'2'); - -fragment RULE_YEAR : '0'..'2' '0'..'9' '0'..'9' '0'..'9'; - -fragment RULE_HOUR : ('0'..'1' '0'..'9'|'2' '0'..'3'); - -fragment RULE_MIN_SEC : '0'..'5' '0'..'9'; - -RULE_DATE_TIME : RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC; - -RULE_MESSAGE_ASIGMENT : (RULE_ID|RULE_STRING) '=' (RULE_ID|RULE_STRING|RULE_INT|'-' RULE_INT); - -RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; - -fragment RULE_INT : ('0'..'9')+; - -RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); - -RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; - -RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; - -RULE_WS : (' '|'\t'|'\r'|'\n')+; - -RULE_ANY_OTHER : .; diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/internal/InternalRos2Parser.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/internal/InternalRos2Parser.java new file mode 100644 index 000000000..b8af8ce4e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/internal/InternalRos2Parser.java @@ -0,0 +1,15099 @@ +package de.fraunhofer.ipa.ros2.parser.antlr.internal; + +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; +import de.fraunhofer.ipa.ros2.services.Ros2GrammarAccess; + + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalRos2Parser extends AbstractInternalAntlrParser { + public static final String[] tokenNames = new String[] { + "", "", "", "", "ParameterStructMember", "ExternalDependency", "RelativeNamespace", "PrivateNamespace", "GlobalNamespace", "Transient_local", "Serviceclient", "Serviceserver", "Actionclient", "Actionserver", "Dependencies", "Parameter_qos", "ParameterAny", "FromGitRepo", "Reliability", "Services_qos", "Subscribers", "Best_effort", "Default_qos", "Durability", "Parameters", "Publishers", "Artifacts", "Sensor_qos", "GraphName", "Feedback_1", "Float32_1", "Float64_1", "Keep_last", "Response", "Duration", "Feedback", "History", "Keep_all", "Message_1", "Profile", "Reliable", "Request", "String_2", "Uint16_1", "Uint32_1", "Uint64_1", "Volatile", "Boolean", "Integer", "Action_1", "Default", "Float32", "Float64", "Int16_1", "Int32_1", "Int64_1", "Message", "Result_1", "Service", "Uint8_1", "Array", "Base64", "Double", "Header", "String", "Struct", "Action", "Bool_1", "Byte_1", "Depth", "Int8_1", "Result", "Specs", "String_1", "Uint16", "Uint32", "Uint64", "Goal_1", "Int16", "Int32", "Int64", "Node_1", "Type_1", "Uint8", "Value", "Date", "List", "Bool", "Byte", "Goal", "Int8", "Msg", "Name", "Node", "Qos", "Srv", "Time", "Type", "Any", "Ns", "LeftSquareBracketRightSquareBracket", "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_DIGIT", "RULE_BINARY", "RULE_BOOLEAN", "RULE_DECINT", "RULE_DOUBLE", "RULE_DAY", "RULE_MONTH", "RULE_YEAR", "RULE_HOUR", "RULE_MIN_SEC", "RULE_DATE_TIME", "RULE_INT", "RULE_MESSAGE_ASIGMENT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER" + }; + public static final int Float32_1=30; + public static final int Node=93; + public static final int RULE_DATE_TIME=123; + public static final int Uint64_1=45; + public static final int String=64; + public static final int History=36; + public static final int Int16=78; + public static final int Float32=51; + public static final int Goal=89; + public static final int Bool=87; + public static final int Uint16=74; + public static final int Boolean=47; + public static final int ExternalDependency=5; + public static final int Uint8=83; + public static final int Parameters=24; + public static final int RULE_ID=109; + public static final int Actionclient=12; + public static final int RULE_DIGIT=113; + public static final int GlobalNamespace=8; + public static final int Artifacts=26; + public static final int Node_1=81; + public static final int Int16_1=53; + public static final int Header=63; + public static final int RULE_INT=124; + public static final int Byte=88; + public static final int RULE_ML_COMMENT=126; + public static final int LeftSquareBracket=103; + public static final int Specs=72; + public static final int Base64=61; + public static final int Message_1=38; + public static final int Profile=39; + public static final int Depth=69; + public static final int Comma=101; + public static final int RULE_MESSAGE_ASIGMENT=125; + public static final int Goal_1=77; + public static final int LeftSquareBracketRightSquareBracket=100; + public static final int Int32=79; + public static final int Publishers=25; + public static final int Serviceserver=11; + public static final int Parameter_qos=15; + public static final int RightCurlyBracket=105; + public static final int RULE_DECINT=116; + public static final int Reliable=40; + public static final int Uint32=75; + public static final int FromGitRepo=17; + public static final int Msg=91; + public static final int RULE_HOUR=121; + public static final int Int8=90; + public static final int Default=50; + public static final int Actionserver=13; + public static final int Int8_1=70; + public static final int Uint16_1=43; + public static final int Type=97; + public static final int Float64=52; + public static final int Int32_1=54; + public static final int Result_1=57; + public static final int Keep_all=37; + public static final int RULE_BINARY=114; + public static final int String_1=73; + public static final int Subscribers=20; + public static final int String_2=42; + public static final int RULE_BEGIN=106; + public static final int RULE_DAY=118; + public static final int Services_qos=19; + public static final int RULE_BOOLEAN=115; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=120; + public static final int Feedback_1=29; + public static final int Result=71; + public static final int Name=92; + public static final int RULE_MIN_SEC=122; + public static final int Default_qos=22; + public static final int ParameterAny=16; + public static final int List=86; + public static final int Dependencies=14; + public static final int RightSquareBracket=104; + public static final int PrivateNamespace=7; + public static final int GraphName=28; + public static final int Byte_1=68; + public static final int Float64_1=31; + public static final int Durability=23; + public static final int Duration=34; + public static final int Uint32_1=44; + public static final int Action_1=49; + public static final int Double=62; + public static final int Keep_last=32; + public static final int Type_1=82; + public static final int Value=84; + public static final int Transient_local=9; + public static final int Uint64=76; + public static final int Action=66; + public static final int RULE_END=107; + public static final int Message=56; + public static final int Time=96; + public static final int RULE_STRING=111; + public static final int Best_effort=21; + public static final int Bool_1=67; + public static final int Any=98; + public static final int Struct=65; + public static final int RULE_SL_COMMENT=108; + public static final int Uint8_1=59; + public static final int RULE_DOUBLE=117; + public static final int Feedback=35; + public static final int ParameterStructMember=4; + public static final int Srv=95; + public static final int RULE_ROS_CONVENTION_A=110; + public static final int RULE_ROS_CONVENTION_PARAM=112; + public static final int Colon=102; + public static final int EOF=-1; + public static final int Ns=99; + public static final int RULE_WS=127; + public static final int Request=41; + public static final int Int64_1=55; + public static final int Service=58; + public static final int Sensor_qos=27; + public static final int RULE_ANY_OTHER=128; + public static final int Volatile=46; + public static final int Date=85; + public static final int Response=33; + public static final int Integer=48; + public static final int Array=60; + public static final int Serviceclient=10; + public static final int Qos=94; + public static final int Int64=80; + public static final int RULE_MONTH=119; + public static final int Reliability=18; + + // delegates + // delegators + + + public InternalRos2Parser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public InternalRos2Parser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + + public String[] getTokenNames() { return InternalRos2Parser.tokenNames; } + public String getGrammarFileName() { return "InternalRos2Parser.g"; } + + + + private Ros2GrammarAccess grammarAccess; + + public InternalRos2Parser(TokenStream input, Ros2GrammarAccess grammarAccess) { + this(input); + this.grammarAccess = grammarAccess; + registerRules(grammarAccess.getGrammar()); + } + + @Override + protected String getFirstRuleName() { + return "Package"; + } + + @Override + protected Ros2GrammarAccess getGrammarAccess() { + return grammarAccess; + } + + + + + // $ANTLR start "entryRulePackage" + // InternalRos2Parser.g:57:1: entryRulePackage returns [EObject current=null] : iv_rulePackage= rulePackage EOF ; + public final EObject entryRulePackage() throws RecognitionException { + EObject current = null; + + EObject iv_rulePackage = null; + + + try { + // InternalRos2Parser.g:57:48: (iv_rulePackage= rulePackage EOF ) + // InternalRos2Parser.g:58:2: iv_rulePackage= rulePackage EOF + { + newCompositeNode(grammarAccess.getPackageRule()); + pushFollow(FOLLOW_1); + iv_rulePackage=rulePackage(); + + state._fsp--; + + current =iv_rulePackage; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePackage" + + + // $ANTLR start "rulePackage" + // InternalRos2Parser.g:64:1: rulePackage returns [EObject current=null] : this_AmentPackage_0= ruleAmentPackage ; + public final EObject rulePackage() throws RecognitionException { + EObject current = null; + + EObject this_AmentPackage_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:70:2: (this_AmentPackage_0= ruleAmentPackage ) + // InternalRos2Parser.g:71:2: this_AmentPackage_0= ruleAmentPackage + { + + newCompositeNode(grammarAccess.getPackageAccess().getAmentPackageParserRuleCall()); + + pushFollow(FOLLOW_2); + this_AmentPackage_0=ruleAmentPackage(); + + state._fsp--; + + + current = this_AmentPackage_0; + afterParserOrEnumRuleCall(); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePackage" + + + // $ANTLR start "entryRuleAmentPackage" + // InternalRos2Parser.g:82:1: entryRuleAmentPackage returns [EObject current=null] : iv_ruleAmentPackage= ruleAmentPackage EOF ; + public final EObject entryRuleAmentPackage() throws RecognitionException { + EObject current = null; + + EObject iv_ruleAmentPackage = null; + + + try { + // InternalRos2Parser.g:82:53: (iv_ruleAmentPackage= ruleAmentPackage EOF ) + // InternalRos2Parser.g:83:2: iv_ruleAmentPackage= ruleAmentPackage EOF + { + newCompositeNode(grammarAccess.getAmentPackageRule()); + pushFollow(FOLLOW_1); + iv_ruleAmentPackage=ruleAmentPackage(); + + state._fsp--; + + current =iv_ruleAmentPackage; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleAmentPackage" + + + // $ANTLR start "ruleAmentPackage" + // InternalRos2Parser.g:89:1: ruleAmentPackage 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 ruleAmentPackage() 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 { + // InternalRos2Parser.g:95: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 ) ) + // InternalRos2Parser.g:96: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 ) + { + // InternalRos2Parser.g:96: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 ) + // InternalRos2Parser.g:97: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 + { + // InternalRos2Parser.g:97:3: () + // InternalRos2Parser.g:98:4: + { + + current = forceCreateModelElement( + grammarAccess.getAmentPackageAccess().getAmentPackageAction_0(), + current); + + + } + + // InternalRos2Parser.g:104:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRos2Parser.g:105:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRos2Parser.g:105:4: (lv_name_1_0= ruleRosNames ) + // InternalRos2Parser.g:106:5: lv_name_1_0= ruleRosNames + { + + newCompositeNode(grammarAccess.getAmentPackageAccess().getNameRosNamesParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleRosNames(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAmentPackageRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getAmentPackageAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_5); + + newLeafNode(this_BEGIN_3, grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_3()); + + // InternalRos2Parser.g:131: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 : + // InternalRos2Parser.g:132:4: otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) + { + otherlv_4=(Token)match(input,FromGitRepo,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getAmentPackageAccess().getFromGitRepoKeyword_4_0()); + + // InternalRos2Parser.g:136:4: ( (lv_fromGitRepo_5_0= ruleEString ) ) + // InternalRos2Parser.g:137:5: (lv_fromGitRepo_5_0= ruleEString ) + { + // InternalRos2Parser.g:137:5: (lv_fromGitRepo_5_0= ruleEString ) + // InternalRos2Parser.g:138:6: lv_fromGitRepo_5_0= ruleEString + { + + newCompositeNode(grammarAccess.getAmentPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + + pushFollow(FOLLOW_7); + lv_fromGitRepo_5_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAmentPackageRule()); + } + set( + current, + "fromGitRepo", + lv_fromGitRepo_5_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos2Parser.g:156: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 : + // InternalRos2Parser.g:157: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.getAmentPackageAccess().getArtifactsKeyword_5_0()); + + this_BEGIN_7=(Token)match(input,RULE_BEGIN,FOLLOW_8); + + newLeafNode(this_BEGIN_7, grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_5_1()); + + // InternalRos2Parser.g:165: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 : + // InternalRos2Parser.g:166:5: (lv_artifact_8_0= ruleArtifact ) + { + // InternalRos2Parser.g:166:5: (lv_artifact_8_0= ruleArtifact ) + // InternalRos2Parser.g:167:6: lv_artifact_8_0= ruleArtifact + { + + newCompositeNode(grammarAccess.getAmentPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); + + pushFollow(FOLLOW_8); + lv_artifact_8_0=ruleArtifact(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAmentPackageRule()); + } + add( + current, + "artifact", + lv_artifact_8_0, + "de.fraunhofer.ipa.ros.Ros.Artifact"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop2; + } + } while (true); + + this_END_9=(Token)match(input,RULE_END,FOLLOW_9); + + newLeafNode(this_END_9, grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_5_3()); + + + } + break; + + } + + // InternalRos2Parser.g:189: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 : + // InternalRos2Parser.g:190: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.getAmentPackageAccess().getDependenciesKeyword_6_0()); + + otherlv_11=(Token)match(input,LeftSquareBracket,FOLLOW_11); + + newLeafNode(otherlv_11, grammarAccess.getAmentPackageAccess().getLeftSquareBracketKeyword_6_1()); + + // InternalRos2Parser.g:198:4: ( (lv_dependency_12_0= ruleDependency ) ) + // InternalRos2Parser.g:199:5: (lv_dependency_12_0= ruleDependency ) + { + // InternalRos2Parser.g:199:5: (lv_dependency_12_0= ruleDependency ) + // InternalRos2Parser.g:200:6: lv_dependency_12_0= ruleDependency + { + + newCompositeNode(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); + + pushFollow(FOLLOW_12); + lv_dependency_12_0=ruleDependency(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAmentPackageRule()); + } + add( + current, + "dependency", + lv_dependency_12_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:217: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 : + // InternalRos2Parser.g:218:5: otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) + { + otherlv_13=(Token)match(input,Comma,FOLLOW_11); + + newLeafNode(otherlv_13, grammarAccess.getAmentPackageAccess().getCommaKeyword_6_3_0()); + + // InternalRos2Parser.g:222:5: ( (lv_dependency_14_0= ruleDependency ) ) + // InternalRos2Parser.g:223:6: (lv_dependency_14_0= ruleDependency ) + { + // InternalRos2Parser.g:223:6: (lv_dependency_14_0= ruleDependency ) + // InternalRos2Parser.g:224:7: lv_dependency_14_0= ruleDependency + { + + newCompositeNode(grammarAccess.getAmentPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + + pushFollow(FOLLOW_12); + lv_dependency_14_0=ruleDependency(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAmentPackageRule()); + } + add( + current, + "dependency", + lv_dependency_14_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop4; + } + } while (true); + + otherlv_15=(Token)match(input,RightSquareBracket,FOLLOW_13); + + newLeafNode(otherlv_15, grammarAccess.getAmentPackageAccess().getRightSquareBracketKeyword_6_4()); + + + } + break; + + } + + this_END_16=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_16, grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_7()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleAmentPackage" + + + // $ANTLR start "entryRuleQualityOfService" + // InternalRos2Parser.g:255:1: entryRuleQualityOfService returns [EObject current=null] : iv_ruleQualityOfService= ruleQualityOfService EOF ; + public final EObject entryRuleQualityOfService() throws RecognitionException { + EObject current = null; + + EObject iv_ruleQualityOfService = null; + + + try { + // InternalRos2Parser.g:255:57: (iv_ruleQualityOfService= ruleQualityOfService EOF ) + // InternalRos2Parser.g:256:2: iv_ruleQualityOfService= ruleQualityOfService EOF + { + newCompositeNode(grammarAccess.getQualityOfServiceRule()); + pushFollow(FOLLOW_1); + iv_ruleQualityOfService=ruleQualityOfService(); + + state._fsp--; + + current =iv_ruleQualityOfService; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualityOfService" + + + // $ANTLR start "ruleQualityOfService" + // InternalRos2Parser.g:262:1: ruleQualityOfService returns [EObject current=null] : ( () ( ( ( ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* ) ) ) ) ; + public final EObject ruleQualityOfService() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token lv_QoSProfile_3_1=null; + Token lv_QoSProfile_3_2=null; + Token lv_QoSProfile_3_3=null; + Token lv_QoSProfile_3_4=null; + Token otherlv_4=null; + Token lv_History_5_1=null; + Token lv_History_5_2=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token lv_Reliability_9_1=null; + Token lv_Reliability_9_2=null; + Token otherlv_10=null; + Token lv_Durability_11_1=null; + Token lv_Durability_11_2=null; + AntlrDatatypeRuleToken lv_Depth_7_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:268:2: ( ( () ( ( ( ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* ) ) ) ) ) + // InternalRos2Parser.g:269:2: ( () ( ( ( ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* ) ) ) ) + { + // InternalRos2Parser.g:269:2: ( () ( ( ( ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* ) ) ) ) + // InternalRos2Parser.g:270:3: () ( ( ( ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* ) ) ) + { + // InternalRos2Parser.g:270:3: () + // InternalRos2Parser.g:271:4: + { + + current = forceCreateModelElement( + grammarAccess.getQualityOfServiceAccess().getQualityOfServiceAction_0(), + current); + + + } + + // InternalRos2Parser.g:277:3: ( ( ( ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* ) ) ) + // InternalRos2Parser.g:278:4: ( ( ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* ) ) + { + // InternalRos2Parser.g:278:4: ( ( ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* ) ) + // InternalRos2Parser.g:279:5: ( ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* ) + { + + getUnorderedGroupHelper().enter(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + + // InternalRos2Parser.g:282:5: ( ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* ) + // InternalRos2Parser.g:283:6: ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* + { + // InternalRos2Parser.g:283:6: ( ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) | ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) )* + loop10: + do { + int alt10=6; + int LA10_0 = input.LA(1); + + if ( LA10_0 == Profile && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0) ) { + alt10=1; + } + else if ( LA10_0 == History && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1) ) { + alt10=2; + } + else if ( LA10_0 == Depth && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2) ) { + alt10=3; + } + else if ( LA10_0 == Reliability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3) ) { + alt10=4; + } + else if ( LA10_0 == Durability && getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4) ) { + alt10=5; + } + + + switch (alt10) { + case 1 : + // InternalRos2Parser.g:284:4: ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) + { + // InternalRos2Parser.g:284:4: ({...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) ) + // InternalRos2Parser.g:285:5: {...}? => ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) + { + if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0) ) { + throw new FailedPredicateException(input, "ruleQualityOfService", "getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0)"); + } + // InternalRos2Parser.g:285:113: ( ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) ) + // InternalRos2Parser.g:286:6: ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) + { + + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 0); + + // InternalRos2Parser.g:289:9: ({...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) ) + // InternalRos2Parser.g:289:10: {...}? => (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) + { + if ( !((true)) ) { + throw new FailedPredicateException(input, "ruleQualityOfService", "true"); + } + // InternalRos2Parser.g:289:19: (otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) ) + // InternalRos2Parser.g:289:20: otherlv_2= Profile ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) + { + otherlv_2=(Token)match(input,Profile,FOLLOW_14); + + newLeafNode(otherlv_2, grammarAccess.getQualityOfServiceAccess().getProfileKeyword_1_0_0()); + + // InternalRos2Parser.g:293:9: ( ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) ) + // InternalRos2Parser.g:294:10: ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) + { + // InternalRos2Parser.g:294:10: ( (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) ) + // InternalRos2Parser.g:295:11: (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) + { + // InternalRos2Parser.g:295:11: (lv_QoSProfile_3_1= Default_qos | lv_QoSProfile_3_2= Services_qos | lv_QoSProfile_3_3= Sensor_qos | lv_QoSProfile_3_4= Parameter_qos ) + int alt6=4; + switch ( input.LA(1) ) { + case Default_qos: + { + alt6=1; + } + break; + case Services_qos: + { + alt6=2; + } + break; + case Sensor_qos: + { + alt6=3; + } + break; + case Parameter_qos: + { + alt6=4; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + + switch (alt6) { + case 1 : + // InternalRos2Parser.g:296:12: lv_QoSProfile_3_1= Default_qos + { + lv_QoSProfile_3_1=(Token)match(input,Default_qos,FOLLOW_15); + + newLeafNode(lv_QoSProfile_3_1, grammarAccess.getQualityOfServiceAccess().getQoSProfileDefault_qosKeyword_1_0_1_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed(current, "QoSProfile", lv_QoSProfile_3_1, null); + + + } + break; + case 2 : + // InternalRos2Parser.g:307:12: lv_QoSProfile_3_2= Services_qos + { + lv_QoSProfile_3_2=(Token)match(input,Services_qos,FOLLOW_15); + + newLeafNode(lv_QoSProfile_3_2, grammarAccess.getQualityOfServiceAccess().getQoSProfileServices_qosKeyword_1_0_1_0_1()); + + + if (current==null) { + current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed(current, "QoSProfile", lv_QoSProfile_3_2, null); + + + } + break; + case 3 : + // InternalRos2Parser.g:318:12: lv_QoSProfile_3_3= Sensor_qos + { + lv_QoSProfile_3_3=(Token)match(input,Sensor_qos,FOLLOW_15); + + newLeafNode(lv_QoSProfile_3_3, grammarAccess.getQualityOfServiceAccess().getQoSProfileSensor_qosKeyword_1_0_1_0_2()); + + + if (current==null) { + current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed(current, "QoSProfile", lv_QoSProfile_3_3, null); + + + } + break; + case 4 : + // InternalRos2Parser.g:329:12: lv_QoSProfile_3_4= Parameter_qos + { + lv_QoSProfile_3_4=(Token)match(input,Parameter_qos,FOLLOW_15); + + newLeafNode(lv_QoSProfile_3_4, grammarAccess.getQualityOfServiceAccess().getQoSProfileParameter_qosKeyword_1_0_1_0_3()); + + + if (current==null) { + current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed(current, "QoSProfile", lv_QoSProfile_3_4, null); + + + } + break; + + } + + + } + + + } + + + } + + + } + + + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + + + } + + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:348:4: ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) + { + // InternalRos2Parser.g:348:4: ({...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) ) + // InternalRos2Parser.g:349:5: {...}? => ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) + { + if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1) ) { + throw new FailedPredicateException(input, "ruleQualityOfService", "getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1)"); + } + // InternalRos2Parser.g:349:113: ( ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) ) + // InternalRos2Parser.g:350:6: ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) + { + + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 1); + + // InternalRos2Parser.g:353:9: ({...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) ) + // InternalRos2Parser.g:353:10: {...}? => (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) + { + if ( !((true)) ) { + throw new FailedPredicateException(input, "ruleQualityOfService", "true"); + } + // InternalRos2Parser.g:353:19: (otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) ) + // InternalRos2Parser.g:353:20: otherlv_4= History ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) + { + otherlv_4=(Token)match(input,History,FOLLOW_16); + + newLeafNode(otherlv_4, grammarAccess.getQualityOfServiceAccess().getHistoryKeyword_1_1_0()); + + // InternalRos2Parser.g:357:9: ( ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) ) + // InternalRos2Parser.g:358:10: ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) + { + // InternalRos2Parser.g:358:10: ( (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) ) + // InternalRos2Parser.g:359:11: (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) + { + // InternalRos2Parser.g:359:11: (lv_History_5_1= Keep_last | lv_History_5_2= Keep_all ) + int alt7=2; + int LA7_0 = input.LA(1); + + if ( LA7_0 == Keep_last ) { + alt7=1; + } + else if ( LA7_0 == Keep_all ) { + alt7=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + + throw nvae; + } + switch (alt7) { + case 1 : + // InternalRos2Parser.g:360:12: lv_History_5_1= Keep_last + { + lv_History_5_1=(Token)match(input,Keep_last,FOLLOW_15); + + newLeafNode(lv_History_5_1, grammarAccess.getQualityOfServiceAccess().getHistoryKeep_lastKeyword_1_1_1_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed(current, "History", lv_History_5_1, null); + + + } + break; + case 2 : + // InternalRos2Parser.g:371:12: lv_History_5_2= Keep_all + { + lv_History_5_2=(Token)match(input,Keep_all,FOLLOW_15); + + newLeafNode(lv_History_5_2, grammarAccess.getQualityOfServiceAccess().getHistoryKeep_allKeyword_1_1_1_0_1()); + + + if (current==null) { + current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed(current, "History", lv_History_5_2, null); + + + } + break; + + } + + + } + + + } + + + } + + + } + + + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + + + } + + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:390:4: ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) + { + // InternalRos2Parser.g:390:4: ({...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) ) + // InternalRos2Parser.g:391:5: {...}? => ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) + { + if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2) ) { + throw new FailedPredicateException(input, "ruleQualityOfService", "getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2)"); + } + // InternalRos2Parser.g:391:113: ( ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) ) + // InternalRos2Parser.g:392:6: ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) + { + + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 2); + + // InternalRos2Parser.g:395:9: ({...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) ) + // InternalRos2Parser.g:395:10: {...}? => (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) + { + if ( !((true)) ) { + throw new FailedPredicateException(input, "ruleQualityOfService", "true"); + } + // InternalRos2Parser.g:395:19: (otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) ) + // InternalRos2Parser.g:395:20: otherlv_6= Depth ( (lv_Depth_7_0= ruleInteger0 ) ) + { + otherlv_6=(Token)match(input,Depth,FOLLOW_17); + + newLeafNode(otherlv_6, grammarAccess.getQualityOfServiceAccess().getDepthKeyword_1_2_0()); + + // InternalRos2Parser.g:399:9: ( (lv_Depth_7_0= ruleInteger0 ) ) + // InternalRos2Parser.g:400:10: (lv_Depth_7_0= ruleInteger0 ) + { + // InternalRos2Parser.g:400:10: (lv_Depth_7_0= ruleInteger0 ) + // InternalRos2Parser.g:401:11: lv_Depth_7_0= ruleInteger0 + { + + newCompositeNode(grammarAccess.getQualityOfServiceAccess().getDepthInteger0ParserRuleCall_1_2_1_0()); + + pushFollow(FOLLOW_15); + lv_Depth_7_0=ruleInteger0(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getQualityOfServiceRule()); + } + set( + current, + "Depth", + lv_Depth_7_0, + "de.fraunhofer.ipa.ros.Ros.Integer0"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + + + } + + + } + + + } + break; + case 4 : + // InternalRos2Parser.g:424:4: ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) + { + // InternalRos2Parser.g:424:4: ({...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) ) + // InternalRos2Parser.g:425:5: {...}? => ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) + { + if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3) ) { + throw new FailedPredicateException(input, "ruleQualityOfService", "getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3)"); + } + // InternalRos2Parser.g:425:113: ( ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) ) + // InternalRos2Parser.g:426:6: ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) + { + + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 3); + + // InternalRos2Parser.g:429:9: ({...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) ) + // InternalRos2Parser.g:429:10: {...}? => (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) + { + if ( !((true)) ) { + throw new FailedPredicateException(input, "ruleQualityOfService", "true"); + } + // InternalRos2Parser.g:429:19: (otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) ) + // InternalRos2Parser.g:429:20: otherlv_8= Reliability ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) + { + otherlv_8=(Token)match(input,Reliability,FOLLOW_18); + + newLeafNode(otherlv_8, grammarAccess.getQualityOfServiceAccess().getReliabilityKeyword_1_3_0()); + + // InternalRos2Parser.g:433:9: ( ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) ) + // InternalRos2Parser.g:434:10: ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) + { + // InternalRos2Parser.g:434:10: ( (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) ) + // InternalRos2Parser.g:435:11: (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) + { + // InternalRos2Parser.g:435:11: (lv_Reliability_9_1= Best_effort | lv_Reliability_9_2= Reliable ) + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0==Best_effort) ) { + alt8=1; + } + else if ( (LA8_0==Reliable) ) { + alt8=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 8, 0, input); + + throw nvae; + } + switch (alt8) { + case 1 : + // InternalRos2Parser.g:436:12: lv_Reliability_9_1= Best_effort + { + lv_Reliability_9_1=(Token)match(input,Best_effort,FOLLOW_15); + + newLeafNode(lv_Reliability_9_1, grammarAccess.getQualityOfServiceAccess().getReliabilityBest_effortKeyword_1_3_1_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed(current, "Reliability", lv_Reliability_9_1, null); + + + } + break; + case 2 : + // InternalRos2Parser.g:447:12: lv_Reliability_9_2= Reliable + { + lv_Reliability_9_2=(Token)match(input,Reliable,FOLLOW_15); + + newLeafNode(lv_Reliability_9_2, grammarAccess.getQualityOfServiceAccess().getReliabilityReliableKeyword_1_3_1_0_1()); + + + if (current==null) { + current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed(current, "Reliability", lv_Reliability_9_2, null); + + + } + break; + + } + + + } + + + } + + + } + + + } + + + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + + + } + + + } + + + } + break; + case 5 : + // InternalRos2Parser.g:466:4: ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) + { + // InternalRos2Parser.g:466:4: ({...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) ) + // InternalRos2Parser.g:467:5: {...}? => ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) + { + if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4) ) { + throw new FailedPredicateException(input, "ruleQualityOfService", "getUnorderedGroupHelper().canSelect(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4)"); + } + // InternalRos2Parser.g:467:113: ( ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) ) + // InternalRos2Parser.g:468:6: ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) + { + + getUnorderedGroupHelper().select(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1(), 4); + + // InternalRos2Parser.g:471:9: ({...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) ) + // InternalRos2Parser.g:471:10: {...}? => (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) + { + if ( !((true)) ) { + throw new FailedPredicateException(input, "ruleQualityOfService", "true"); + } + // InternalRos2Parser.g:471:19: (otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) ) + // InternalRos2Parser.g:471:20: otherlv_10= Durability ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) + { + otherlv_10=(Token)match(input,Durability,FOLLOW_19); + + newLeafNode(otherlv_10, grammarAccess.getQualityOfServiceAccess().getDurabilityKeyword_1_4_0()); + + // InternalRos2Parser.g:475:9: ( ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) ) + // InternalRos2Parser.g:476:10: ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) + { + // InternalRos2Parser.g:476:10: ( (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) ) + // InternalRos2Parser.g:477:11: (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) + { + // InternalRos2Parser.g:477:11: (lv_Durability_11_1= Transient_local | lv_Durability_11_2= Volatile ) + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0==Transient_local) ) { + alt9=1; + } + else if ( (LA9_0==Volatile) ) { + alt9=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + + throw nvae; + } + switch (alt9) { + case 1 : + // InternalRos2Parser.g:478:12: lv_Durability_11_1= Transient_local + { + lv_Durability_11_1=(Token)match(input,Transient_local,FOLLOW_15); + + newLeafNode(lv_Durability_11_1, grammarAccess.getQualityOfServiceAccess().getDurabilityTransient_localKeyword_1_4_1_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed(current, "Durability", lv_Durability_11_1, null); + + + } + break; + case 2 : + // InternalRos2Parser.g:489:12: lv_Durability_11_2= Volatile + { + lv_Durability_11_2=(Token)match(input,Volatile,FOLLOW_15); + + newLeafNode(lv_Durability_11_2, grammarAccess.getQualityOfServiceAccess().getDurabilityVolatileKeyword_1_4_1_0_1()); + + + if (current==null) { + current = createModelElement(grammarAccess.getQualityOfServiceRule()); + } + setWithLastConsumed(current, "Durability", lv_Durability_11_2, null); + + + } + break; + + } + + + } + + + } + + + } + + + } + + + getUnorderedGroupHelper().returnFromSelection(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + + + } + + + } + + + } + break; + + default : + break loop10; + } + } while (true); + + + } + + + } + + + getUnorderedGroupHelper().leave(grammarAccess.getQualityOfServiceAccess().getUnorderedGroup_1()); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualityOfService" + + + // $ANTLR start "entryRulePublisher" + // InternalRos2Parser.g:519:1: entryRulePublisher returns [EObject current=null] : iv_rulePublisher= rulePublisher EOF ; + public final EObject entryRulePublisher() throws RecognitionException { + EObject current = null; + + EObject iv_rulePublisher = null; + + + try { + // InternalRos2Parser.g:519:50: (iv_rulePublisher= rulePublisher EOF ) + // InternalRos2Parser.g:520: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" + // InternalRos2Parser.g:526:1: rulePublisher returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos this_BEGIN_9= RULE_BEGIN ( (lv_qos_10_0= ruleQualityOfService ) ) this_END_11= RULE_END )? this_END_12= 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 otherlv_6=null; + Token otherlv_8=null; + Token this_BEGIN_9=null; + Token this_END_11=null; + Token this_END_12=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + EObject lv_qos_10_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:532:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos this_BEGIN_9= RULE_BEGIN ( (lv_qos_10_0= ruleQualityOfService ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) ) + // InternalRos2Parser.g:533:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos this_BEGIN_9= RULE_BEGIN ( (lv_qos_10_0= ruleQualityOfService ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) + { + // InternalRos2Parser.g:533:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos this_BEGIN_9= RULE_BEGIN ( (lv_qos_10_0= ruleQualityOfService ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) + // InternalRos2Parser.g:534:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos this_BEGIN_9= RULE_BEGIN ( (lv_qos_10_0= ruleQualityOfService ) ) this_END_11= RULE_END )? this_END_12= RULE_END + { + // InternalRos2Parser.g:534:3: () + // InternalRos2Parser.g:535:4: + { + + current = forceCreateModelElement( + grammarAccess.getPublisherAccess().getPublisherAction_0(), + current); + + + } + + // InternalRos2Parser.g:541:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos2Parser.g:542:4: (lv_name_1_0= ruleEString ) + { + // InternalRos2Parser.g:542:4: (lv_name_1_0= ruleEString ) + // InternalRos2Parser.g:543: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.ros.Ros.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_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getPublisherAccess().getTypeKeyword_4()); + + // InternalRos2Parser.g:572:3: ( ( ruleEString ) ) + // InternalRos2Parser.g:573:4: ( ruleEString ) + { + // InternalRos2Parser.g:573:4: ( ruleEString ) + // InternalRos2Parser.g:574:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getPublisherRule()); + } + + + newCompositeNode(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + + pushFollow(FOLLOW_21); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:588:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0==Ns) ) { + alt11=1; + } + switch (alt11) { + case 1 : + // InternalRos2Parser.g:589:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_22); + + newLeafNode(otherlv_6, grammarAccess.getPublisherAccess().getNsKeyword_6_0()); + + // InternalRos2Parser.g:593:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos2Parser.g:594:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos2Parser.g:594:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos2Parser.g:595:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getPublisherAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_23); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPublisherRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos2Parser.g:613:3: (otherlv_8= Qos this_BEGIN_9= RULE_BEGIN ( (lv_qos_10_0= ruleQualityOfService ) ) this_END_11= RULE_END )? + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0==Qos) ) { + alt12=1; + } + switch (alt12) { + case 1 : + // InternalRos2Parser.g:614:4: otherlv_8= Qos this_BEGIN_9= RULE_BEGIN ( (lv_qos_10_0= ruleQualityOfService ) ) this_END_11= RULE_END + { + otherlv_8=(Token)match(input,Qos,FOLLOW_4); + + newLeafNode(otherlv_8, grammarAccess.getPublisherAccess().getQosKeyword_7_0()); + + this_BEGIN_9=(Token)match(input,RULE_BEGIN,FOLLOW_24); + + newLeafNode(this_BEGIN_9, grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_7_1()); + + // InternalRos2Parser.g:622:4: ( (lv_qos_10_0= ruleQualityOfService ) ) + // InternalRos2Parser.g:623:5: (lv_qos_10_0= ruleQualityOfService ) + { + // InternalRos2Parser.g:623:5: (lv_qos_10_0= ruleQualityOfService ) + // InternalRos2Parser.g:624:6: lv_qos_10_0= ruleQualityOfService + { + + newCompositeNode(grammarAccess.getPublisherAccess().getQosQualityOfServiceParserRuleCall_7_2_0()); + + pushFollow(FOLLOW_13); + lv_qos_10_0=ruleQualityOfService(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPublisherRule()); + } + set( + current, + "qos", + lv_qos_10_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_11=(Token)match(input,RULE_END,FOLLOW_13); + + newLeafNode(this_END_11, grammarAccess.getPublisherAccess().getENDTerminalRuleCall_7_3()); + + + } + break; + + } + + this_END_12=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_12, grammarAccess.getPublisherAccess().getENDTerminalRuleCall_8()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePublisher" + + + // $ANTLR start "entryRuleSubscriber" + // InternalRos2Parser.g:654:1: entryRuleSubscriber returns [EObject current=null] : iv_ruleSubscriber= ruleSubscriber EOF ; + public final EObject entryRuleSubscriber() throws RecognitionException { + EObject current = null; + + EObject iv_ruleSubscriber = null; + + + try { + // InternalRos2Parser.g:654:51: (iv_ruleSubscriber= ruleSubscriber EOF ) + // InternalRos2Parser.g:655: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" + // InternalRos2Parser.g:661:1: ruleSubscriber returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= 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 otherlv_6=null; + Token otherlv_8=null; + Token this_END_10=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + EObject lv_qos_9_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:667:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) ) + // InternalRos2Parser.g:668:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) + { + // InternalRos2Parser.g:668:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) + // InternalRos2Parser.g:669:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END + { + // InternalRos2Parser.g:669:3: () + // InternalRos2Parser.g:670:4: + { + + current = forceCreateModelElement( + grammarAccess.getSubscriberAccess().getSubscriberAction_0(), + current); + + + } + + // InternalRos2Parser.g:676:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos2Parser.g:677:4: (lv_name_1_0= ruleEString ) + { + // InternalRos2Parser.g:677:4: (lv_name_1_0= ruleEString ) + // InternalRos2Parser.g:678: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.ros.Ros.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_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getSubscriberAccess().getTypeKeyword_4()); + + // InternalRos2Parser.g:707:3: ( ( ruleEString ) ) + // InternalRos2Parser.g:708:4: ( ruleEString ) + { + // InternalRos2Parser.g:708:4: ( ruleEString ) + // InternalRos2Parser.g:709:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getSubscriberRule()); + } + + + newCompositeNode(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + + pushFollow(FOLLOW_21); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:723:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==Ns) ) { + alt13=1; + } + switch (alt13) { + case 1 : + // InternalRos2Parser.g:724:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_22); + + newLeafNode(otherlv_6, grammarAccess.getSubscriberAccess().getNsKeyword_6_0()); + + // InternalRos2Parser.g:728:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos2Parser.g:729:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos2Parser.g:729:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos2Parser.g:730:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getSubscriberAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_23); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getSubscriberRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos2Parser.g:748:3: (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0==Qos) ) { + alt14=1; + } + switch (alt14) { + case 1 : + // InternalRos2Parser.g:749:4: otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) + { + otherlv_8=(Token)match(input,Qos,FOLLOW_24); + + newLeafNode(otherlv_8, grammarAccess.getSubscriberAccess().getQosKeyword_7_0()); + + // InternalRos2Parser.g:753:4: ( (lv_qos_9_0= ruleQualityOfService ) ) + // InternalRos2Parser.g:754:5: (lv_qos_9_0= ruleQualityOfService ) + { + // InternalRos2Parser.g:754:5: (lv_qos_9_0= ruleQualityOfService ) + // InternalRos2Parser.g:755:6: lv_qos_9_0= ruleQualityOfService + { + + newCompositeNode(grammarAccess.getSubscriberAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_13); + lv_qos_9_0=ruleQualityOfService(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getSubscriberRule()); + } + set( + current, + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_10=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_10, grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_8()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleSubscriber" + + + // $ANTLR start "entryRuleServiceServer" + // InternalRos2Parser.g:781:1: entryRuleServiceServer returns [EObject current=null] : iv_ruleServiceServer= ruleServiceServer EOF ; + public final EObject entryRuleServiceServer() throws RecognitionException { + EObject current = null; + + EObject iv_ruleServiceServer = null; + + + try { + // InternalRos2Parser.g:781:54: (iv_ruleServiceServer= ruleServiceServer EOF ) + // InternalRos2Parser.g:782:2: iv_ruleServiceServer= ruleServiceServer EOF + { + newCompositeNode(grammarAccess.getServiceServerRule()); + pushFollow(FOLLOW_1); + iv_ruleServiceServer=ruleServiceServer(); + + state._fsp--; + + current =iv_ruleServiceServer; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleServiceServer" + + + // $ANTLR start "ruleServiceServer" + // InternalRos2Parser.g:788:1: ruleServiceServer returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) ; + public final EObject ruleServiceServer() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token this_END_10=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + EObject lv_qos_9_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:794:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) ) + // InternalRos2Parser.g:795:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) + { + // InternalRos2Parser.g:795:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) + // InternalRos2Parser.g:796:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END + { + // InternalRos2Parser.g:796:3: () + // InternalRos2Parser.g:797:4: + { + + current = forceCreateModelElement( + grammarAccess.getServiceServerAccess().getServiceServerAction_0(), + current); + + + } + + // InternalRos2Parser.g:803:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos2Parser.g:804:4: (lv_name_1_0= ruleEString ) + { + // InternalRos2Parser.g:804:4: (lv_name_1_0= ruleEString ) + // InternalRos2Parser.g:805:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getServiceServerAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceServerRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getServiceServerAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_3, grammarAccess.getServiceServerAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getServiceServerAccess().getTypeKeyword_4()); + + // InternalRos2Parser.g:834:3: ( ( ruleEString ) ) + // InternalRos2Parser.g:835:4: ( ruleEString ) + { + // InternalRos2Parser.g:835:4: ( ruleEString ) + // InternalRos2Parser.g:836:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getServiceServerRule()); + } + + + newCompositeNode(grammarAccess.getServiceServerAccess().getServiceServiceSpecCrossReference_5_0()); + + pushFollow(FOLLOW_21); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:850:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt15=2; + int LA15_0 = input.LA(1); + + if ( (LA15_0==Ns) ) { + alt15=1; + } + switch (alt15) { + case 1 : + // InternalRos2Parser.g:851:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_22); + + newLeafNode(otherlv_6, grammarAccess.getServiceServerAccess().getNsKeyword_6_0()); + + // InternalRos2Parser.g:855:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos2Parser.g:856:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos2Parser.g:856:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos2Parser.g:857:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getServiceServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_23); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceServerRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos2Parser.g:875:3: (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0==Qos) ) { + alt16=1; + } + switch (alt16) { + case 1 : + // InternalRos2Parser.g:876:4: otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) + { + otherlv_8=(Token)match(input,Qos,FOLLOW_24); + + newLeafNode(otherlv_8, grammarAccess.getServiceServerAccess().getQosKeyword_7_0()); + + // InternalRos2Parser.g:880:4: ( (lv_qos_9_0= ruleQualityOfService ) ) + // InternalRos2Parser.g:881:5: (lv_qos_9_0= ruleQualityOfService ) + { + // InternalRos2Parser.g:881:5: (lv_qos_9_0= ruleQualityOfService ) + // InternalRos2Parser.g:882:6: lv_qos_9_0= ruleQualityOfService + { + + newCompositeNode(grammarAccess.getServiceServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_13); + lv_qos_9_0=ruleQualityOfService(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceServerRule()); + } + set( + current, + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_10=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_10, grammarAccess.getServiceServerAccess().getENDTerminalRuleCall_8()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleServiceServer" + + + // $ANTLR start "entryRuleServiceClient" + // InternalRos2Parser.g:908:1: entryRuleServiceClient returns [EObject current=null] : iv_ruleServiceClient= ruleServiceClient EOF ; + public final EObject entryRuleServiceClient() throws RecognitionException { + EObject current = null; + + EObject iv_ruleServiceClient = null; + + + try { + // InternalRos2Parser.g:908:54: (iv_ruleServiceClient= ruleServiceClient EOF ) + // InternalRos2Parser.g:909:2: iv_ruleServiceClient= ruleServiceClient EOF + { + newCompositeNode(grammarAccess.getServiceClientRule()); + pushFollow(FOLLOW_1); + iv_ruleServiceClient=ruleServiceClient(); + + state._fsp--; + + current =iv_ruleServiceClient; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleServiceClient" + + + // $ANTLR start "ruleServiceClient" + // InternalRos2Parser.g:915:1: ruleServiceClient returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) ; + public final EObject ruleServiceClient() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token this_END_10=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + EObject lv_qos_9_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:921:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) ) + // InternalRos2Parser.g:922:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) + { + // InternalRos2Parser.g:922:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) + // InternalRos2Parser.g:923:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END + { + // InternalRos2Parser.g:923:3: () + // InternalRos2Parser.g:924:4: + { + + current = forceCreateModelElement( + grammarAccess.getServiceClientAccess().getServiceClientAction_0(), + current); + + + } + + // InternalRos2Parser.g:930:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos2Parser.g:931:4: (lv_name_1_0= ruleEString ) + { + // InternalRos2Parser.g:931:4: (lv_name_1_0= ruleEString ) + // InternalRos2Parser.g:932:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getServiceClientAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceClientRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getServiceClientAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_3, grammarAccess.getServiceClientAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getServiceClientAccess().getTypeKeyword_4()); + + // InternalRos2Parser.g:961:3: ( ( ruleEString ) ) + // InternalRos2Parser.g:962:4: ( ruleEString ) + { + // InternalRos2Parser.g:962:4: ( ruleEString ) + // InternalRos2Parser.g:963:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getServiceClientRule()); + } + + + newCompositeNode(grammarAccess.getServiceClientAccess().getServiceServiceSpecCrossReference_5_0()); + + pushFollow(FOLLOW_21); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:977:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt17=2; + int LA17_0 = input.LA(1); + + if ( (LA17_0==Ns) ) { + alt17=1; + } + switch (alt17) { + case 1 : + // InternalRos2Parser.g:978:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_22); + + newLeafNode(otherlv_6, grammarAccess.getServiceClientAccess().getNsKeyword_6_0()); + + // InternalRos2Parser.g:982:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos2Parser.g:983:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos2Parser.g:983:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos2Parser.g:984:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getServiceClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_23); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceClientRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos2Parser.g:1002:3: (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0==Qos) ) { + alt18=1; + } + switch (alt18) { + case 1 : + // InternalRos2Parser.g:1003:4: otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) + { + otherlv_8=(Token)match(input,Qos,FOLLOW_24); + + newLeafNode(otherlv_8, grammarAccess.getServiceClientAccess().getQosKeyword_7_0()); + + // InternalRos2Parser.g:1007:4: ( (lv_qos_9_0= ruleQualityOfService ) ) + // InternalRos2Parser.g:1008:5: (lv_qos_9_0= ruleQualityOfService ) + { + // InternalRos2Parser.g:1008:5: (lv_qos_9_0= ruleQualityOfService ) + // InternalRos2Parser.g:1009:6: lv_qos_9_0= ruleQualityOfService + { + + newCompositeNode(grammarAccess.getServiceClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_13); + lv_qos_9_0=ruleQualityOfService(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceClientRule()); + } + set( + current, + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_10=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_10, grammarAccess.getServiceClientAccess().getENDTerminalRuleCall_8()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleServiceClient" + + + // $ANTLR start "entryRuleActionServer" + // InternalRos2Parser.g:1035:1: entryRuleActionServer returns [EObject current=null] : iv_ruleActionServer= ruleActionServer EOF ; + public final EObject entryRuleActionServer() throws RecognitionException { + EObject current = null; + + EObject iv_ruleActionServer = null; + + + try { + // InternalRos2Parser.g:1035:53: (iv_ruleActionServer= ruleActionServer EOF ) + // InternalRos2Parser.g:1036:2: iv_ruleActionServer= ruleActionServer EOF + { + newCompositeNode(grammarAccess.getActionServerRule()); + pushFollow(FOLLOW_1); + iv_ruleActionServer=ruleActionServer(); + + state._fsp--; + + current =iv_ruleActionServer; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleActionServer" + + + // $ANTLR start "ruleActionServer" + // InternalRos2Parser.g:1042:1: ruleActionServer returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) ; + public final EObject ruleActionServer() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token this_END_10=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + EObject lv_qos_9_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:1048:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) ) + // InternalRos2Parser.g:1049:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) + { + // InternalRos2Parser.g:1049:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) + // InternalRos2Parser.g:1050:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END + { + // InternalRos2Parser.g:1050:3: () + // InternalRos2Parser.g:1051:4: + { + + current = forceCreateModelElement( + grammarAccess.getActionServerAccess().getActionServerAction_0(), + current); + + + } + + // InternalRos2Parser.g:1057:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos2Parser.g:1058:4: (lv_name_1_0= ruleEString ) + { + // InternalRos2Parser.g:1058:4: (lv_name_1_0= ruleEString ) + // InternalRos2Parser.g:1059:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getActionServerAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionServerRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getActionServerAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_3, grammarAccess.getActionServerAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getActionServerAccess().getTypeKeyword_4()); + + // InternalRos2Parser.g:1088:3: ( ( ruleEString ) ) + // InternalRos2Parser.g:1089:4: ( ruleEString ) + { + // InternalRos2Parser.g:1089:4: ( ruleEString ) + // InternalRos2Parser.g:1090:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getActionServerRule()); + } + + + newCompositeNode(grammarAccess.getActionServerAccess().getActionActionSpecCrossReference_5_0()); + + pushFollow(FOLLOW_21); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:1104:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt19=2; + int LA19_0 = input.LA(1); + + if ( (LA19_0==Ns) ) { + alt19=1; + } + switch (alt19) { + case 1 : + // InternalRos2Parser.g:1105:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_22); + + newLeafNode(otherlv_6, grammarAccess.getActionServerAccess().getNsKeyword_6_0()); + + // InternalRos2Parser.g:1109:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos2Parser.g:1110:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos2Parser.g:1110:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos2Parser.g:1111:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getActionServerAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_23); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionServerRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos2Parser.g:1129:3: (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0==Qos) ) { + alt20=1; + } + switch (alt20) { + case 1 : + // InternalRos2Parser.g:1130:4: otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) + { + otherlv_8=(Token)match(input,Qos,FOLLOW_24); + + newLeafNode(otherlv_8, grammarAccess.getActionServerAccess().getQosKeyword_7_0()); + + // InternalRos2Parser.g:1134:4: ( (lv_qos_9_0= ruleQualityOfService ) ) + // InternalRos2Parser.g:1135:5: (lv_qos_9_0= ruleQualityOfService ) + { + // InternalRos2Parser.g:1135:5: (lv_qos_9_0= ruleQualityOfService ) + // InternalRos2Parser.g:1136:6: lv_qos_9_0= ruleQualityOfService + { + + newCompositeNode(grammarAccess.getActionServerAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_13); + lv_qos_9_0=ruleQualityOfService(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionServerRule()); + } + set( + current, + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_10=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_10, grammarAccess.getActionServerAccess().getENDTerminalRuleCall_8()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleActionServer" + + + // $ANTLR start "entryRuleActionClient" + // InternalRos2Parser.g:1162:1: entryRuleActionClient returns [EObject current=null] : iv_ruleActionClient= ruleActionClient EOF ; + public final EObject entryRuleActionClient() throws RecognitionException { + EObject current = null; + + EObject iv_ruleActionClient = null; + + + try { + // InternalRos2Parser.g:1162:53: (iv_ruleActionClient= ruleActionClient EOF ) + // InternalRos2Parser.g:1163:2: iv_ruleActionClient= ruleActionClient EOF + { + newCompositeNode(grammarAccess.getActionClientRule()); + pushFollow(FOLLOW_1); + iv_ruleActionClient=ruleActionClient(); + + state._fsp--; + + current =iv_ruleActionClient; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleActionClient" + + + // $ANTLR start "ruleActionClient" + // InternalRos2Parser.g:1169:1: ruleActionClient returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) ; + public final EObject ruleActionClient() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token this_END_10=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_namespace_7_0 = null; + + EObject lv_qos_9_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:1175:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) ) + // InternalRos2Parser.g:1176:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) + { + // InternalRos2Parser.g:1176:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END ) + // InternalRos2Parser.g:1177:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type_1 ( ( ruleEString ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END + { + // InternalRos2Parser.g:1177:3: () + // InternalRos2Parser.g:1178:4: + { + + current = forceCreateModelElement( + grammarAccess.getActionClientAccess().getActionClientAction_0(), + current); + + + } + + // InternalRos2Parser.g:1184:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos2Parser.g:1185:4: (lv_name_1_0= ruleEString ) + { + // InternalRos2Parser.g:1185:4: (lv_name_1_0= ruleEString ) + // InternalRos2Parser.g:1186:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getActionClientAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionClientRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getActionClientAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_3, grammarAccess.getActionClientAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type_1,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getActionClientAccess().getTypeKeyword_4()); + + // InternalRos2Parser.g:1215:3: ( ( ruleEString ) ) + // InternalRos2Parser.g:1216:4: ( ruleEString ) + { + // InternalRos2Parser.g:1216:4: ( ruleEString ) + // InternalRos2Parser.g:1217:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getActionClientRule()); + } + + + newCompositeNode(grammarAccess.getActionClientAccess().getActionActionSpecCrossReference_5_0()); + + pushFollow(FOLLOW_21); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:1231:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt21=2; + int LA21_0 = input.LA(1); + + if ( (LA21_0==Ns) ) { + alt21=1; + } + switch (alt21) { + case 1 : + // InternalRos2Parser.g:1232:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_22); + + newLeafNode(otherlv_6, grammarAccess.getActionClientAccess().getNsKeyword_6_0()); + + // InternalRos2Parser.g:1236:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos2Parser.g:1237:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos2Parser.g:1237:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos2Parser.g:1238:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getActionClientAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_23); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionClientRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos2Parser.g:1256:3: (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? + int alt22=2; + int LA22_0 = input.LA(1); + + if ( (LA22_0==Qos) ) { + alt22=1; + } + switch (alt22) { + case 1 : + // InternalRos2Parser.g:1257:4: otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) + { + otherlv_8=(Token)match(input,Qos,FOLLOW_24); + + newLeafNode(otherlv_8, grammarAccess.getActionClientAccess().getQosKeyword_7_0()); + + // InternalRos2Parser.g:1261:4: ( (lv_qos_9_0= ruleQualityOfService ) ) + // InternalRos2Parser.g:1262:5: (lv_qos_9_0= ruleQualityOfService ) + { + // InternalRos2Parser.g:1262:5: (lv_qos_9_0= ruleQualityOfService ) + // InternalRos2Parser.g:1263:6: lv_qos_9_0= ruleQualityOfService + { + + newCompositeNode(grammarAccess.getActionClientAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_13); + lv_qos_9_0=ruleQualityOfService(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionClientRule()); + } + set( + current, + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_10=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_10, grammarAccess.getActionClientAccess().getENDTerminalRuleCall_8()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleActionClient" + + + // $ANTLR start "entryRuleParameter" + // InternalRos2Parser.g:1289:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ; + public final EObject entryRuleParameter() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameter = null; + + + try { + // InternalRos2Parser.g:1289:50: (iv_ruleParameter= ruleParameter EOF ) + // InternalRos2Parser.g:1290: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" + // InternalRos2Parser.g:1296:1: ruleParameter returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END otherlv_11= RightCurlyBracket ) ; + public final EObject ruleParameter() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token this_END_10=null; + Token otherlv_11=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_type_5_0 = null; + + EObject lv_namespace_7_0 = null; + + EObject lv_qos_9_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:1302:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END otherlv_11= RightCurlyBracket ) ) + // InternalRos2Parser.g:1303:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END otherlv_11= RightCurlyBracket ) + { + // InternalRos2Parser.g:1303:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END otherlv_11= RightCurlyBracket ) + // InternalRos2Parser.g:1304:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( (lv_type_5_0= ruleParameterType ) ) (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? this_END_10= RULE_END otherlv_11= RightCurlyBracket + { + // InternalRos2Parser.g:1304:3: () + // InternalRos2Parser.g:1305:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterAccess().getParameterAction_0(), + current); + + + } + + // InternalRos2Parser.g:1311:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos2Parser.g:1312:4: (lv_name_1_0= ruleEString ) + { + // InternalRos2Parser.g:1312:4: (lv_name_1_0= ruleEString ) + // InternalRos2Parser.g:1313: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.ros.Ros.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_25); + + newLeafNode(this_BEGIN_3, grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type,FOLLOW_26); + + newLeafNode(otherlv_4, grammarAccess.getParameterAccess().getTypeKeyword_4()); + + // InternalRos2Parser.g:1342:3: ( (lv_type_5_0= ruleParameterType ) ) + // InternalRos2Parser.g:1343:4: (lv_type_5_0= ruleParameterType ) + { + // InternalRos2Parser.g:1343:4: (lv_type_5_0= ruleParameterType ) + // InternalRos2Parser.g:1344:5: lv_type_5_0= ruleParameterType + { + + newCompositeNode(grammarAccess.getParameterAccess().getTypeParameterTypeParserRuleCall_5_0()); + + pushFollow(FOLLOW_21); + lv_type_5_0=ruleParameterType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + current, + "type", + lv_type_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:1361:3: (otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) )? + int alt23=2; + int LA23_0 = input.LA(1); + + if ( (LA23_0==Ns) ) { + alt23=1; + } + switch (alt23) { + case 1 : + // InternalRos2Parser.g:1362:4: otherlv_6= Ns ( (lv_namespace_7_0= ruleNamespace ) ) + { + otherlv_6=(Token)match(input,Ns,FOLLOW_22); + + newLeafNode(otherlv_6, grammarAccess.getParameterAccess().getNsKeyword_6_0()); + + // InternalRos2Parser.g:1366:4: ( (lv_namespace_7_0= ruleNamespace ) ) + // InternalRos2Parser.g:1367:5: (lv_namespace_7_0= ruleNamespace ) + { + // InternalRos2Parser.g:1367:5: (lv_namespace_7_0= ruleNamespace ) + // InternalRos2Parser.g:1368:6: lv_namespace_7_0= ruleNamespace + { + + newCompositeNode(grammarAccess.getParameterAccess().getNamespaceNamespaceParserRuleCall_6_1_0()); + + pushFollow(FOLLOW_23); + lv_namespace_7_0=ruleNamespace(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + current, + "namespace", + lv_namespace_7_0, + "de.fraunhofer.ipa.ros.Ros.Namespace"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos2Parser.g:1386:3: (otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) )? + int alt24=2; + int LA24_0 = input.LA(1); + + if ( (LA24_0==Qos) ) { + alt24=1; + } + switch (alt24) { + case 1 : + // InternalRos2Parser.g:1387:4: otherlv_8= Qos ( (lv_qos_9_0= ruleQualityOfService ) ) + { + otherlv_8=(Token)match(input,Qos,FOLLOW_24); + + newLeafNode(otherlv_8, grammarAccess.getParameterAccess().getQosKeyword_7_0()); + + // InternalRos2Parser.g:1391:4: ( (lv_qos_9_0= ruleQualityOfService ) ) + // InternalRos2Parser.g:1392:5: (lv_qos_9_0= ruleQualityOfService ) + { + // InternalRos2Parser.g:1392:5: (lv_qos_9_0= ruleQualityOfService ) + // InternalRos2Parser.g:1393:6: lv_qos_9_0= ruleQualityOfService + { + + newCompositeNode(grammarAccess.getParameterAccess().getQosQualityOfServiceParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_13); + lv_qos_9_0=ruleQualityOfService(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + current, + "qos", + lv_qos_9_0, + "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_10=(Token)match(input,RULE_END,FOLLOW_27); + + newLeafNode(this_END_10, grammarAccess.getParameterAccess().getENDTerminalRuleCall_8()); + + otherlv_11=(Token)match(input,RightCurlyBracket,FOLLOW_2); + + newLeafNode(otherlv_11, grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_9()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameter" + + + // $ANTLR start "entryRuleEString" + // InternalRos2Parser.g:1423:1: entryRuleEString returns [String current=null] : iv_ruleEString= ruleEString EOF ; + public final String entryRuleEString() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleEString = null; + + + try { + // InternalRos2Parser.g:1423:47: (iv_ruleEString= ruleEString EOF ) + // InternalRos2Parser.g:1424: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" + // InternalRos2Parser.g:1430: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 { + // InternalRos2Parser.g:1436:2: ( (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) ) + // InternalRos2Parser.g:1437:2: (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) + { + // InternalRos2Parser.g:1437:2: (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0==RULE_STRING) ) { + alt25=1; + } + else if ( (LA25_0==RULE_ID) ) { + alt25=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); + + throw nvae; + } + switch (alt25) { + case 1 : + // InternalRos2Parser.g:1438: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 : + // InternalRos2Parser.g:1446: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" + + + // $ANTLR start "entryRuleRosNames" + // InternalRos2Parser.g:1457:1: entryRuleRosNames returns [String current=null] : iv_ruleRosNames= ruleRosNames EOF ; + public final String entryRuleRosNames() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleRosNames = null; + + + try { + // InternalRos2Parser.g:1457:48: (iv_ruleRosNames= ruleRosNames EOF ) + // InternalRos2Parser.g:1458: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" + // InternalRos2Parser.g:1464: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 { + // InternalRos2Parser.g:1470:2: ( (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) ) + // InternalRos2Parser.g:1471:2: (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) + { + // InternalRos2Parser.g:1471:2: (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) + int alt26=3; + switch ( input.LA(1) ) { + case RULE_ROS_CONVENTION_A: + { + alt26=1; + } + break; + case RULE_ID: + { + alt26=2; + } + break; + case Node: + { + alt26=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 26, 0, input); + + throw nvae; + } + + switch (alt26) { + case 1 : + // InternalRos2Parser.g:1472: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 : + // InternalRos2Parser.g:1480: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 : + // InternalRos2Parser.g:1488: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 "entryRulePackage_Impl" + // InternalRos2Parser.g:1497:1: entryRulePackage_Impl returns [EObject current=null] : iv_rulePackage_Impl= rulePackage_Impl EOF ; + public final EObject entryRulePackage_Impl() throws RecognitionException { + EObject current = null; + + EObject iv_rulePackage_Impl = null; + + + try { + // InternalRos2Parser.g:1497:53: (iv_rulePackage_Impl= rulePackage_Impl EOF ) + // InternalRos2Parser.g:1498:2: iv_rulePackage_Impl= rulePackage_Impl EOF + { + newCompositeNode(grammarAccess.getPackage_ImplRule()); + pushFollow(FOLLOW_1); + iv_rulePackage_Impl=rulePackage_Impl(); + + state._fsp--; + + current =iv_rulePackage_Impl; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePackage_Impl" + + + // $ANTLR start "rulePackage_Impl" + // InternalRos2Parser.g:1504:1: rulePackage_Impl 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= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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 rulePackage_Impl() 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_spec_8_0 = null; + + EObject lv_dependency_12_0 = null; + + EObject lv_dependency_14_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:1510:2: ( ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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 ) ) + // InternalRos2Parser.g:1511:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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 ) + { + // InternalRos2Parser.g:1511:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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 ) + // InternalRos2Parser.g:1512:3: () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* 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 + { + // InternalRos2Parser.g:1512:3: () + // InternalRos2Parser.g:1513:4: + { + + current = forceCreateModelElement( + grammarAccess.getPackage_ImplAccess().getPackageAction_0(), + current); + + + } + + // InternalRos2Parser.g:1519:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRos2Parser.g:1520:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRos2Parser.g:1520:4: (lv_name_1_0= ruleRosNames ) + // InternalRos2Parser.g:1521:5: lv_name_1_0= ruleRosNames + { + + newCompositeNode(grammarAccess.getPackage_ImplAccess().getNameRosNamesParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleRosNames(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getPackage_ImplAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_28); + + newLeafNode(this_BEGIN_3, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_3()); + + // InternalRos2Parser.g:1546:3: (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? + int alt27=2; + int LA27_0 = input.LA(1); + + if ( (LA27_0==FromGitRepo) ) { + alt27=1; + } + switch (alt27) { + case 1 : + // InternalRos2Parser.g:1547:4: otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) + { + otherlv_4=(Token)match(input,FromGitRepo,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getPackage_ImplAccess().getFromGitRepoKeyword_4_0()); + + // InternalRos2Parser.g:1551:4: ( (lv_fromGitRepo_5_0= ruleEString ) ) + // InternalRos2Parser.g:1552:5: (lv_fromGitRepo_5_0= ruleEString ) + { + // InternalRos2Parser.g:1552:5: (lv_fromGitRepo_5_0= ruleEString ) + // InternalRos2Parser.g:1553:6: lv_fromGitRepo_5_0= ruleEString + { + + newCompositeNode(grammarAccess.getPackage_ImplAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + + pushFollow(FOLLOW_29); + lv_fromGitRepo_5_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + set( + current, + "fromGitRepo", + lv_fromGitRepo_5_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos2Parser.g:1571:3: (otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* this_END_9= RULE_END )? + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0==Specs) ) { + alt29=1; + } + switch (alt29) { + case 1 : + // InternalRos2Parser.g:1572:4: otherlv_6= Specs this_BEGIN_7= RULE_BEGIN ( (lv_spec_8_0= ruleSpecBase ) )* this_END_9= RULE_END + { + otherlv_6=(Token)match(input,Specs,FOLLOW_4); + + newLeafNode(otherlv_6, grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()); + + this_BEGIN_7=(Token)match(input,RULE_BEGIN,FOLLOW_30); + + newLeafNode(this_BEGIN_7, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()); + + // InternalRos2Parser.g:1580:4: ( (lv_spec_8_0= ruleSpecBase ) )* + loop28: + do { + int alt28=2; + int LA28_0 = input.LA(1); + + if ( (LA28_0==Action_1||LA28_0==Msg||LA28_0==Srv) ) { + alt28=1; + } + + + switch (alt28) { + case 1 : + // InternalRos2Parser.g:1581:5: (lv_spec_8_0= ruleSpecBase ) + { + // InternalRos2Parser.g:1581:5: (lv_spec_8_0= ruleSpecBase ) + // InternalRos2Parser.g:1582:6: lv_spec_8_0= ruleSpecBase + { + + newCompositeNode(grammarAccess.getPackage_ImplAccess().getSpecSpecBaseParserRuleCall_5_2_0()); + + pushFollow(FOLLOW_30); + lv_spec_8_0=ruleSpecBase(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + current, + "spec", + lv_spec_8_0, + "de.fraunhofer.ipa.ros.Ros.SpecBase"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop28; + } + } while (true); + + this_END_9=(Token)match(input,RULE_END,FOLLOW_9); + + newLeafNode(this_END_9, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_3()); + + + } + break; + + } + + // InternalRos2Parser.g:1604:3: (otherlv_10= Dependencies otherlv_11= LeftSquareBracket ( (lv_dependency_12_0= ruleDependency ) ) (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* otherlv_15= RightSquareBracket )? + int alt31=2; + int LA31_0 = input.LA(1); + + if ( (LA31_0==Dependencies) ) { + alt31=1; + } + switch (alt31) { + case 1 : + // InternalRos2Parser.g:1605: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.getPackage_ImplAccess().getDependenciesKeyword_6_0()); + + otherlv_11=(Token)match(input,LeftSquareBracket,FOLLOW_11); + + newLeafNode(otherlv_11, grammarAccess.getPackage_ImplAccess().getLeftSquareBracketKeyword_6_1()); + + // InternalRos2Parser.g:1613:4: ( (lv_dependency_12_0= ruleDependency ) ) + // InternalRos2Parser.g:1614:5: (lv_dependency_12_0= ruleDependency ) + { + // InternalRos2Parser.g:1614:5: (lv_dependency_12_0= ruleDependency ) + // InternalRos2Parser.g:1615:6: lv_dependency_12_0= ruleDependency + { + + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_2_0()); + + pushFollow(FOLLOW_12); + lv_dependency_12_0=ruleDependency(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + current, + "dependency", + lv_dependency_12_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:1632:4: (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* + loop30: + do { + int alt30=2; + int LA30_0 = input.LA(1); + + if ( (LA30_0==Comma) ) { + alt30=1; + } + + + switch (alt30) { + case 1 : + // InternalRos2Parser.g:1633:5: otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) + { + otherlv_13=(Token)match(input,Comma,FOLLOW_11); + + newLeafNode(otherlv_13, grammarAccess.getPackage_ImplAccess().getCommaKeyword_6_3_0()); + + // InternalRos2Parser.g:1637:5: ( (lv_dependency_14_0= ruleDependency ) ) + // InternalRos2Parser.g:1638:6: (lv_dependency_14_0= ruleDependency ) + { + // InternalRos2Parser.g:1638:6: (lv_dependency_14_0= ruleDependency ) + // InternalRos2Parser.g:1639:7: lv_dependency_14_0= ruleDependency + { + + newCompositeNode(grammarAccess.getPackage_ImplAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + + pushFollow(FOLLOW_12); + lv_dependency_14_0=ruleDependency(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPackage_ImplRule()); + } + add( + current, + "dependency", + lv_dependency_14_0, + "de.fraunhofer.ipa.ros.Ros.Dependency"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop30; + } + } while (true); + + otherlv_15=(Token)match(input,RightSquareBracket,FOLLOW_13); + + newLeafNode(otherlv_15, grammarAccess.getPackage_ImplAccess().getRightSquareBracketKeyword_6_4()); + + + } + break; + + } + + this_END_16=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_16, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_7()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePackage_Impl" + + + // $ANTLR start "entryRuleArtifact" + // InternalRos2Parser.g:1670:1: entryRuleArtifact returns [EObject current=null] : iv_ruleArtifact= ruleArtifact EOF ; + public final EObject entryRuleArtifact() throws RecognitionException { + EObject current = null; + + EObject iv_ruleArtifact = null; + + + try { + // InternalRos2Parser.g:1670:49: (iv_ruleArtifact= ruleArtifact EOF ) + // InternalRos2Parser.g:1671: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" + // InternalRos2Parser.g:1677: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 { + // InternalRos2Parser.g:1683:2: ( ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END ) ) + // InternalRos2Parser.g:1684:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END ) + { + // InternalRos2Parser.g:1684:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END ) + // InternalRos2Parser.g:1685:3: () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END + { + // InternalRos2Parser.g:1685:3: () + // InternalRos2Parser.g:1686:4: + { + + current = forceCreateModelElement( + grammarAccess.getArtifactAccess().getArtifactAction_0(), + current); + + + } + + // InternalRos2Parser.g:1692:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRos2Parser.g:1693:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRos2Parser.g:1693:4: (lv_name_1_0= ruleRosNames ) + // InternalRos2Parser.g:1694: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.ros.Ros.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_31); + + newLeafNode(this_BEGIN_3, grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); + + // InternalRos2Parser.g:1719:3: ( (lv_node_4_0= ruleNode ) )? + int alt32=2; + int LA32_0 = input.LA(1); + + if ( (LA32_0==Node_1) ) { + alt32=1; + } + switch (alt32) { + case 1 : + // InternalRos2Parser.g:1720:4: (lv_node_4_0= ruleNode ) + { + // InternalRos2Parser.g:1720:4: (lv_node_4_0= ruleNode ) + // InternalRos2Parser.g:1721: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.ros.Ros.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" + // InternalRos2Parser.g:1746:1: entryRuleNode returns [EObject current=null] : iv_ruleNode= ruleNode EOF ; + public final EObject entryRuleNode() throws RecognitionException { + EObject current = null; + + EObject iv_ruleNode = null; + + + try { + // InternalRos2Parser.g:1746:45: (iv_ruleNode= ruleNode EOF ) + // InternalRos2Parser.g:1747: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" + // InternalRos2Parser.g:1753: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= 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 otherlv_15=null; + Token this_BEGIN_16=null; + Token this_END_18=null; + Token otherlv_19=null; + Token this_BEGIN_20=null; + Token this_END_22=null; + Token otherlv_23=null; + Token this_BEGIN_24=null; + Token this_END_26=null; + Token otherlv_27=null; + Token this_BEGIN_28=null; + Token this_END_30=null; + Token this_END_31=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_publisher_5_0 = null; + + EObject lv_subscriber_9_0 = null; + + EObject lv_serviceserver_13_0 = null; + + EObject lv_serviceclient_17_0 = null; + + EObject lv_actionserver_21_0 = null; + + EObject lv_actionclient_25_0 = null; + + EObject lv_parameter_29_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:1759: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END ) ) + // InternalRos2Parser.g:1760: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END ) + { + // InternalRos2Parser.g:1760: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END ) + // InternalRos2Parser.g:1761: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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* this_END_31= RULE_END + { + otherlv_0=(Token)match(input,Node_1,FOLLOW_32); + + newLeafNode(otherlv_0, grammarAccess.getNodeAccess().getNodeKeyword_0()); + + // InternalRos2Parser.g:1765:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRos2Parser.g:1766:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRos2Parser.g:1766:4: (lv_name_1_0= ruleRosNames ) + // InternalRos2Parser.g:1767: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.ros.Ros.RosNames"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_BEGIN_2=(Token)match(input,RULE_BEGIN,FOLLOW_33); + + newLeafNode(this_BEGIN_2, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); + + // InternalRos2Parser.g:1788:3: ( (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= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) | (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) | (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) | (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) | (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) )* + loop40: + do { + int alt40=8; + switch ( input.LA(1) ) { + case Publishers: + { + alt40=1; + } + break; + case Subscribers: + { + alt40=2; + } + break; + case Serviceserver: + { + alt40=3; + } + break; + case Serviceclient: + { + alt40=4; + } + break; + case Actionserver: + { + alt40=5; + } + break; + case Actionclient: + { + alt40=6; + } + break; + case Parameters: + { + alt40=7; + } + break; + + } + + switch (alt40) { + case 1 : + // InternalRos2Parser.g:1789:4: (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END ) + { + // InternalRos2Parser.g:1789:4: (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END ) + // InternalRos2Parser.g:1790:5: 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_0()); + + this_BEGIN_4=(Token)match(input,RULE_BEGIN,FOLLOW_34); + + newLeafNode(this_BEGIN_4, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()); + + // InternalRos2Parser.g:1798:5: ( (lv_publisher_5_0= rulePublisher ) )* + loop33: + do { + int alt33=2; + int LA33_0 = input.LA(1); + + if ( (LA33_0==RULE_ID||LA33_0==RULE_STRING) ) { + alt33=1; + } + + + switch (alt33) { + case 1 : + // InternalRos2Parser.g:1799:6: (lv_publisher_5_0= rulePublisher ) + { + // InternalRos2Parser.g:1799:6: (lv_publisher_5_0= rulePublisher ) + // InternalRos2Parser.g:1800:7: lv_publisher_5_0= rulePublisher + { + + newCompositeNode(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_0_2_0()); + + pushFollow(FOLLOW_34); + lv_publisher_5_0=rulePublisher(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "publisher", + lv_publisher_5_0, + "de.fraunhofer.ipa.ros2.Ros2.Publisher"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop33; + } + } while (true); + + this_END_6=(Token)match(input,RULE_END,FOLLOW_33); + + newLeafNode(this_END_6, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()); + + + } + + + } + break; + case 2 : + // InternalRos2Parser.g:1823:4: (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END ) + { + // InternalRos2Parser.g:1823:4: (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END ) + // InternalRos2Parser.g:1824:5: 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_3_1_0()); + + this_BEGIN_8=(Token)match(input,RULE_BEGIN,FOLLOW_34); + + newLeafNode(this_BEGIN_8, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()); + + // InternalRos2Parser.g:1832:5: ( (lv_subscriber_9_0= ruleSubscriber ) )* + loop34: + do { + int alt34=2; + int LA34_0 = input.LA(1); + + if ( (LA34_0==RULE_ID||LA34_0==RULE_STRING) ) { + alt34=1; + } + + + switch (alt34) { + case 1 : + // InternalRos2Parser.g:1833:6: (lv_subscriber_9_0= ruleSubscriber ) + { + // InternalRos2Parser.g:1833:6: (lv_subscriber_9_0= ruleSubscriber ) + // InternalRos2Parser.g:1834:7: lv_subscriber_9_0= ruleSubscriber + { + + newCompositeNode(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_3_1_2_0()); + + pushFollow(FOLLOW_34); + lv_subscriber_9_0=ruleSubscriber(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "subscriber", + lv_subscriber_9_0, + "de.fraunhofer.ipa.ros2.Ros2.Subscriber"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop34; + } + } while (true); + + this_END_10=(Token)match(input,RULE_END,FOLLOW_33); + + newLeafNode(this_END_10, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()); + + + } + + + } + break; + case 3 : + // InternalRos2Parser.g:1857:4: (otherlv_11= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) + { + // InternalRos2Parser.g:1857:4: (otherlv_11= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END ) + // InternalRos2Parser.g:1858:5: otherlv_11= Serviceserver this_BEGIN_12= RULE_BEGIN ( (lv_serviceserver_13_0= ruleServiceServer ) )* this_END_14= RULE_END + { + otherlv_11=(Token)match(input,Serviceserver,FOLLOW_4); + + newLeafNode(otherlv_11, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()); + + this_BEGIN_12=(Token)match(input,RULE_BEGIN,FOLLOW_34); + + newLeafNode(this_BEGIN_12, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()); + + // InternalRos2Parser.g:1866:5: ( (lv_serviceserver_13_0= ruleServiceServer ) )* + loop35: + do { + int alt35=2; + int LA35_0 = input.LA(1); + + if ( (LA35_0==RULE_ID||LA35_0==RULE_STRING) ) { + alt35=1; + } + + + switch (alt35) { + case 1 : + // InternalRos2Parser.g:1867:6: (lv_serviceserver_13_0= ruleServiceServer ) + { + // InternalRos2Parser.g:1867:6: (lv_serviceserver_13_0= ruleServiceServer ) + // InternalRos2Parser.g:1868:7: lv_serviceserver_13_0= ruleServiceServer + { + + newCompositeNode(grammarAccess.getNodeAccess().getServiceserverServiceServerParserRuleCall_3_2_2_0()); + + pushFollow(FOLLOW_34); + lv_serviceserver_13_0=ruleServiceServer(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "serviceserver", + lv_serviceserver_13_0, + "de.fraunhofer.ipa.ros2.Ros2.ServiceServer"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop35; + } + } while (true); + + this_END_14=(Token)match(input,RULE_END,FOLLOW_33); + + newLeafNode(this_END_14, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()); + + + } + + + } + break; + case 4 : + // InternalRos2Parser.g:1891:4: (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) + { + // InternalRos2Parser.g:1891:4: (otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END ) + // InternalRos2Parser.g:1892:5: otherlv_15= Serviceclient this_BEGIN_16= RULE_BEGIN ( (lv_serviceclient_17_0= ruleServiceClient ) )* this_END_18= RULE_END + { + otherlv_15=(Token)match(input,Serviceclient,FOLLOW_4); + + newLeafNode(otherlv_15, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()); + + this_BEGIN_16=(Token)match(input,RULE_BEGIN,FOLLOW_34); + + newLeafNode(this_BEGIN_16, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()); + + // InternalRos2Parser.g:1900:5: ( (lv_serviceclient_17_0= ruleServiceClient ) )* + loop36: + do { + int alt36=2; + int LA36_0 = input.LA(1); + + if ( (LA36_0==RULE_ID||LA36_0==RULE_STRING) ) { + alt36=1; + } + + + switch (alt36) { + case 1 : + // InternalRos2Parser.g:1901:6: (lv_serviceclient_17_0= ruleServiceClient ) + { + // InternalRos2Parser.g:1901:6: (lv_serviceclient_17_0= ruleServiceClient ) + // InternalRos2Parser.g:1902:7: lv_serviceclient_17_0= ruleServiceClient + { + + newCompositeNode(grammarAccess.getNodeAccess().getServiceclientServiceClientParserRuleCall_3_3_2_0()); + + pushFollow(FOLLOW_34); + lv_serviceclient_17_0=ruleServiceClient(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "serviceclient", + lv_serviceclient_17_0, + "de.fraunhofer.ipa.ros2.Ros2.ServiceClient"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop36; + } + } while (true); + + this_END_18=(Token)match(input,RULE_END,FOLLOW_33); + + newLeafNode(this_END_18, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()); + + + } + + + } + break; + case 5 : + // InternalRos2Parser.g:1925:4: (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) + { + // InternalRos2Parser.g:1925:4: (otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END ) + // InternalRos2Parser.g:1926:5: otherlv_19= Actionserver this_BEGIN_20= RULE_BEGIN ( (lv_actionserver_21_0= ruleActionServer ) )* this_END_22= RULE_END + { + otherlv_19=(Token)match(input,Actionserver,FOLLOW_4); + + newLeafNode(otherlv_19, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()); + + this_BEGIN_20=(Token)match(input,RULE_BEGIN,FOLLOW_34); + + newLeafNode(this_BEGIN_20, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()); + + // InternalRos2Parser.g:1934:5: ( (lv_actionserver_21_0= ruleActionServer ) )* + loop37: + do { + int alt37=2; + int LA37_0 = input.LA(1); + + if ( (LA37_0==RULE_ID||LA37_0==RULE_STRING) ) { + alt37=1; + } + + + switch (alt37) { + case 1 : + // InternalRos2Parser.g:1935:6: (lv_actionserver_21_0= ruleActionServer ) + { + // InternalRos2Parser.g:1935:6: (lv_actionserver_21_0= ruleActionServer ) + // InternalRos2Parser.g:1936:7: lv_actionserver_21_0= ruleActionServer + { + + newCompositeNode(grammarAccess.getNodeAccess().getActionserverActionServerParserRuleCall_3_4_2_0()); + + pushFollow(FOLLOW_34); + lv_actionserver_21_0=ruleActionServer(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "actionserver", + lv_actionserver_21_0, + "de.fraunhofer.ipa.ros2.Ros2.ActionServer"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop37; + } + } while (true); + + this_END_22=(Token)match(input,RULE_END,FOLLOW_33); + + newLeafNode(this_END_22, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()); + + + } + + + } + break; + case 6 : + // InternalRos2Parser.g:1959:4: (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) + { + // InternalRos2Parser.g:1959:4: (otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END ) + // InternalRos2Parser.g:1960:5: otherlv_23= Actionclient this_BEGIN_24= RULE_BEGIN ( (lv_actionclient_25_0= ruleActionClient ) )* this_END_26= RULE_END + { + otherlv_23=(Token)match(input,Actionclient,FOLLOW_4); + + newLeafNode(otherlv_23, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()); + + this_BEGIN_24=(Token)match(input,RULE_BEGIN,FOLLOW_34); + + newLeafNode(this_BEGIN_24, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()); + + // InternalRos2Parser.g:1968:5: ( (lv_actionclient_25_0= ruleActionClient ) )* + loop38: + do { + int alt38=2; + int LA38_0 = input.LA(1); + + if ( (LA38_0==RULE_ID||LA38_0==RULE_STRING) ) { + alt38=1; + } + + + switch (alt38) { + case 1 : + // InternalRos2Parser.g:1969:6: (lv_actionclient_25_0= ruleActionClient ) + { + // InternalRos2Parser.g:1969:6: (lv_actionclient_25_0= ruleActionClient ) + // InternalRos2Parser.g:1970:7: lv_actionclient_25_0= ruleActionClient + { + + newCompositeNode(grammarAccess.getNodeAccess().getActionclientActionClientParserRuleCall_3_5_2_0()); + + pushFollow(FOLLOW_34); + lv_actionclient_25_0=ruleActionClient(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "actionclient", + lv_actionclient_25_0, + "de.fraunhofer.ipa.ros2.Ros2.ActionClient"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop38; + } + } while (true); + + this_END_26=(Token)match(input,RULE_END,FOLLOW_33); + + newLeafNode(this_END_26, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()); + + + } + + + } + break; + case 7 : + // InternalRos2Parser.g:1993:4: (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) + { + // InternalRos2Parser.g:1993:4: (otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END ) + // InternalRos2Parser.g:1994:5: otherlv_27= Parameters this_BEGIN_28= RULE_BEGIN ( (lv_parameter_29_0= ruleParameter ) )* this_END_30= RULE_END + { + otherlv_27=(Token)match(input,Parameters,FOLLOW_4); + + newLeafNode(otherlv_27, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()); + + this_BEGIN_28=(Token)match(input,RULE_BEGIN,FOLLOW_34); + + newLeafNode(this_BEGIN_28, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()); + + // InternalRos2Parser.g:2002:5: ( (lv_parameter_29_0= ruleParameter ) )* + loop39: + do { + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0==RULE_ID||LA39_0==RULE_STRING) ) { + alt39=1; + } + + + switch (alt39) { + case 1 : + // InternalRos2Parser.g:2003:6: (lv_parameter_29_0= ruleParameter ) + { + // InternalRos2Parser.g:2003:6: (lv_parameter_29_0= ruleParameter ) + // InternalRos2Parser.g:2004:7: lv_parameter_29_0= ruleParameter + { + + newCompositeNode(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_3_6_2_0()); + + pushFollow(FOLLOW_34); + lv_parameter_29_0=ruleParameter(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "parameter", + lv_parameter_29_0, + "de.fraunhofer.ipa.ros2.Ros2.Parameter"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop39; + } + } while (true); + + this_END_30=(Token)match(input,RULE_END,FOLLOW_33); + + newLeafNode(this_END_30, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()); + + + } + + + } + break; + + default : + break loop40; + } + } while (true); + + this_END_31=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_31, grammarAccess.getNodeAccess().getENDTerminalRuleCall_4()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleNode" + + + // $ANTLR start "entryRuleSpecBase" + // InternalRos2Parser.g:2035:1: entryRuleSpecBase returns [EObject current=null] : iv_ruleSpecBase= ruleSpecBase EOF ; + public final EObject entryRuleSpecBase() throws RecognitionException { + EObject current = null; + + EObject iv_ruleSpecBase = null; + + + try { + // InternalRos2Parser.g:2035:49: (iv_ruleSpecBase= ruleSpecBase EOF ) + // InternalRos2Parser.g:2036:2: iv_ruleSpecBase= ruleSpecBase EOF + { + newCompositeNode(grammarAccess.getSpecBaseRule()); + pushFollow(FOLLOW_1); + iv_ruleSpecBase=ruleSpecBase(); + + state._fsp--; + + current =iv_ruleSpecBase; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleSpecBase" + + + // $ANTLR start "ruleSpecBase" + // InternalRos2Parser.g:2042:1: ruleSpecBase returns [EObject current=null] : (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) ; + public final EObject ruleSpecBase() throws RecognitionException { + EObject current = null; + + EObject this_TopicSpec_0 = null; + + EObject this_ServiceSpec_1 = null; + + EObject this_ActionSpec_2 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:2048:2: ( (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) ) + // InternalRos2Parser.g:2049:2: (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) + { + // InternalRos2Parser.g:2049:2: (this_TopicSpec_0= ruleTopicSpec | this_ServiceSpec_1= ruleServiceSpec | this_ActionSpec_2= ruleActionSpec ) + int alt41=3; + switch ( input.LA(1) ) { + case Msg: + { + alt41=1; + } + break; + case Srv: + { + alt41=2; + } + break; + case Action_1: + { + alt41=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 41, 0, input); + + throw nvae; + } + + switch (alt41) { + case 1 : + // InternalRos2Parser.g:2050:3: this_TopicSpec_0= ruleTopicSpec + { + + newCompositeNode(grammarAccess.getSpecBaseAccess().getTopicSpecParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_TopicSpec_0=ruleTopicSpec(); + + state._fsp--; + + + current = this_TopicSpec_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos2Parser.g:2059:3: this_ServiceSpec_1= ruleServiceSpec + { + + newCompositeNode(grammarAccess.getSpecBaseAccess().getServiceSpecParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_ServiceSpec_1=ruleServiceSpec(); + + state._fsp--; + + + current = this_ServiceSpec_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalRos2Parser.g:2068:3: this_ActionSpec_2= ruleActionSpec + { + + newCompositeNode(grammarAccess.getSpecBaseAccess().getActionSpecParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_ActionSpec_2=ruleActionSpec(); + + state._fsp--; + + + current = this_ActionSpec_2; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleSpecBase" + + + // $ANTLR start "entryRuleTopicSpec" + // InternalRos2Parser.g:2080:1: entryRuleTopicSpec returns [EObject current=null] : iv_ruleTopicSpec= ruleTopicSpec EOF ; + public final EObject entryRuleTopicSpec() throws RecognitionException { + EObject current = null; + + EObject iv_ruleTopicSpec = null; + + + try { + // InternalRos2Parser.g:2080:50: (iv_ruleTopicSpec= ruleTopicSpec EOF ) + // InternalRos2Parser.g:2081:2: iv_ruleTopicSpec= ruleTopicSpec EOF + { + newCompositeNode(grammarAccess.getTopicSpecRule()); + pushFollow(FOLLOW_1); + iv_ruleTopicSpec=ruleTopicSpec(); + + state._fsp--; + + current =iv_ruleTopicSpec; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleTopicSpec" + + + // $ANTLR start "ruleTopicSpec" + // InternalRos2Parser.g:2087:1: ruleTopicSpec returns [EObject current=null] : ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) ; + public final EObject ruleTopicSpec() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token lv_name_2_2=null; + Token lv_name_2_3=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token this_BEGIN_5=null; + Token this_END_7=null; + Token this_END_8=null; + AntlrDatatypeRuleToken lv_name_2_1 = null; + + EObject lv_message_6_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:2093:2: ( ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) ) + // InternalRos2Parser.g:2094:2: ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) + { + // InternalRos2Parser.g:2094:2: ( () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END ) + // InternalRos2Parser.g:2095:3: () otherlv_1= Msg ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Message_1 (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? this_END_8= RULE_END + { + // InternalRos2Parser.g:2095:3: () + // InternalRos2Parser.g:2096:4: + { + + current = forceCreateModelElement( + grammarAccess.getTopicSpecAccess().getTopicSpecAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Msg,FOLLOW_35); + + newLeafNode(otherlv_1, grammarAccess.getTopicSpecAccess().getMsgKeyword_1()); + + // InternalRos2Parser.g:2106:3: ( ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) ) + // InternalRos2Parser.g:2107:4: ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) + { + // InternalRos2Parser.g:2107:4: ( (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) ) + // InternalRos2Parser.g:2108:5: (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) + { + // InternalRos2Parser.g:2108:5: (lv_name_2_1= ruleEString | lv_name_2_2= Header | lv_name_2_3= String ) + int alt42=3; + switch ( input.LA(1) ) { + case RULE_ID: + case RULE_STRING: + { + alt42=1; + } + break; + case Header: + { + alt42=2; + } + break; + case String: + { + alt42=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 42, 0, input); + + throw nvae; + } + + switch (alt42) { + case 1 : + // InternalRos2Parser.g:2109:6: lv_name_2_1= ruleEString + { + + newCompositeNode(grammarAccess.getTopicSpecAccess().getNameEStringParserRuleCall_2_0_0()); + + pushFollow(FOLLOW_4); + lv_name_2_1=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getTopicSpecRule()); + } + set( + current, + "name", + lv_name_2_1, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos2Parser.g:2125:6: lv_name_2_2= Header + { + lv_name_2_2=(Token)match(input,Header,FOLLOW_4); + + newLeafNode(lv_name_2_2, grammarAccess.getTopicSpecAccess().getNameHeaderKeyword_2_0_1()); + + + if (current==null) { + current = createModelElement(grammarAccess.getTopicSpecRule()); + } + setWithLastConsumed(current, "name", lv_name_2_2, null); + + + } + break; + case 3 : + // InternalRos2Parser.g:2136:6: lv_name_2_3= String + { + lv_name_2_3=(Token)match(input,String,FOLLOW_4); + + newLeafNode(lv_name_2_3, grammarAccess.getTopicSpecAccess().getNameStringKeyword_2_0_2()); + + + if (current==null) { + current = createModelElement(grammarAccess.getTopicSpecRule()); + } + setWithLastConsumed(current, "name", lv_name_2_3, null); + + + } + break; + + } + + + } + + + } + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_36); + + newLeafNode(this_BEGIN_3, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Message_1,FOLLOW_37); + + newLeafNode(otherlv_4, grammarAccess.getTopicSpecAccess().getMessageKeyword_4()); + + // InternalRos2Parser.g:2157:3: (this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? + int alt43=2; + int LA43_0 = input.LA(1); + + if ( (LA43_0==RULE_BEGIN) ) { + alt43=1; + } + switch (alt43) { + case 1 : + // InternalRos2Parser.g:2158:4: this_BEGIN_5= RULE_BEGIN ( (lv_message_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END + { + this_BEGIN_5=(Token)match(input,RULE_BEGIN,FOLLOW_38); + + newLeafNode(this_BEGIN_5, grammarAccess.getTopicSpecAccess().getBEGINTerminalRuleCall_5_0()); + + // InternalRos2Parser.g:2162:4: ( (lv_message_6_0= ruleMessageDefinition ) ) + // InternalRos2Parser.g:2163:5: (lv_message_6_0= ruleMessageDefinition ) + { + // InternalRos2Parser.g:2163:5: (lv_message_6_0= ruleMessageDefinition ) + // InternalRos2Parser.g:2164:6: lv_message_6_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getTopicSpecAccess().getMessageMessageDefinitionParserRuleCall_5_1_0()); + + pushFollow(FOLLOW_13); + lv_message_6_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getTopicSpecRule()); + } + set( + current, + "message", + lv_message_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_7=(Token)match(input,RULE_END,FOLLOW_13); + + newLeafNode(this_END_7, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_5_2()); + + + } + break; + + } + + this_END_8=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_8, grammarAccess.getTopicSpecAccess().getENDTerminalRuleCall_6()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleTopicSpec" + + + // $ANTLR start "entryRuleServiceSpec" + // InternalRos2Parser.g:2194:1: entryRuleServiceSpec returns [EObject current=null] : iv_ruleServiceSpec= ruleServiceSpec EOF ; + public final EObject entryRuleServiceSpec() throws RecognitionException { + EObject current = null; + + EObject iv_ruleServiceSpec = null; + + + try { + // InternalRos2Parser.g:2194:52: (iv_ruleServiceSpec= ruleServiceSpec EOF ) + // InternalRos2Parser.g:2195:2: iv_ruleServiceSpec= ruleServiceSpec EOF + { + newCompositeNode(grammarAccess.getServiceSpecRule()); + pushFollow(FOLLOW_1); + iv_ruleServiceSpec=ruleServiceSpec(); + + state._fsp--; + + current =iv_ruleServiceSpec; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleServiceSpec" + + + // $ANTLR start "ruleServiceSpec" + // InternalRos2Parser.g:2201:1: ruleServiceSpec returns [EObject current=null] : ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) ; + public final EObject ruleServiceSpec() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token this_BEGIN_5=null; + Token this_END_7=null; + Token otherlv_8=null; + Token this_BEGIN_9=null; + Token this_END_11=null; + Token this_END_12=null; + AntlrDatatypeRuleToken lv_name_2_0 = null; + + EObject lv_request_6_0 = null; + + EObject lv_response_10_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:2207:2: ( ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) ) + // InternalRos2Parser.g:2208:2: ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) + { + // InternalRos2Parser.g:2208:2: ( () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END ) + // InternalRos2Parser.g:2209:3: () otherlv_1= Srv ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Request (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Response (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? this_END_12= RULE_END + { + // InternalRos2Parser.g:2209:3: () + // InternalRos2Parser.g:2210:4: + { + + current = forceCreateModelElement( + grammarAccess.getServiceSpecAccess().getServiceSpecAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Srv,FOLLOW_6); + + newLeafNode(otherlv_1, grammarAccess.getServiceSpecAccess().getSrvKeyword_1()); + + // InternalRos2Parser.g:2220:3: ( (lv_name_2_0= ruleEString ) ) + // InternalRos2Parser.g:2221:4: (lv_name_2_0= ruleEString ) + { + // InternalRos2Parser.g:2221:4: (lv_name_2_0= ruleEString ) + // InternalRos2Parser.g:2222:5: lv_name_2_0= ruleEString + { + + newCompositeNode(grammarAccess.getServiceSpecAccess().getNameEStringParserRuleCall_2_0()); + + pushFollow(FOLLOW_4); + lv_name_2_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + current, + "name", + lv_name_2_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_39); + + newLeafNode(this_BEGIN_3, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Request,FOLLOW_40); + + newLeafNode(otherlv_4, grammarAccess.getServiceSpecAccess().getRequestKeyword_4()); + + // InternalRos2Parser.g:2247:3: (this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? + int alt44=2; + int LA44_0 = input.LA(1); + + if ( (LA44_0==RULE_BEGIN) ) { + alt44=1; + } + switch (alt44) { + case 1 : + // InternalRos2Parser.g:2248:4: this_BEGIN_5= RULE_BEGIN ( (lv_request_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END + { + this_BEGIN_5=(Token)match(input,RULE_BEGIN,FOLLOW_38); + + newLeafNode(this_BEGIN_5, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_5_0()); + + // InternalRos2Parser.g:2252:4: ( (lv_request_6_0= ruleMessageDefinition ) ) + // InternalRos2Parser.g:2253:5: (lv_request_6_0= ruleMessageDefinition ) + { + // InternalRos2Parser.g:2253:5: (lv_request_6_0= ruleMessageDefinition ) + // InternalRos2Parser.g:2254:6: lv_request_6_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getServiceSpecAccess().getRequestMessageDefinitionParserRuleCall_5_1_0()); + + pushFollow(FOLLOW_13); + lv_request_6_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + current, + "request", + lv_request_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_7=(Token)match(input,RULE_END,FOLLOW_41); + + newLeafNode(this_END_7, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_5_2()); + + + } + break; + + } + + otherlv_8=(Token)match(input,Response,FOLLOW_37); + + newLeafNode(otherlv_8, grammarAccess.getServiceSpecAccess().getResponseKeyword_6()); + + // InternalRos2Parser.g:2280:3: (this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? + int alt45=2; + int LA45_0 = input.LA(1); + + if ( (LA45_0==RULE_BEGIN) ) { + alt45=1; + } + switch (alt45) { + case 1 : + // InternalRos2Parser.g:2281:4: this_BEGIN_9= RULE_BEGIN ( (lv_response_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END + { + this_BEGIN_9=(Token)match(input,RULE_BEGIN,FOLLOW_38); + + newLeafNode(this_BEGIN_9, grammarAccess.getServiceSpecAccess().getBEGINTerminalRuleCall_7_0()); + + // InternalRos2Parser.g:2285:4: ( (lv_response_10_0= ruleMessageDefinition ) ) + // InternalRos2Parser.g:2286:5: (lv_response_10_0= ruleMessageDefinition ) + { + // InternalRos2Parser.g:2286:5: (lv_response_10_0= ruleMessageDefinition ) + // InternalRos2Parser.g:2287:6: lv_response_10_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getServiceSpecAccess().getResponseMessageDefinitionParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_13); + lv_response_10_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getServiceSpecRule()); + } + set( + current, + "response", + lv_response_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_11=(Token)match(input,RULE_END,FOLLOW_13); + + newLeafNode(this_END_11, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_7_2()); + + + } + break; + + } + + this_END_12=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_12, grammarAccess.getServiceSpecAccess().getENDTerminalRuleCall_8()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleServiceSpec" + + + // $ANTLR start "entryRuleActionSpec" + // InternalRos2Parser.g:2317:1: entryRuleActionSpec returns [EObject current=null] : iv_ruleActionSpec= ruleActionSpec EOF ; + public final EObject entryRuleActionSpec() throws RecognitionException { + EObject current = null; + + EObject iv_ruleActionSpec = null; + + + try { + // InternalRos2Parser.g:2317:51: (iv_ruleActionSpec= ruleActionSpec EOF ) + // InternalRos2Parser.g:2318:2: iv_ruleActionSpec= ruleActionSpec EOF + { + newCompositeNode(grammarAccess.getActionSpecRule()); + pushFollow(FOLLOW_1); + iv_ruleActionSpec=ruleActionSpec(); + + state._fsp--; + + current =iv_ruleActionSpec; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleActionSpec" + + + // $ANTLR start "ruleActionSpec" + // InternalRos2Parser.g:2324:1: ruleActionSpec returns [EObject current=null] : ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) ; + public final EObject ruleActionSpec() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token this_BEGIN_5=null; + Token this_END_7=null; + Token otherlv_8=null; + Token this_BEGIN_9=null; + Token this_END_11=null; + Token otherlv_12=null; + Token this_BEGIN_13=null; + Token this_END_15=null; + Token this_END_16=null; + AntlrDatatypeRuleToken lv_name_2_0 = null; + + EObject lv_goal_6_0 = null; + + EObject lv_result_10_0 = null; + + EObject lv_feedback_14_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:2330:2: ( ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) ) + // InternalRos2Parser.g:2331:2: ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) + { + // InternalRos2Parser.g:2331:2: ( () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END ) + // InternalRos2Parser.g:2332:3: () otherlv_1= Action_1 ( (lv_name_2_0= ruleEString ) ) this_BEGIN_3= RULE_BEGIN otherlv_4= Goal_1 (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? otherlv_8= Result_1 (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? otherlv_12= Feedback_1 (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? this_END_16= RULE_END + { + // InternalRos2Parser.g:2332:3: () + // InternalRos2Parser.g:2333:4: + { + + current = forceCreateModelElement( + grammarAccess.getActionSpecAccess().getActionSpecAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Action_1,FOLLOW_6); + + newLeafNode(otherlv_1, grammarAccess.getActionSpecAccess().getActionKeyword_1()); + + // InternalRos2Parser.g:2343:3: ( (lv_name_2_0= ruleEString ) ) + // InternalRos2Parser.g:2344:4: (lv_name_2_0= ruleEString ) + { + // InternalRos2Parser.g:2344:4: (lv_name_2_0= ruleEString ) + // InternalRos2Parser.g:2345:5: lv_name_2_0= ruleEString + { + + newCompositeNode(grammarAccess.getActionSpecAccess().getNameEStringParserRuleCall_2_0()); + + pushFollow(FOLLOW_4); + lv_name_2_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + current, + "name", + lv_name_2_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_42); + + newLeafNode(this_BEGIN_3, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Goal_1,FOLLOW_43); + + newLeafNode(otherlv_4, grammarAccess.getActionSpecAccess().getGoalKeyword_4()); + + // InternalRos2Parser.g:2370:3: (this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END )? + int alt46=2; + int LA46_0 = input.LA(1); + + if ( (LA46_0==RULE_BEGIN) ) { + alt46=1; + } + switch (alt46) { + case 1 : + // InternalRos2Parser.g:2371:4: this_BEGIN_5= RULE_BEGIN ( (lv_goal_6_0= ruleMessageDefinition ) ) this_END_7= RULE_END + { + this_BEGIN_5=(Token)match(input,RULE_BEGIN,FOLLOW_38); + + newLeafNode(this_BEGIN_5, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_5_0()); + + // InternalRos2Parser.g:2375:4: ( (lv_goal_6_0= ruleMessageDefinition ) ) + // InternalRos2Parser.g:2376:5: (lv_goal_6_0= ruleMessageDefinition ) + { + // InternalRos2Parser.g:2376:5: (lv_goal_6_0= ruleMessageDefinition ) + // InternalRos2Parser.g:2377:6: lv_goal_6_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getActionSpecAccess().getGoalMessageDefinitionParserRuleCall_5_1_0()); + + pushFollow(FOLLOW_13); + lv_goal_6_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + current, + "goal", + lv_goal_6_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_7=(Token)match(input,RULE_END,FOLLOW_44); + + newLeafNode(this_END_7, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_5_2()); + + + } + break; + + } + + otherlv_8=(Token)match(input,Result_1,FOLLOW_45); + + newLeafNode(otherlv_8, grammarAccess.getActionSpecAccess().getResultKeyword_6()); + + // InternalRos2Parser.g:2403:3: (this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END )? + int alt47=2; + int LA47_0 = input.LA(1); + + if ( (LA47_0==RULE_BEGIN) ) { + alt47=1; + } + switch (alt47) { + case 1 : + // InternalRos2Parser.g:2404:4: this_BEGIN_9= RULE_BEGIN ( (lv_result_10_0= ruleMessageDefinition ) ) this_END_11= RULE_END + { + this_BEGIN_9=(Token)match(input,RULE_BEGIN,FOLLOW_38); + + newLeafNode(this_BEGIN_9, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_7_0()); + + // InternalRos2Parser.g:2408:4: ( (lv_result_10_0= ruleMessageDefinition ) ) + // InternalRos2Parser.g:2409:5: (lv_result_10_0= ruleMessageDefinition ) + { + // InternalRos2Parser.g:2409:5: (lv_result_10_0= ruleMessageDefinition ) + // InternalRos2Parser.g:2410:6: lv_result_10_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getActionSpecAccess().getResultMessageDefinitionParserRuleCall_7_1_0()); + + pushFollow(FOLLOW_13); + lv_result_10_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + current, + "result", + lv_result_10_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_11=(Token)match(input,RULE_END,FOLLOW_46); + + newLeafNode(this_END_11, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_7_2()); + + + } + break; + + } + + otherlv_12=(Token)match(input,Feedback_1,FOLLOW_37); + + newLeafNode(otherlv_12, grammarAccess.getActionSpecAccess().getFeedbackKeyword_8()); + + // InternalRos2Parser.g:2436:3: (this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END )? + int alt48=2; + int LA48_0 = input.LA(1); + + if ( (LA48_0==RULE_BEGIN) ) { + alt48=1; + } + switch (alt48) { + case 1 : + // InternalRos2Parser.g:2437:4: this_BEGIN_13= RULE_BEGIN ( (lv_feedback_14_0= ruleMessageDefinition ) ) this_END_15= RULE_END + { + this_BEGIN_13=(Token)match(input,RULE_BEGIN,FOLLOW_38); + + newLeafNode(this_BEGIN_13, grammarAccess.getActionSpecAccess().getBEGINTerminalRuleCall_9_0()); + + // InternalRos2Parser.g:2441:4: ( (lv_feedback_14_0= ruleMessageDefinition ) ) + // InternalRos2Parser.g:2442:5: (lv_feedback_14_0= ruleMessageDefinition ) + { + // InternalRos2Parser.g:2442:5: (lv_feedback_14_0= ruleMessageDefinition ) + // InternalRos2Parser.g:2443:6: lv_feedback_14_0= ruleMessageDefinition + { + + newCompositeNode(grammarAccess.getActionSpecAccess().getFeedbackMessageDefinitionParserRuleCall_9_1_0()); + + pushFollow(FOLLOW_13); + lv_feedback_14_0=ruleMessageDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getActionSpecRule()); + } + set( + current, + "feedback", + lv_feedback_14_0, + "de.fraunhofer.ipa.ros.Ros.MessageDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_15=(Token)match(input,RULE_END,FOLLOW_13); + + newLeafNode(this_END_15, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_9_2()); + + + } + break; + + } + + this_END_16=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_16, grammarAccess.getActionSpecAccess().getENDTerminalRuleCall_10()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleActionSpec" + + + // $ANTLR start "entryRuleMessageDefinition" + // InternalRos2Parser.g:2473:1: entryRuleMessageDefinition returns [EObject current=null] : iv_ruleMessageDefinition= ruleMessageDefinition EOF ; + public final EObject entryRuleMessageDefinition() throws RecognitionException { + EObject current = null; + + EObject iv_ruleMessageDefinition = null; + + + try { + // InternalRos2Parser.g:2473:58: (iv_ruleMessageDefinition= ruleMessageDefinition EOF ) + // InternalRos2Parser.g:2474:2: iv_ruleMessageDefinition= ruleMessageDefinition EOF + { + newCompositeNode(grammarAccess.getMessageDefinitionRule()); + pushFollow(FOLLOW_1); + iv_ruleMessageDefinition=ruleMessageDefinition(); + + state._fsp--; + + current =iv_ruleMessageDefinition; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleMessageDefinition" + + + // $ANTLR start "ruleMessageDefinition" + // InternalRos2Parser.g:2480:1: ruleMessageDefinition returns [EObject current=null] : ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) ; + public final EObject ruleMessageDefinition() throws RecognitionException { + EObject current = null; + + EObject lv_MessagePart_1_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:2486:2: ( ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) ) + // InternalRos2Parser.g:2487:2: ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) + { + // InternalRos2Parser.g:2487:2: ( () ( (lv_MessagePart_1_0= ruleMessagePart ) )* ) + // InternalRos2Parser.g:2488:3: () ( (lv_MessagePart_1_0= ruleMessagePart ) )* + { + // InternalRos2Parser.g:2488:3: () + // InternalRos2Parser.g:2489:4: + { + + current = forceCreateModelElement( + grammarAccess.getMessageDefinitionAccess().getMessageDefinitionAction_0(), + current); + + + } + + // InternalRos2Parser.g:2495:3: ( (lv_MessagePart_1_0= ruleMessagePart ) )* + loop49: + do { + int alt49=2; + int LA49_0 = input.LA(1); + + if ( ((LA49_0>=Float32_1 && LA49_0<=Float64_1)||LA49_0==Duration||(LA49_0>=String_2 && LA49_0<=Uint64_1)||(LA49_0>=Float32 && LA49_0<=Int64_1)||LA49_0==Uint8_1||LA49_0==Header||(LA49_0>=Bool_1 && LA49_0<=Byte_1)||LA49_0==Int8_1||(LA49_0>=String_1 && LA49_0<=Uint64)||(LA49_0>=Int16 && LA49_0<=Int64)||LA49_0==Uint8||(LA49_0>=Bool && LA49_0<=Byte)||LA49_0==Int8||LA49_0==Time||LA49_0==RULE_ID||LA49_0==RULE_STRING) ) { + alt49=1; + } + + + switch (alt49) { + case 1 : + // InternalRos2Parser.g:2496:4: (lv_MessagePart_1_0= ruleMessagePart ) + { + // InternalRos2Parser.g:2496:4: (lv_MessagePart_1_0= ruleMessagePart ) + // InternalRos2Parser.g:2497:5: lv_MessagePart_1_0= ruleMessagePart + { + + newCompositeNode(grammarAccess.getMessageDefinitionAccess().getMessagePartMessagePartParserRuleCall_1_0()); + + pushFollow(FOLLOW_47); + lv_MessagePart_1_0=ruleMessagePart(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getMessageDefinitionRule()); + } + add( + current, + "MessagePart", + lv_MessagePart_1_0, + "de.fraunhofer.ipa.ros.Ros.MessagePart"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop49; + } + } while (true); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMessageDefinition" + + + // $ANTLR start "entryRuleDependency" + // InternalRos2Parser.g:2518:1: entryRuleDependency returns [EObject current=null] : iv_ruleDependency= ruleDependency EOF ; + public final EObject entryRuleDependency() throws RecognitionException { + EObject current = null; + + EObject iv_ruleDependency = null; + + + try { + // InternalRos2Parser.g:2518:51: (iv_ruleDependency= ruleDependency EOF ) + // InternalRos2Parser.g:2519: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" + // InternalRos2Parser.g:2525: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 { + // InternalRos2Parser.g:2531:2: ( (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) ) + // InternalRos2Parser.g:2532:2: (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) + { + // InternalRos2Parser.g:2532:2: (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) + int alt50=2; + int LA50_0 = input.LA(1); + + if ( (LA50_0==RULE_ID||LA50_0==RULE_STRING) ) { + alt50=1; + } + else if ( (LA50_0==ExternalDependency) ) { + alt50=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 50, 0, input); + + throw nvae; + } + switch (alt50) { + case 1 : + // InternalRos2Parser.g:2533: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 : + // InternalRos2Parser.g:2542: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" + // InternalRos2Parser.g:2554:1: entryRulePackageDependency returns [EObject current=null] : iv_rulePackageDependency= rulePackageDependency EOF ; + public final EObject entryRulePackageDependency() throws RecognitionException { + EObject current = null; + + EObject iv_rulePackageDependency = null; + + + try { + // InternalRos2Parser.g:2554:58: (iv_rulePackageDependency= rulePackageDependency EOF ) + // InternalRos2Parser.g:2555: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" + // InternalRos2Parser.g:2561:1: rulePackageDependency returns [EObject current=null] : ( ( ruleEString ) ) ; + public final EObject rulePackageDependency() throws RecognitionException { + EObject current = null; + + + enterRule(); + + try { + // InternalRos2Parser.g:2567:2: ( ( ( ruleEString ) ) ) + // InternalRos2Parser.g:2568:2: ( ( ruleEString ) ) + { + // InternalRos2Parser.g:2568:2: ( ( ruleEString ) ) + // InternalRos2Parser.g:2569:3: ( ruleEString ) + { + // InternalRos2Parser.g:2569:3: ( ruleEString ) + // InternalRos2Parser.g:2570: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" + // InternalRos2Parser.g:2587:1: entryRuleExternalDependency returns [EObject current=null] : iv_ruleExternalDependency= ruleExternalDependency EOF ; + public final EObject entryRuleExternalDependency() throws RecognitionException { + EObject current = null; + + EObject iv_ruleExternalDependency = null; + + + try { + // InternalRos2Parser.g:2587:59: (iv_ruleExternalDependency= ruleExternalDependency EOF ) + // InternalRos2Parser.g:2588: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" + // InternalRos2Parser.g:2594: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 { + // InternalRos2Parser.g:2600:2: ( ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) ) + // InternalRos2Parser.g:2601:2: ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) + { + // InternalRos2Parser.g:2601:2: ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) + // InternalRos2Parser.g:2602:3: () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) + { + // InternalRos2Parser.g:2602:3: () + // InternalRos2Parser.g:2603:4: + { + + current = forceCreateModelElement( + grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,ExternalDependency,FOLLOW_6); + + newLeafNode(otherlv_1, grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); + + // InternalRos2Parser.g:2613:3: ( (lv_name_2_0= ruleEString ) ) + // InternalRos2Parser.g:2614:4: (lv_name_2_0= ruleEString ) + { + // InternalRos2Parser.g:2614:4: (lv_name_2_0= ruleEString ) + // InternalRos2Parser.g:2615: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.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleExternalDependency" + + + // $ANTLR start "entryRuleNamespace" + // InternalRos2Parser.g:2636:1: entryRuleNamespace returns [EObject current=null] : iv_ruleNamespace= ruleNamespace EOF ; + public final EObject entryRuleNamespace() throws RecognitionException { + EObject current = null; + + EObject iv_ruleNamespace = null; + + + try { + // InternalRos2Parser.g:2636:50: (iv_ruleNamespace= ruleNamespace EOF ) + // InternalRos2Parser.g:2637:2: iv_ruleNamespace= ruleNamespace EOF + { + newCompositeNode(grammarAccess.getNamespaceRule()); + pushFollow(FOLLOW_1); + iv_ruleNamespace=ruleNamespace(); + + state._fsp--; + + current =iv_ruleNamespace; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleNamespace" + + + // $ANTLR start "ruleNamespace" + // InternalRos2Parser.g:2643:1: ruleNamespace returns [EObject current=null] : (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) ; + public final EObject ruleNamespace() throws RecognitionException { + EObject current = null; + + EObject this_GlobalNamespace_0 = null; + + EObject this_RelativeNamespace_Impl_1 = null; + + EObject this_PrivateNamespace_2 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:2649:2: ( (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) ) + // InternalRos2Parser.g:2650:2: (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) + { + // InternalRos2Parser.g:2650:2: (this_GlobalNamespace_0= ruleGlobalNamespace | this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl | this_PrivateNamespace_2= rulePrivateNamespace ) + int alt51=3; + switch ( input.LA(1) ) { + case GlobalNamespace: + { + alt51=1; + } + break; + case RelativeNamespace: + { + alt51=2; + } + break; + case PrivateNamespace: + { + alt51=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 51, 0, input); + + throw nvae; + } + + switch (alt51) { + case 1 : + // InternalRos2Parser.g:2651:3: this_GlobalNamespace_0= ruleGlobalNamespace + { + + newCompositeNode(grammarAccess.getNamespaceAccess().getGlobalNamespaceParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_GlobalNamespace_0=ruleGlobalNamespace(); + + state._fsp--; + + + current = this_GlobalNamespace_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos2Parser.g:2660:3: this_RelativeNamespace_Impl_1= ruleRelativeNamespace_Impl + { + + newCompositeNode(grammarAccess.getNamespaceAccess().getRelativeNamespace_ImplParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_RelativeNamespace_Impl_1=ruleRelativeNamespace_Impl(); + + state._fsp--; + + + current = this_RelativeNamespace_Impl_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalRos2Parser.g:2669:3: this_PrivateNamespace_2= rulePrivateNamespace + { + + newCompositeNode(grammarAccess.getNamespaceAccess().getPrivateNamespaceParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_PrivateNamespace_2=rulePrivateNamespace(); + + state._fsp--; + + + current = this_PrivateNamespace_2; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleNamespace" + + + // $ANTLR start "entryRuleGraphName" + // InternalRos2Parser.g:2681:1: entryRuleGraphName returns [String current=null] : iv_ruleGraphName= ruleGraphName EOF ; + public final String entryRuleGraphName() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleGraphName = null; + + + try { + // InternalRos2Parser.g:2681:49: (iv_ruleGraphName= ruleGraphName EOF ) + // InternalRos2Parser.g:2682:2: iv_ruleGraphName= ruleGraphName EOF + { + newCompositeNode(grammarAccess.getGraphNameRule()); + pushFollow(FOLLOW_1); + iv_ruleGraphName=ruleGraphName(); + + state._fsp--; + + current =iv_ruleGraphName.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleGraphName" + + + // $ANTLR start "ruleGraphName" + // InternalRos2Parser.g:2688:1: ruleGraphName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= GraphName ; + public final AntlrDatatypeRuleToken ruleGraphName() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:2694:2: (kw= GraphName ) + // InternalRos2Parser.g:2695:2: kw= GraphName + { + kw=(Token)match(input,GraphName,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getGraphNameAccess().getGraphNameKeyword()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleGraphName" + + + // $ANTLR start "entryRuleGlobalNamespace" + // InternalRos2Parser.g:2703:1: entryRuleGlobalNamespace returns [EObject current=null] : iv_ruleGlobalNamespace= ruleGlobalNamespace EOF ; + public final EObject entryRuleGlobalNamespace() throws RecognitionException { + EObject current = null; + + EObject iv_ruleGlobalNamespace = null; + + + try { + // InternalRos2Parser.g:2703:56: (iv_ruleGlobalNamespace= ruleGlobalNamespace EOF ) + // InternalRos2Parser.g:2704:2: iv_ruleGlobalNamespace= ruleGlobalNamespace EOF + { + newCompositeNode(grammarAccess.getGlobalNamespaceRule()); + pushFollow(FOLLOW_1); + iv_ruleGlobalNamespace=ruleGlobalNamespace(); + + state._fsp--; + + current =iv_ruleGlobalNamespace; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleGlobalNamespace" + + + // $ANTLR start "ruleGlobalNamespace" + // InternalRos2Parser.g:2710:1: ruleGlobalNamespace returns [EObject current=null] : ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ; + public final EObject ruleGlobalNamespace() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + AntlrDatatypeRuleToken lv_parts_3_0 = null; + + AntlrDatatypeRuleToken lv_parts_5_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:2716:2: ( ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ) + // InternalRos2Parser.g:2717:2: ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + { + // InternalRos2Parser.g:2717:2: ( () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + // InternalRos2Parser.g:2718:3: () otherlv_1= GlobalNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + { + // InternalRos2Parser.g:2718:3: () + // InternalRos2Parser.g:2719:4: + { + + current = forceCreateModelElement( + grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,GlobalNamespace,FOLLOW_48); + + newLeafNode(otherlv_1, grammarAccess.getGlobalNamespaceAccess().getGlobalNamespaceKeyword_1()); + + // InternalRos2Parser.g:2729:3: (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + int alt53=2; + int LA53_0 = input.LA(1); + + if ( (LA53_0==LeftSquareBracket) ) { + alt53=1; + } + switch (alt53) { + case 1 : + // InternalRos2Parser.g:2730:4: otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket + { + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_49); + + newLeafNode(otherlv_2, grammarAccess.getGlobalNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + + // InternalRos2Parser.g:2734:4: ( (lv_parts_3_0= ruleGraphName ) ) + // InternalRos2Parser.g:2735:5: (lv_parts_3_0= ruleGraphName ) + { + // InternalRos2Parser.g:2735:5: (lv_parts_3_0= ruleGraphName ) + // InternalRos2Parser.g:2736:6: lv_parts_3_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_3_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getGlobalNamespaceRule()); + } + add( + current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:2753:4: (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* + loop52: + do { + int alt52=2; + int LA52_0 = input.LA(1); + + if ( (LA52_0==Comma) ) { + alt52=1; + } + + + switch (alt52) { + case 1 : + // InternalRos2Parser.g:2754:5: otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) + { + otherlv_4=(Token)match(input,Comma,FOLLOW_49); + + newLeafNode(otherlv_4, grammarAccess.getGlobalNamespaceAccess().getCommaKeyword_2_2_0()); + + // InternalRos2Parser.g:2758:5: ( (lv_parts_5_0= ruleGraphName ) ) + // InternalRos2Parser.g:2759:6: (lv_parts_5_0= ruleGraphName ) + { + // InternalRos2Parser.g:2759:6: (lv_parts_5_0= ruleGraphName ) + // InternalRos2Parser.g:2760:7: lv_parts_5_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getGlobalNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_5_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getGlobalNamespaceRule()); + } + add( + current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop52; + } + } while (true); + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_6, grammarAccess.getGlobalNamespaceAccess().getRightSquareBracketKeyword_2_3()); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleGlobalNamespace" + + + // $ANTLR start "entryRuleRelativeNamespace_Impl" + // InternalRos2Parser.g:2787:1: entryRuleRelativeNamespace_Impl returns [EObject current=null] : iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF ; + public final EObject entryRuleRelativeNamespace_Impl() throws RecognitionException { + EObject current = null; + + EObject iv_ruleRelativeNamespace_Impl = null; + + + try { + // InternalRos2Parser.g:2787:63: (iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF ) + // InternalRos2Parser.g:2788:2: iv_ruleRelativeNamespace_Impl= ruleRelativeNamespace_Impl EOF + { + newCompositeNode(grammarAccess.getRelativeNamespace_ImplRule()); + pushFollow(FOLLOW_1); + iv_ruleRelativeNamespace_Impl=ruleRelativeNamespace_Impl(); + + state._fsp--; + + current =iv_ruleRelativeNamespace_Impl; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleRelativeNamespace_Impl" + + + // $ANTLR start "ruleRelativeNamespace_Impl" + // InternalRos2Parser.g:2794:1: ruleRelativeNamespace_Impl returns [EObject current=null] : ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ; + public final EObject ruleRelativeNamespace_Impl() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + AntlrDatatypeRuleToken lv_parts_3_0 = null; + + AntlrDatatypeRuleToken lv_parts_5_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:2800:2: ( ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ) + // InternalRos2Parser.g:2801:2: ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + { + // InternalRos2Parser.g:2801:2: ( () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + // InternalRos2Parser.g:2802:3: () otherlv_1= RelativeNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + { + // InternalRos2Parser.g:2802:3: () + // InternalRos2Parser.g:2803:4: + { + + current = forceCreateModelElement( + grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,RelativeNamespace,FOLLOW_48); + + newLeafNode(otherlv_1, grammarAccess.getRelativeNamespace_ImplAccess().getRelativeNamespaceKeyword_1()); + + // InternalRos2Parser.g:2813:3: (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + int alt55=2; + int LA55_0 = input.LA(1); + + if ( (LA55_0==LeftSquareBracket) ) { + alt55=1; + } + switch (alt55) { + case 1 : + // InternalRos2Parser.g:2814:4: otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket + { + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_49); + + newLeafNode(otherlv_2, grammarAccess.getRelativeNamespace_ImplAccess().getLeftSquareBracketKeyword_2_0()); + + // InternalRos2Parser.g:2818:4: ( (lv_parts_3_0= ruleGraphName ) ) + // InternalRos2Parser.g:2819:5: (lv_parts_3_0= ruleGraphName ) + { + // InternalRos2Parser.g:2819:5: (lv_parts_3_0= ruleGraphName ) + // InternalRos2Parser.g:2820:6: lv_parts_3_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_3_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getRelativeNamespace_ImplRule()); + } + add( + current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:2837:4: (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* + loop54: + do { + int alt54=2; + int LA54_0 = input.LA(1); + + if ( (LA54_0==Comma) ) { + alt54=1; + } + + + switch (alt54) { + case 1 : + // InternalRos2Parser.g:2838:5: otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) + { + otherlv_4=(Token)match(input,Comma,FOLLOW_49); + + newLeafNode(otherlv_4, grammarAccess.getRelativeNamespace_ImplAccess().getCommaKeyword_2_2_0()); + + // InternalRos2Parser.g:2842:5: ( (lv_parts_5_0= ruleGraphName ) ) + // InternalRos2Parser.g:2843:6: (lv_parts_5_0= ruleGraphName ) + { + // InternalRos2Parser.g:2843:6: (lv_parts_5_0= ruleGraphName ) + // InternalRos2Parser.g:2844:7: lv_parts_5_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getRelativeNamespace_ImplAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_5_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getRelativeNamespace_ImplRule()); + } + add( + current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop54; + } + } while (true); + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_6, grammarAccess.getRelativeNamespace_ImplAccess().getRightSquareBracketKeyword_2_3()); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleRelativeNamespace_Impl" + + + // $ANTLR start "entryRulePrivateNamespace" + // InternalRos2Parser.g:2871:1: entryRulePrivateNamespace returns [EObject current=null] : iv_rulePrivateNamespace= rulePrivateNamespace EOF ; + public final EObject entryRulePrivateNamespace() throws RecognitionException { + EObject current = null; + + EObject iv_rulePrivateNamespace = null; + + + try { + // InternalRos2Parser.g:2871:57: (iv_rulePrivateNamespace= rulePrivateNamespace EOF ) + // InternalRos2Parser.g:2872:2: iv_rulePrivateNamespace= rulePrivateNamespace EOF + { + newCompositeNode(grammarAccess.getPrivateNamespaceRule()); + pushFollow(FOLLOW_1); + iv_rulePrivateNamespace=rulePrivateNamespace(); + + state._fsp--; + + current =iv_rulePrivateNamespace; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePrivateNamespace" + + + // $ANTLR start "rulePrivateNamespace" + // InternalRos2Parser.g:2878:1: rulePrivateNamespace returns [EObject current=null] : ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ; + public final EObject rulePrivateNamespace() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + AntlrDatatypeRuleToken lv_parts_3_0 = null; + + AntlrDatatypeRuleToken lv_parts_5_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:2884:2: ( ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) ) + // InternalRos2Parser.g:2885:2: ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + { + // InternalRos2Parser.g:2885:2: ( () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? ) + // InternalRos2Parser.g:2886:3: () otherlv_1= PrivateNamespace (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + { + // InternalRos2Parser.g:2886:3: () + // InternalRos2Parser.g:2887:4: + { + + current = forceCreateModelElement( + grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,PrivateNamespace,FOLLOW_48); + + newLeafNode(otherlv_1, grammarAccess.getPrivateNamespaceAccess().getPrivateNamespaceKeyword_1()); + + // InternalRos2Parser.g:2897:3: (otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket )? + int alt57=2; + int LA57_0 = input.LA(1); + + if ( (LA57_0==LeftSquareBracket) ) { + alt57=1; + } + switch (alt57) { + case 1 : + // InternalRos2Parser.g:2898:4: otherlv_2= LeftSquareBracket ( (lv_parts_3_0= ruleGraphName ) ) (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* otherlv_6= RightSquareBracket + { + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_49); + + newLeafNode(otherlv_2, grammarAccess.getPrivateNamespaceAccess().getLeftSquareBracketKeyword_2_0()); + + // InternalRos2Parser.g:2902:4: ( (lv_parts_3_0= ruleGraphName ) ) + // InternalRos2Parser.g:2903:5: (lv_parts_3_0= ruleGraphName ) + { + // InternalRos2Parser.g:2903:5: (lv_parts_3_0= ruleGraphName ) + // InternalRos2Parser.g:2904:6: lv_parts_3_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_3_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPrivateNamespaceRule()); + } + add( + current, + "parts", + lv_parts_3_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:2921:4: (otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) )* + loop56: + do { + int alt56=2; + int LA56_0 = input.LA(1); + + if ( (LA56_0==Comma) ) { + alt56=1; + } + + + switch (alt56) { + case 1 : + // InternalRos2Parser.g:2922:5: otherlv_4= Comma ( (lv_parts_5_0= ruleGraphName ) ) + { + otherlv_4=(Token)match(input,Comma,FOLLOW_49); + + newLeafNode(otherlv_4, grammarAccess.getPrivateNamespaceAccess().getCommaKeyword_2_2_0()); + + // InternalRos2Parser.g:2926:5: ( (lv_parts_5_0= ruleGraphName ) ) + // InternalRos2Parser.g:2927:6: (lv_parts_5_0= ruleGraphName ) + { + // InternalRos2Parser.g:2927:6: (lv_parts_5_0= ruleGraphName ) + // InternalRos2Parser.g:2928:7: lv_parts_5_0= ruleGraphName + { + + newCompositeNode(grammarAccess.getPrivateNamespaceAccess().getPartsGraphNameParserRuleCall_2_2_1_0()); + + pushFollow(FOLLOW_12); + lv_parts_5_0=ruleGraphName(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPrivateNamespaceRule()); + } + add( + current, + "parts", + lv_parts_5_0, + "de.fraunhofer.ipa.ros.Ros.GraphName"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop56; + } + } while (true); + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_6, grammarAccess.getPrivateNamespaceAccess().getRightSquareBracketKeyword_2_3()); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePrivateNamespace" + + + // $ANTLR start "entryRuleParameterType" + // InternalRos2Parser.g:2955:1: entryRuleParameterType returns [EObject current=null] : iv_ruleParameterType= ruleParameterType EOF ; + public final EObject entryRuleParameterType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterType = null; + + + try { + // InternalRos2Parser.g:2955:54: (iv_ruleParameterType= ruleParameterType EOF ) + // InternalRos2Parser.g:2956:2: iv_ruleParameterType= ruleParameterType EOF + { + newCompositeNode(grammarAccess.getParameterTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterType=ruleParameterType(); + + state._fsp--; + + current =iv_ruleParameterType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterType" + + + // $ANTLR start "ruleParameterType" + // InternalRos2Parser.g:2962:1: ruleParameterType returns [EObject current=null] : (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) ; + public final EObject ruleParameterType() throws RecognitionException { + EObject current = null; + + EObject this_ParameterListType_0 = null; + + EObject this_ParameterStructType_1 = null; + + EObject this_ParameterIntegerType_2 = null; + + EObject this_ParameterStringType_3 = null; + + EObject this_ParameterDoubleType_4 = null; + + EObject this_ParameterBooleanType_5 = null; + + EObject this_ParameterBase64Type_6 = null; + + EObject this_ParameterArrayType_7 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:2968:2: ( (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) ) + // InternalRos2Parser.g:2969:2: (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) + { + // InternalRos2Parser.g:2969:2: (this_ParameterListType_0= ruleParameterListType | this_ParameterStructType_1= ruleParameterStructType | this_ParameterIntegerType_2= ruleParameterIntegerType | this_ParameterStringType_3= ruleParameterStringType | this_ParameterDoubleType_4= ruleParameterDoubleType | this_ParameterBooleanType_5= ruleParameterBooleanType | this_ParameterBase64Type_6= ruleParameterBase64Type | this_ParameterArrayType_7= ruleParameterArrayType ) + int alt58=8; + switch ( input.LA(1) ) { + case List: + { + alt58=1; + } + break; + case Struct: + { + alt58=2; + } + break; + case Integer: + { + alt58=3; + } + break; + case String: + { + alt58=4; + } + break; + case Double: + { + alt58=5; + } + break; + case Boolean: + { + alt58=6; + } + break; + case Base64: + { + alt58=7; + } + break; + case Array: + { + alt58=8; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 58, 0, input); + + throw nvae; + } + + switch (alt58) { + case 1 : + // InternalRos2Parser.g:2970:3: this_ParameterListType_0= ruleParameterListType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterListTypeParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_ParameterListType_0=ruleParameterListType(); + + state._fsp--; + + + current = this_ParameterListType_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos2Parser.g:2979:3: this_ParameterStructType_1= ruleParameterStructType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterStructTypeParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_ParameterStructType_1=ruleParameterStructType(); + + state._fsp--; + + + current = this_ParameterStructType_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalRos2Parser.g:2988:3: this_ParameterIntegerType_2= ruleParameterIntegerType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterIntegerTypeParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_ParameterIntegerType_2=ruleParameterIntegerType(); + + state._fsp--; + + + current = this_ParameterIntegerType_2; + afterParserOrEnumRuleCall(); + + + } + break; + case 4 : + // InternalRos2Parser.g:2997:3: this_ParameterStringType_3= ruleParameterStringType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterStringTypeParserRuleCall_3()); + + pushFollow(FOLLOW_2); + this_ParameterStringType_3=ruleParameterStringType(); + + state._fsp--; + + + current = this_ParameterStringType_3; + afterParserOrEnumRuleCall(); + + + } + break; + case 5 : + // InternalRos2Parser.g:3006:3: this_ParameterDoubleType_4= ruleParameterDoubleType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterDoubleTypeParserRuleCall_4()); + + pushFollow(FOLLOW_2); + this_ParameterDoubleType_4=ruleParameterDoubleType(); + + state._fsp--; + + + current = this_ParameterDoubleType_4; + afterParserOrEnumRuleCall(); + + + } + break; + case 6 : + // InternalRos2Parser.g:3015:3: this_ParameterBooleanType_5= ruleParameterBooleanType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterBooleanTypeParserRuleCall_5()); + + pushFollow(FOLLOW_2); + this_ParameterBooleanType_5=ruleParameterBooleanType(); + + state._fsp--; + + + current = this_ParameterBooleanType_5; + afterParserOrEnumRuleCall(); + + + } + break; + case 7 : + // InternalRos2Parser.g:3024:3: this_ParameterBase64Type_6= ruleParameterBase64Type + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterBase64TypeParserRuleCall_6()); + + pushFollow(FOLLOW_2); + this_ParameterBase64Type_6=ruleParameterBase64Type(); + + state._fsp--; + + + current = this_ParameterBase64Type_6; + afterParserOrEnumRuleCall(); + + + } + break; + case 8 : + // InternalRos2Parser.g:3033:3: this_ParameterArrayType_7= ruleParameterArrayType + { + + newCompositeNode(grammarAccess.getParameterTypeAccess().getParameterArrayTypeParserRuleCall_7()); + + pushFollow(FOLLOW_2); + this_ParameterArrayType_7=ruleParameterArrayType(); + + state._fsp--; + + + current = this_ParameterArrayType_7; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterType" + + + // $ANTLR start "entryRuleParameterValue" + // InternalRos2Parser.g:3045:1: entryRuleParameterValue returns [EObject current=null] : iv_ruleParameterValue= ruleParameterValue EOF ; + public final EObject entryRuleParameterValue() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterValue = null; + + + try { + // InternalRos2Parser.g:3045:55: (iv_ruleParameterValue= ruleParameterValue EOF ) + // InternalRos2Parser.g:3046:2: iv_ruleParameterValue= ruleParameterValue EOF + { + newCompositeNode(grammarAccess.getParameterValueRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterValue=ruleParameterValue(); + + state._fsp--; + + current =iv_ruleParameterValue; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterValue" + + + // $ANTLR start "ruleParameterValue" + // InternalRos2Parser.g:3052:1: ruleParameterValue returns [EObject current=null] : (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) ; + public final EObject ruleParameterValue() throws RecognitionException { + EObject current = null; + + EObject this_ParameterString_0 = null; + + EObject this_ParameterBase64_1 = null; + + EObject this_ParameterInteger_2 = null; + + EObject this_ParameterDouble_3 = null; + + EObject this_ParameterBoolean_4 = null; + + EObject this_ParameterList_5 = null; + + EObject this_ParameterStruct_6 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3058:2: ( (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) ) + // InternalRos2Parser.g:3059:2: (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) + { + // InternalRos2Parser.g:3059:2: (this_ParameterString_0= ruleParameterString | this_ParameterBase64_1= ruleParameterBase64 | this_ParameterInteger_2= ruleParameterInteger | this_ParameterDouble_3= ruleParameterDouble | this_ParameterBoolean_4= ruleParameterBoolean | this_ParameterList_5= ruleParameterList | this_ParameterStruct_6= ruleParameterStruct ) + int alt59=7; + switch ( input.LA(1) ) { + case RULE_ID: + case RULE_STRING: + { + alt59=1; + } + break; + case RULE_BINARY: + { + alt59=2; + } + break; + case RULE_DECINT: + { + alt59=3; + } + break; + case RULE_DOUBLE: + { + alt59=4; + } + break; + case RULE_BOOLEAN: + { + alt59=5; + } + break; + case LeftSquareBracket: + { + int LA59_6 = input.LA(2); + + if ( (LA59_6==Comma||(LA59_6>=LeftSquareBracket && LA59_6<=RightSquareBracket)||LA59_6==RULE_ID||LA59_6==RULE_STRING||(LA59_6>=RULE_BINARY && LA59_6<=RULE_DOUBLE)) ) { + alt59=6; + } + else if ( (LA59_6==ParameterStructMember) ) { + alt59=7; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 59, 6, input); + + throw nvae; + } + } + break; + case EOF: + case Comma: + case RightSquareBracket: + case RULE_END: + { + alt59=7; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 59, 0, input); + + throw nvae; + } + + switch (alt59) { + case 1 : + // InternalRos2Parser.g:3060:3: this_ParameterString_0= ruleParameterString + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterStringParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_ParameterString_0=ruleParameterString(); + + state._fsp--; + + + current = this_ParameterString_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos2Parser.g:3069:3: this_ParameterBase64_1= ruleParameterBase64 + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterBase64ParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_ParameterBase64_1=ruleParameterBase64(); + + state._fsp--; + + + current = this_ParameterBase64_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalRos2Parser.g:3078:3: this_ParameterInteger_2= ruleParameterInteger + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterIntegerParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_ParameterInteger_2=ruleParameterInteger(); + + state._fsp--; + + + current = this_ParameterInteger_2; + afterParserOrEnumRuleCall(); + + + } + break; + case 4 : + // InternalRos2Parser.g:3087:3: this_ParameterDouble_3= ruleParameterDouble + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterDoubleParserRuleCall_3()); + + pushFollow(FOLLOW_2); + this_ParameterDouble_3=ruleParameterDouble(); + + state._fsp--; + + + current = this_ParameterDouble_3; + afterParserOrEnumRuleCall(); + + + } + break; + case 5 : + // InternalRos2Parser.g:3096:3: this_ParameterBoolean_4= ruleParameterBoolean + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterBooleanParserRuleCall_4()); + + pushFollow(FOLLOW_2); + this_ParameterBoolean_4=ruleParameterBoolean(); + + state._fsp--; + + + current = this_ParameterBoolean_4; + afterParserOrEnumRuleCall(); + + + } + break; + case 6 : + // InternalRos2Parser.g:3105:3: this_ParameterList_5= ruleParameterList + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterListParserRuleCall_5()); + + pushFollow(FOLLOW_2); + this_ParameterList_5=ruleParameterList(); + + state._fsp--; + + + current = this_ParameterList_5; + afterParserOrEnumRuleCall(); + + + } + break; + case 7 : + // InternalRos2Parser.g:3114:3: this_ParameterStruct_6= ruleParameterStruct + { + + newCompositeNode(grammarAccess.getParameterValueAccess().getParameterStructParserRuleCall_6()); + + pushFollow(FOLLOW_2); + this_ParameterStruct_6=ruleParameterStruct(); + + state._fsp--; + + + current = this_ParameterStruct_6; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterValue" + + + // $ANTLR start "entryRuleParameterListType" + // InternalRos2Parser.g:3126:1: entryRuleParameterListType returns [EObject current=null] : iv_ruleParameterListType= ruleParameterListType EOF ; + public final EObject entryRuleParameterListType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterListType = null; + + + try { + // InternalRos2Parser.g:3126:58: (iv_ruleParameterListType= ruleParameterListType EOF ) + // InternalRos2Parser.g:3127:2: iv_ruleParameterListType= ruleParameterListType EOF + { + newCompositeNode(grammarAccess.getParameterListTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterListType=ruleParameterListType(); + + state._fsp--; + + current =iv_ruleParameterListType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterListType" + + + // $ANTLR start "ruleParameterListType" + // InternalRos2Parser.g:3133:1: ruleParameterListType returns [EObject current=null] : ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) ; + public final EObject ruleParameterListType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_sequence_3_0 = null; + + EObject lv_sequence_5_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3139:2: ( ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) ) + // InternalRos2Parser.g:3140:2: ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) + { + // InternalRos2Parser.g:3140:2: ( () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket ) + // InternalRos2Parser.g:3141:3: () otherlv_1= List otherlv_2= LeftSquareBracket ( (lv_sequence_3_0= ruleParameterType ) ) (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* otherlv_6= RightSquareBracket + { + // InternalRos2Parser.g:3141:3: () + // InternalRos2Parser.g:3142:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterListTypeAccess().getParameterListTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,List,FOLLOW_10); + + newLeafNode(otherlv_1, grammarAccess.getParameterListTypeAccess().getListKeyword_1()); + + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_26); + + newLeafNode(otherlv_2, grammarAccess.getParameterListTypeAccess().getLeftSquareBracketKeyword_2()); + + // InternalRos2Parser.g:3156:3: ( (lv_sequence_3_0= ruleParameterType ) ) + // InternalRos2Parser.g:3157:4: (lv_sequence_3_0= ruleParameterType ) + { + // InternalRos2Parser.g:3157:4: (lv_sequence_3_0= ruleParameterType ) + // InternalRos2Parser.g:3158:5: lv_sequence_3_0= ruleParameterType + { + + newCompositeNode(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_3_0()); + + pushFollow(FOLLOW_12); + lv_sequence_3_0=ruleParameterType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterListTypeRule()); + } + add( + current, + "sequence", + lv_sequence_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:3175:3: (otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) )* + loop60: + do { + int alt60=2; + int LA60_0 = input.LA(1); + + if ( (LA60_0==Comma) ) { + alt60=1; + } + + + switch (alt60) { + case 1 : + // InternalRos2Parser.g:3176:4: otherlv_4= Comma ( (lv_sequence_5_0= ruleParameterType ) ) + { + otherlv_4=(Token)match(input,Comma,FOLLOW_26); + + newLeafNode(otherlv_4, grammarAccess.getParameterListTypeAccess().getCommaKeyword_4_0()); + + // InternalRos2Parser.g:3180:4: ( (lv_sequence_5_0= ruleParameterType ) ) + // InternalRos2Parser.g:3181:5: (lv_sequence_5_0= ruleParameterType ) + { + // InternalRos2Parser.g:3181:5: (lv_sequence_5_0= ruleParameterType ) + // InternalRos2Parser.g:3182:6: lv_sequence_5_0= ruleParameterType + { + + newCompositeNode(grammarAccess.getParameterListTypeAccess().getSequenceParameterTypeParserRuleCall_4_1_0()); + + pushFollow(FOLLOW_12); + lv_sequence_5_0=ruleParameterType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterListTypeRule()); + } + add( + current, + "sequence", + lv_sequence_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop60; + } + } while (true); + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_6, grammarAccess.getParameterListTypeAccess().getRightSquareBracketKeyword_5()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterListType" + + + // $ANTLR start "entryRuleParameterStructType" + // InternalRos2Parser.g:3208:1: entryRuleParameterStructType returns [EObject current=null] : iv_ruleParameterStructType= ruleParameterStructType EOF ; + public final EObject entryRuleParameterStructType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterStructType = null; + + + try { + // InternalRos2Parser.g:3208:60: (iv_ruleParameterStructType= ruleParameterStructType EOF ) + // InternalRos2Parser.g:3209:2: iv_ruleParameterStructType= ruleParameterStructType EOF + { + newCompositeNode(grammarAccess.getParameterStructTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterStructType=ruleParameterStructType(); + + state._fsp--; + + current =iv_ruleParameterStructType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterStructType" + + + // $ANTLR start "ruleParameterStructType" + // InternalRos2Parser.g:3215:1: ruleParameterStructType returns [EObject current=null] : ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) ; + public final EObject ruleParameterStructType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_parameterstructypetmember_3_0 = null; + + EObject lv_parameterstructypetmember_5_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3221:2: ( ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) ) + // InternalRos2Parser.g:3222:2: ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) + { + // InternalRos2Parser.g:3222:2: ( () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket ) + // InternalRos2Parser.g:3223:3: () otherlv_1= Struct otherlv_2= LeftSquareBracket ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* otherlv_6= RightSquareBracket + { + // InternalRos2Parser.g:3223:3: () + // InternalRos2Parser.g:3224:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterStructTypeAccess().getParameterStructTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Struct,FOLLOW_10); + + newLeafNode(otherlv_1, grammarAccess.getParameterStructTypeAccess().getStructKeyword_1()); + + otherlv_2=(Token)match(input,LeftSquareBracket,FOLLOW_6); + + newLeafNode(otherlv_2, grammarAccess.getParameterStructTypeAccess().getLeftSquareBracketKeyword_2()); + + // InternalRos2Parser.g:3238:3: ( (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) ) + // InternalRos2Parser.g:3239:4: (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) + { + // InternalRos2Parser.g:3239:4: (lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember ) + // InternalRos2Parser.g:3240:5: lv_parameterstructypetmember_3_0= ruleParameterStructTypeMember + { + + newCompositeNode(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_3_0()); + + pushFollow(FOLLOW_12); + lv_parameterstructypetmember_3_0=ruleParameterStructTypeMember(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructTypeRule()); + } + add( + current, + "parameterstructypetmember", + lv_parameterstructypetmember_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructTypeMember"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:3257:3: (otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) )* + loop61: + do { + int alt61=2; + int LA61_0 = input.LA(1); + + if ( (LA61_0==Comma) ) { + alt61=1; + } + + + switch (alt61) { + case 1 : + // InternalRos2Parser.g:3258:4: otherlv_4= Comma ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) + { + otherlv_4=(Token)match(input,Comma,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getParameterStructTypeAccess().getCommaKeyword_4_0()); + + // InternalRos2Parser.g:3262:4: ( (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) ) + // InternalRos2Parser.g:3263:5: (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) + { + // InternalRos2Parser.g:3263:5: (lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember ) + // InternalRos2Parser.g:3264:6: lv_parameterstructypetmember_5_0= ruleParameterStructTypeMember + { + + newCompositeNode(grammarAccess.getParameterStructTypeAccess().getParameterstructypetmemberParameterStructTypeMemberParserRuleCall_4_1_0()); + + pushFollow(FOLLOW_12); + lv_parameterstructypetmember_5_0=ruleParameterStructTypeMember(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructTypeRule()); + } + add( + current, + "parameterstructypetmember", + lv_parameterstructypetmember_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructTypeMember"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop61; + } + } while (true); + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_6, grammarAccess.getParameterStructTypeAccess().getRightSquareBracketKeyword_5()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterStructType" + + + // $ANTLR start "entryRuleParameterIntegerType" + // InternalRos2Parser.g:3290:1: entryRuleParameterIntegerType returns [EObject current=null] : iv_ruleParameterIntegerType= ruleParameterIntegerType EOF ; + public final EObject entryRuleParameterIntegerType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterIntegerType = null; + + + try { + // InternalRos2Parser.g:3290:61: (iv_ruleParameterIntegerType= ruleParameterIntegerType EOF ) + // InternalRos2Parser.g:3291:2: iv_ruleParameterIntegerType= ruleParameterIntegerType EOF + { + newCompositeNode(grammarAccess.getParameterIntegerTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterIntegerType=ruleParameterIntegerType(); + + state._fsp--; + + current =iv_ruleParameterIntegerType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterIntegerType" + + + // $ANTLR start "ruleParameterIntegerType" + // InternalRos2Parser.g:3297:1: ruleParameterIntegerType returns [EObject current=null] : ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) ; + public final EObject ruleParameterIntegerType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + EObject lv_default_3_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3303:2: ( ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) ) + // InternalRos2Parser.g:3304:2: ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) + { + // InternalRos2Parser.g:3304:2: ( () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? ) + // InternalRos2Parser.g:3305:3: () otherlv_1= Integer (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? + { + // InternalRos2Parser.g:3305:3: () + // InternalRos2Parser.g:3306:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterIntegerTypeAccess().getParameterIntegerTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Integer,FOLLOW_50); + + newLeafNode(otherlv_1, grammarAccess.getParameterIntegerTypeAccess().getIntegerKeyword_1()); + + // InternalRos2Parser.g:3316:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) )? + int alt62=2; + int LA62_0 = input.LA(1); + + if ( (LA62_0==Default) ) { + int LA62_1 = input.LA(2); + + if ( (LA62_1==RULE_DECINT) ) { + alt62=1; + } + } + switch (alt62) { + case 1 : + // InternalRos2Parser.g:3317:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterInteger ) ) + { + otherlv_2=(Token)match(input,Default,FOLLOW_17); + + newLeafNode(otherlv_2, grammarAccess.getParameterIntegerTypeAccess().getDefaultKeyword_2_0()); + + // InternalRos2Parser.g:3321:4: ( (lv_default_3_0= ruleParameterInteger ) ) + // InternalRos2Parser.g:3322:5: (lv_default_3_0= ruleParameterInteger ) + { + // InternalRos2Parser.g:3322:5: (lv_default_3_0= ruleParameterInteger ) + // InternalRos2Parser.g:3323:6: lv_default_3_0= ruleParameterInteger + { + + newCompositeNode(grammarAccess.getParameterIntegerTypeAccess().getDefaultParameterIntegerParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_default_3_0=ruleParameterInteger(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterIntegerTypeRule()); + } + set( + current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterInteger"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterIntegerType" + + + // $ANTLR start "entryRuleParameterStringType" + // InternalRos2Parser.g:3345:1: entryRuleParameterStringType returns [EObject current=null] : iv_ruleParameterStringType= ruleParameterStringType EOF ; + public final EObject entryRuleParameterStringType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterStringType = null; + + + try { + // InternalRos2Parser.g:3345:60: (iv_ruleParameterStringType= ruleParameterStringType EOF ) + // InternalRos2Parser.g:3346:2: iv_ruleParameterStringType= ruleParameterStringType EOF + { + newCompositeNode(grammarAccess.getParameterStringTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterStringType=ruleParameterStringType(); + + state._fsp--; + + current =iv_ruleParameterStringType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterStringType" + + + // $ANTLR start "ruleParameterStringType" + // InternalRos2Parser.g:3352:1: ruleParameterStringType returns [EObject current=null] : ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) ; + public final EObject ruleParameterStringType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + EObject lv_default_3_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3358:2: ( ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) ) + // InternalRos2Parser.g:3359:2: ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) + { + // InternalRos2Parser.g:3359:2: ( () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? ) + // InternalRos2Parser.g:3360:3: () otherlv_1= String (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? + { + // InternalRos2Parser.g:3360:3: () + // InternalRos2Parser.g:3361:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterStringTypeAccess().getParameterStringTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,String,FOLLOW_50); + + newLeafNode(otherlv_1, grammarAccess.getParameterStringTypeAccess().getStringKeyword_1()); + + // InternalRos2Parser.g:3371:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) )? + int alt63=2; + int LA63_0 = input.LA(1); + + if ( (LA63_0==Default) ) { + int LA63_1 = input.LA(2); + + if ( (LA63_1==RULE_ID||LA63_1==RULE_STRING) ) { + alt63=1; + } + } + switch (alt63) { + case 1 : + // InternalRos2Parser.g:3372:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterString ) ) + { + otherlv_2=(Token)match(input,Default,FOLLOW_6); + + newLeafNode(otherlv_2, grammarAccess.getParameterStringTypeAccess().getDefaultKeyword_2_0()); + + // InternalRos2Parser.g:3376:4: ( (lv_default_3_0= ruleParameterString ) ) + // InternalRos2Parser.g:3377:5: (lv_default_3_0= ruleParameterString ) + { + // InternalRos2Parser.g:3377:5: (lv_default_3_0= ruleParameterString ) + // InternalRos2Parser.g:3378:6: lv_default_3_0= ruleParameterString + { + + newCompositeNode(grammarAccess.getParameterStringTypeAccess().getDefaultParameterStringParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_default_3_0=ruleParameterString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStringTypeRule()); + } + set( + current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterStringType" + + + // $ANTLR start "entryRuleParameterDoubleType" + // InternalRos2Parser.g:3400:1: entryRuleParameterDoubleType returns [EObject current=null] : iv_ruleParameterDoubleType= ruleParameterDoubleType EOF ; + public final EObject entryRuleParameterDoubleType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterDoubleType = null; + + + try { + // InternalRos2Parser.g:3400:60: (iv_ruleParameterDoubleType= ruleParameterDoubleType EOF ) + // InternalRos2Parser.g:3401:2: iv_ruleParameterDoubleType= ruleParameterDoubleType EOF + { + newCompositeNode(grammarAccess.getParameterDoubleTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterDoubleType=ruleParameterDoubleType(); + + state._fsp--; + + current =iv_ruleParameterDoubleType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterDoubleType" + + + // $ANTLR start "ruleParameterDoubleType" + // InternalRos2Parser.g:3407:1: ruleParameterDoubleType returns [EObject current=null] : ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) ; + public final EObject ruleParameterDoubleType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + EObject lv_default_3_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3413:2: ( ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) ) + // InternalRos2Parser.g:3414:2: ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) + { + // InternalRos2Parser.g:3414:2: ( () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? ) + // InternalRos2Parser.g:3415:3: () otherlv_1= Double (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? + { + // InternalRos2Parser.g:3415:3: () + // InternalRos2Parser.g:3416:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterDoubleTypeAccess().getParameterDoubleTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Double,FOLLOW_50); + + newLeafNode(otherlv_1, grammarAccess.getParameterDoubleTypeAccess().getDoubleKeyword_1()); + + // InternalRos2Parser.g:3426:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) )? + int alt64=2; + int LA64_0 = input.LA(1); + + if ( (LA64_0==Default) ) { + int LA64_1 = input.LA(2); + + if ( (LA64_1==RULE_DOUBLE) ) { + alt64=1; + } + } + switch (alt64) { + case 1 : + // InternalRos2Parser.g:3427:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterDouble ) ) + { + otherlv_2=(Token)match(input,Default,FOLLOW_51); + + newLeafNode(otherlv_2, grammarAccess.getParameterDoubleTypeAccess().getDefaultKeyword_2_0()); + + // InternalRos2Parser.g:3431:4: ( (lv_default_3_0= ruleParameterDouble ) ) + // InternalRos2Parser.g:3432:5: (lv_default_3_0= ruleParameterDouble ) + { + // InternalRos2Parser.g:3432:5: (lv_default_3_0= ruleParameterDouble ) + // InternalRos2Parser.g:3433:6: lv_default_3_0= ruleParameterDouble + { + + newCompositeNode(grammarAccess.getParameterDoubleTypeAccess().getDefaultParameterDoubleParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_default_3_0=ruleParameterDouble(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterDoubleTypeRule()); + } + set( + current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterDouble"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterDoubleType" + + + // $ANTLR start "entryRuleParameterBooleanType" + // InternalRos2Parser.g:3455:1: entryRuleParameterBooleanType returns [EObject current=null] : iv_ruleParameterBooleanType= ruleParameterBooleanType EOF ; + public final EObject entryRuleParameterBooleanType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterBooleanType = null; + + + try { + // InternalRos2Parser.g:3455:61: (iv_ruleParameterBooleanType= ruleParameterBooleanType EOF ) + // InternalRos2Parser.g:3456:2: iv_ruleParameterBooleanType= ruleParameterBooleanType EOF + { + newCompositeNode(grammarAccess.getParameterBooleanTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterBooleanType=ruleParameterBooleanType(); + + state._fsp--; + + current =iv_ruleParameterBooleanType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterBooleanType" + + + // $ANTLR start "ruleParameterBooleanType" + // InternalRos2Parser.g:3462:1: ruleParameterBooleanType returns [EObject current=null] : ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) ; + public final EObject ruleParameterBooleanType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + EObject lv_default_3_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3468:2: ( ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) ) + // InternalRos2Parser.g:3469:2: ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) + { + // InternalRos2Parser.g:3469:2: ( () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? ) + // InternalRos2Parser.g:3470:3: () otherlv_1= Boolean (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? + { + // InternalRos2Parser.g:3470:3: () + // InternalRos2Parser.g:3471:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterBooleanTypeAccess().getParameterBooleanTypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Boolean,FOLLOW_50); + + newLeafNode(otherlv_1, grammarAccess.getParameterBooleanTypeAccess().getBooleanKeyword_1()); + + // InternalRos2Parser.g:3481:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) )? + int alt65=2; + int LA65_0 = input.LA(1); + + if ( (LA65_0==Default) ) { + int LA65_1 = input.LA(2); + + if ( (LA65_1==RULE_BOOLEAN) ) { + alt65=1; + } + } + switch (alt65) { + case 1 : + // InternalRos2Parser.g:3482:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterBoolean ) ) + { + otherlv_2=(Token)match(input,Default,FOLLOW_52); + + newLeafNode(otherlv_2, grammarAccess.getParameterBooleanTypeAccess().getDefaultKeyword_2_0()); + + // InternalRos2Parser.g:3486:4: ( (lv_default_3_0= ruleParameterBoolean ) ) + // InternalRos2Parser.g:3487:5: (lv_default_3_0= ruleParameterBoolean ) + { + // InternalRos2Parser.g:3487:5: (lv_default_3_0= ruleParameterBoolean ) + // InternalRos2Parser.g:3488:6: lv_default_3_0= ruleParameterBoolean + { + + newCompositeNode(grammarAccess.getParameterBooleanTypeAccess().getDefaultParameterBooleanParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_default_3_0=ruleParameterBoolean(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterBooleanTypeRule()); + } + set( + current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterBoolean"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterBooleanType" + + + // $ANTLR start "entryRuleParameterBase64Type" + // InternalRos2Parser.g:3510:1: entryRuleParameterBase64Type returns [EObject current=null] : iv_ruleParameterBase64Type= ruleParameterBase64Type EOF ; + public final EObject entryRuleParameterBase64Type() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterBase64Type = null; + + + try { + // InternalRos2Parser.g:3510:60: (iv_ruleParameterBase64Type= ruleParameterBase64Type EOF ) + // InternalRos2Parser.g:3511:2: iv_ruleParameterBase64Type= ruleParameterBase64Type EOF + { + newCompositeNode(grammarAccess.getParameterBase64TypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterBase64Type=ruleParameterBase64Type(); + + state._fsp--; + + current =iv_ruleParameterBase64Type; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterBase64Type" + + + // $ANTLR start "ruleParameterBase64Type" + // InternalRos2Parser.g:3517:1: ruleParameterBase64Type returns [EObject current=null] : ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) ; + public final EObject ruleParameterBase64Type() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + EObject lv_default_3_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3523:2: ( ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) ) + // InternalRos2Parser.g:3524:2: ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) + { + // InternalRos2Parser.g:3524:2: ( () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? ) + // InternalRos2Parser.g:3525:3: () otherlv_1= Base64 (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? + { + // InternalRos2Parser.g:3525:3: () + // InternalRos2Parser.g:3526:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterBase64TypeAccess().getParameterBase64TypeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Base64,FOLLOW_50); + + newLeafNode(otherlv_1, grammarAccess.getParameterBase64TypeAccess().getBase64Keyword_1()); + + // InternalRos2Parser.g:3536:3: (otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) )? + int alt66=2; + int LA66_0 = input.LA(1); + + if ( (LA66_0==Default) ) { + int LA66_1 = input.LA(2); + + if ( (LA66_1==RULE_BINARY) ) { + alt66=1; + } + } + switch (alt66) { + case 1 : + // InternalRos2Parser.g:3537:4: otherlv_2= Default ( (lv_default_3_0= ruleParameterBase64 ) ) + { + otherlv_2=(Token)match(input,Default,FOLLOW_53); + + newLeafNode(otherlv_2, grammarAccess.getParameterBase64TypeAccess().getDefaultKeyword_2_0()); + + // InternalRos2Parser.g:3541:4: ( (lv_default_3_0= ruleParameterBase64 ) ) + // InternalRos2Parser.g:3542:5: (lv_default_3_0= ruleParameterBase64 ) + { + // InternalRos2Parser.g:3542:5: (lv_default_3_0= ruleParameterBase64 ) + // InternalRos2Parser.g:3543:6: lv_default_3_0= ruleParameterBase64 + { + + newCompositeNode(grammarAccess.getParameterBase64TypeAccess().getDefaultParameterBase64ParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_default_3_0=ruleParameterBase64(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterBase64TypeRule()); + } + set( + current, + "default", + lv_default_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterBase64"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterBase64Type" + + + // $ANTLR start "entryRuleParameterArrayType" + // InternalRos2Parser.g:3565:1: entryRuleParameterArrayType returns [EObject current=null] : iv_ruleParameterArrayType= ruleParameterArrayType EOF ; + public final EObject entryRuleParameterArrayType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterArrayType = null; + + + try { + // InternalRos2Parser.g:3565:59: (iv_ruleParameterArrayType= ruleParameterArrayType EOF ) + // InternalRos2Parser.g:3566:2: iv_ruleParameterArrayType= ruleParameterArrayType EOF + { + newCompositeNode(grammarAccess.getParameterArrayTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterArrayType=ruleParameterArrayType(); + + state._fsp--; + + current =iv_ruleParameterArrayType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterArrayType" + + + // $ANTLR start "ruleParameterArrayType" + // InternalRos2Parser.g:3572:1: ruleParameterArrayType returns [EObject current=null] : (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) ; + public final EObject ruleParameterArrayType() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token this_BEGIN_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token this_END_6=null; + EObject lv_type_3_0 = null; + + EObject lv_default_5_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3578:2: ( (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) ) + // InternalRos2Parser.g:3579:2: (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) + { + // InternalRos2Parser.g:3579:2: (otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END ) + // InternalRos2Parser.g:3580:3: otherlv_0= Array this_BEGIN_1= RULE_BEGIN otherlv_2= Type ( (lv_type_3_0= ruleParameterType ) ) (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? this_END_6= RULE_END + { + otherlv_0=(Token)match(input,Array,FOLLOW_4); + + newLeafNode(otherlv_0, grammarAccess.getParameterArrayTypeAccess().getArrayKeyword_0()); + + this_BEGIN_1=(Token)match(input,RULE_BEGIN,FOLLOW_25); + + newLeafNode(this_BEGIN_1, grammarAccess.getParameterArrayTypeAccess().getBEGINTerminalRuleCall_1()); + + otherlv_2=(Token)match(input,Type,FOLLOW_26); + + newLeafNode(otherlv_2, grammarAccess.getParameterArrayTypeAccess().getTypeKeyword_2()); + + // InternalRos2Parser.g:3592:3: ( (lv_type_3_0= ruleParameterType ) ) + // InternalRos2Parser.g:3593:4: (lv_type_3_0= ruleParameterType ) + { + // InternalRos2Parser.g:3593:4: (lv_type_3_0= ruleParameterType ) + // InternalRos2Parser.g:3594:5: lv_type_3_0= ruleParameterType + { + + newCompositeNode(grammarAccess.getParameterArrayTypeAccess().getTypeParameterTypeParserRuleCall_3_0()); + + pushFollow(FOLLOW_54); + lv_type_3_0=ruleParameterType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterArrayTypeRule()); + } + set( + current, + "type", + lv_type_3_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:3611:3: (otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) )? + int alt67=2; + int LA67_0 = input.LA(1); + + if ( (LA67_0==Default) ) { + alt67=1; + } + switch (alt67) { + case 1 : + // InternalRos2Parser.g:3612:4: otherlv_4= Default ( (lv_default_5_0= ruleParameterList ) ) + { + otherlv_4=(Token)match(input,Default,FOLLOW_10); + + newLeafNode(otherlv_4, grammarAccess.getParameterArrayTypeAccess().getDefaultKeyword_4_0()); + + // InternalRos2Parser.g:3616:4: ( (lv_default_5_0= ruleParameterList ) ) + // InternalRos2Parser.g:3617:5: (lv_default_5_0= ruleParameterList ) + { + // InternalRos2Parser.g:3617:5: (lv_default_5_0= ruleParameterList ) + // InternalRos2Parser.g:3618:6: lv_default_5_0= ruleParameterList + { + + newCompositeNode(grammarAccess.getParameterArrayTypeAccess().getDefaultParameterListParserRuleCall_4_1_0()); + + pushFollow(FOLLOW_13); + lv_default_5_0=ruleParameterList(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterArrayTypeRule()); + } + set( + current, + "default", + lv_default_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterList"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + this_END_6=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_6, grammarAccess.getParameterArrayTypeAccess().getENDTerminalRuleCall_5()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterArrayType" + + + // $ANTLR start "entryRuleParameterList" + // InternalRos2Parser.g:3644:1: entryRuleParameterList returns [EObject current=null] : iv_ruleParameterList= ruleParameterList EOF ; + public final EObject entryRuleParameterList() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterList = null; + + + try { + // InternalRos2Parser.g:3644:54: (iv_ruleParameterList= ruleParameterList EOF ) + // InternalRos2Parser.g:3645:2: iv_ruleParameterList= ruleParameterList EOF + { + newCompositeNode(grammarAccess.getParameterListRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterList=ruleParameterList(); + + state._fsp--; + + current =iv_ruleParameterList; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterList" + + + // $ANTLR start "ruleParameterList" + // InternalRos2Parser.g:3651:1: ruleParameterList returns [EObject current=null] : ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) ; + public final EObject ruleParameterList() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + EObject lv_value_2_0 = null; + + EObject lv_value_4_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3657:2: ( ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) ) + // InternalRos2Parser.g:3658:2: ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) + { + // InternalRos2Parser.g:3658:2: ( () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket ) + // InternalRos2Parser.g:3659:3: () otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterValue ) ) (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* otherlv_5= RightSquareBracket + { + // InternalRos2Parser.g:3659:3: () + // InternalRos2Parser.g:3660:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterListAccess().getParameterSequenceAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,LeftSquareBracket,FOLLOW_55); + + newLeafNode(otherlv_1, grammarAccess.getParameterListAccess().getLeftSquareBracketKeyword_1()); + + // InternalRos2Parser.g:3670:3: ( (lv_value_2_0= ruleParameterValue ) ) + // InternalRos2Parser.g:3671:4: (lv_value_2_0= ruleParameterValue ) + { + // InternalRos2Parser.g:3671:4: (lv_value_2_0= ruleParameterValue ) + // InternalRos2Parser.g:3672:5: lv_value_2_0= ruleParameterValue + { + + newCompositeNode(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_2_0()); + + pushFollow(FOLLOW_12); + lv_value_2_0=ruleParameterValue(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterListRule()); + } + add( + current, + "value", + lv_value_2_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:3689:3: (otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) )* + loop68: + do { + int alt68=2; + int LA68_0 = input.LA(1); + + if ( (LA68_0==Comma) ) { + alt68=1; + } + + + switch (alt68) { + case 1 : + // InternalRos2Parser.g:3690:4: otherlv_3= Comma ( (lv_value_4_0= ruleParameterValue ) ) + { + otherlv_3=(Token)match(input,Comma,FOLLOW_55); + + newLeafNode(otherlv_3, grammarAccess.getParameterListAccess().getCommaKeyword_3_0()); + + // InternalRos2Parser.g:3694:4: ( (lv_value_4_0= ruleParameterValue ) ) + // InternalRos2Parser.g:3695:5: (lv_value_4_0= ruleParameterValue ) + { + // InternalRos2Parser.g:3695:5: (lv_value_4_0= ruleParameterValue ) + // InternalRos2Parser.g:3696:6: lv_value_4_0= ruleParameterValue + { + + newCompositeNode(grammarAccess.getParameterListAccess().getValueParameterValueParserRuleCall_3_1_0()); + + pushFollow(FOLLOW_12); + lv_value_4_0=ruleParameterValue(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterListRule()); + } + add( + current, + "value", + lv_value_4_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop68; + } + } while (true); + + otherlv_5=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_5, grammarAccess.getParameterListAccess().getRightSquareBracketKeyword_4()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterList" + + + // $ANTLR start "entryRuleParameterAny" + // InternalRos2Parser.g:3722:1: entryRuleParameterAny returns [EObject current=null] : iv_ruleParameterAny= ruleParameterAny EOF ; + public final EObject entryRuleParameterAny() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterAny = null; + + + try { + // InternalRos2Parser.g:3722:53: (iv_ruleParameterAny= ruleParameterAny EOF ) + // InternalRos2Parser.g:3723:2: iv_ruleParameterAny= ruleParameterAny EOF + { + newCompositeNode(grammarAccess.getParameterAnyRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterAny=ruleParameterAny(); + + state._fsp--; + + current =iv_ruleParameterAny; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterAny" + + + // $ANTLR start "ruleParameterAny" + // InternalRos2Parser.g:3729:1: ruleParameterAny returns [EObject current=null] : ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) ; + public final EObject ruleParameterAny() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + AntlrDatatypeRuleToken lv_value_3_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3735:2: ( ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) ) + // InternalRos2Parser.g:3736:2: ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) + { + // InternalRos2Parser.g:3736:2: ( () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? ) + // InternalRos2Parser.g:3737:3: () otherlv_1= ParameterAny (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? + { + // InternalRos2Parser.g:3737:3: () + // InternalRos2Parser.g:3738:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterAnyAccess().getParameterAnyAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,ParameterAny,FOLLOW_56); + + newLeafNode(otherlv_1, grammarAccess.getParameterAnyAccess().getParameterAnyKeyword_1()); + + // InternalRos2Parser.g:3748:3: (otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) )? + int alt69=2; + int LA69_0 = input.LA(1); + + if ( (LA69_0==Value) ) { + alt69=1; + } + switch (alt69) { + case 1 : + // InternalRos2Parser.g:3749:4: otherlv_2= Value ( (lv_value_3_0= ruleEString ) ) + { + otherlv_2=(Token)match(input,Value,FOLLOW_6); + + newLeafNode(otherlv_2, grammarAccess.getParameterAnyAccess().getValueKeyword_2_0()); + + // InternalRos2Parser.g:3753:4: ( (lv_value_3_0= ruleEString ) ) + // InternalRos2Parser.g:3754:5: (lv_value_3_0= ruleEString ) + { + // InternalRos2Parser.g:3754:5: (lv_value_3_0= ruleEString ) + // InternalRos2Parser.g:3755:6: lv_value_3_0= ruleEString + { + + newCompositeNode(grammarAccess.getParameterAnyAccess().getValueEStringParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_2); + lv_value_3_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterAnyRule()); + } + set( + current, + "value", + lv_value_3_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterAny" + + + // $ANTLR start "entryRuleParameterString" + // InternalRos2Parser.g:3777:1: entryRuleParameterString returns [EObject current=null] : iv_ruleParameterString= ruleParameterString EOF ; + public final EObject entryRuleParameterString() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterString = null; + + + try { + // InternalRos2Parser.g:3777:56: (iv_ruleParameterString= ruleParameterString EOF ) + // InternalRos2Parser.g:3778:2: iv_ruleParameterString= ruleParameterString EOF + { + newCompositeNode(grammarAccess.getParameterStringRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterString=ruleParameterString(); + + state._fsp--; + + current =iv_ruleParameterString; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterString" + + + // $ANTLR start "ruleParameterString" + // InternalRos2Parser.g:3784:1: ruleParameterString returns [EObject current=null] : ( (lv_value_0_0= ruleEString ) ) ; + public final EObject ruleParameterString() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3790:2: ( ( (lv_value_0_0= ruleEString ) ) ) + // InternalRos2Parser.g:3791:2: ( (lv_value_0_0= ruleEString ) ) + { + // InternalRos2Parser.g:3791:2: ( (lv_value_0_0= ruleEString ) ) + // InternalRos2Parser.g:3792:3: (lv_value_0_0= ruleEString ) + { + // InternalRos2Parser.g:3792:3: (lv_value_0_0= ruleEString ) + // InternalRos2Parser.g:3793:4: lv_value_0_0= ruleEString + { + + newCompositeNode(grammarAccess.getParameterStringAccess().getValueEStringParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStringRule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterString" + + + // $ANTLR start "entryRuleParameterBase64" + // InternalRos2Parser.g:3813:1: entryRuleParameterBase64 returns [EObject current=null] : iv_ruleParameterBase64= ruleParameterBase64 EOF ; + public final EObject entryRuleParameterBase64() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterBase64 = null; + + + try { + // InternalRos2Parser.g:3813:56: (iv_ruleParameterBase64= ruleParameterBase64 EOF ) + // InternalRos2Parser.g:3814:2: iv_ruleParameterBase64= ruleParameterBase64 EOF + { + newCompositeNode(grammarAccess.getParameterBase64Rule()); + pushFollow(FOLLOW_1); + iv_ruleParameterBase64=ruleParameterBase64(); + + state._fsp--; + + current =iv_ruleParameterBase64; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterBase64" + + + // $ANTLR start "ruleParameterBase64" + // InternalRos2Parser.g:3820:1: ruleParameterBase64 returns [EObject current=null] : ( (lv_value_0_0= ruleBase64Binary ) ) ; + public final EObject ruleParameterBase64() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3826:2: ( ( (lv_value_0_0= ruleBase64Binary ) ) ) + // InternalRos2Parser.g:3827:2: ( (lv_value_0_0= ruleBase64Binary ) ) + { + // InternalRos2Parser.g:3827:2: ( (lv_value_0_0= ruleBase64Binary ) ) + // InternalRos2Parser.g:3828:3: (lv_value_0_0= ruleBase64Binary ) + { + // InternalRos2Parser.g:3828:3: (lv_value_0_0= ruleBase64Binary ) + // InternalRos2Parser.g:3829:4: lv_value_0_0= ruleBase64Binary + { + + newCompositeNode(grammarAccess.getParameterBase64Access().getValueBase64BinaryParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleBase64Binary(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterBase64Rule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Base64Binary"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterBase64" + + + // $ANTLR start "entryRuleParameterInteger" + // InternalRos2Parser.g:3849:1: entryRuleParameterInteger returns [EObject current=null] : iv_ruleParameterInteger= ruleParameterInteger EOF ; + public final EObject entryRuleParameterInteger() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterInteger = null; + + + try { + // InternalRos2Parser.g:3849:57: (iv_ruleParameterInteger= ruleParameterInteger EOF ) + // InternalRos2Parser.g:3850:2: iv_ruleParameterInteger= ruleParameterInteger EOF + { + newCompositeNode(grammarAccess.getParameterIntegerRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterInteger=ruleParameterInteger(); + + state._fsp--; + + current =iv_ruleParameterInteger; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterInteger" + + + // $ANTLR start "ruleParameterInteger" + // InternalRos2Parser.g:3856:1: ruleParameterInteger returns [EObject current=null] : ( (lv_value_0_0= ruleInteger0 ) ) ; + public final EObject ruleParameterInteger() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3862:2: ( ( (lv_value_0_0= ruleInteger0 ) ) ) + // InternalRos2Parser.g:3863:2: ( (lv_value_0_0= ruleInteger0 ) ) + { + // InternalRos2Parser.g:3863:2: ( (lv_value_0_0= ruleInteger0 ) ) + // InternalRos2Parser.g:3864:3: (lv_value_0_0= ruleInteger0 ) + { + // InternalRos2Parser.g:3864:3: (lv_value_0_0= ruleInteger0 ) + // InternalRos2Parser.g:3865:4: lv_value_0_0= ruleInteger0 + { + + newCompositeNode(grammarAccess.getParameterIntegerAccess().getValueInteger0ParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleInteger0(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterIntegerRule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Integer0"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterInteger" + + + // $ANTLR start "entryRuleParameterDouble" + // InternalRos2Parser.g:3885:1: entryRuleParameterDouble returns [EObject current=null] : iv_ruleParameterDouble= ruleParameterDouble EOF ; + public final EObject entryRuleParameterDouble() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterDouble = null; + + + try { + // InternalRos2Parser.g:3885:56: (iv_ruleParameterDouble= ruleParameterDouble EOF ) + // InternalRos2Parser.g:3886:2: iv_ruleParameterDouble= ruleParameterDouble EOF + { + newCompositeNode(grammarAccess.getParameterDoubleRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterDouble=ruleParameterDouble(); + + state._fsp--; + + current =iv_ruleParameterDouble; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterDouble" + + + // $ANTLR start "ruleParameterDouble" + // InternalRos2Parser.g:3892:1: ruleParameterDouble returns [EObject current=null] : ( (lv_value_0_0= ruleDouble0 ) ) ; + public final EObject ruleParameterDouble() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3898:2: ( ( (lv_value_0_0= ruleDouble0 ) ) ) + // InternalRos2Parser.g:3899:2: ( (lv_value_0_0= ruleDouble0 ) ) + { + // InternalRos2Parser.g:3899:2: ( (lv_value_0_0= ruleDouble0 ) ) + // InternalRos2Parser.g:3900:3: (lv_value_0_0= ruleDouble0 ) + { + // InternalRos2Parser.g:3900:3: (lv_value_0_0= ruleDouble0 ) + // InternalRos2Parser.g:3901:4: lv_value_0_0= ruleDouble0 + { + + newCompositeNode(grammarAccess.getParameterDoubleAccess().getValueDouble0ParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleDouble0(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterDoubleRule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.Double0"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterDouble" + + + // $ANTLR start "entryRuleParameterBoolean" + // InternalRos2Parser.g:3921:1: entryRuleParameterBoolean returns [EObject current=null] : iv_ruleParameterBoolean= ruleParameterBoolean EOF ; + public final EObject entryRuleParameterBoolean() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterBoolean = null; + + + try { + // InternalRos2Parser.g:3921:57: (iv_ruleParameterBoolean= ruleParameterBoolean EOF ) + // InternalRos2Parser.g:3922:2: iv_ruleParameterBoolean= ruleParameterBoolean EOF + { + newCompositeNode(grammarAccess.getParameterBooleanRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterBoolean=ruleParameterBoolean(); + + state._fsp--; + + current =iv_ruleParameterBoolean; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterBoolean" + + + // $ANTLR start "ruleParameterBoolean" + // InternalRos2Parser.g:3928:1: ruleParameterBoolean returns [EObject current=null] : ( (lv_value_0_0= ruleboolean0 ) ) ; + public final EObject ruleParameterBoolean() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3934:2: ( ( (lv_value_0_0= ruleboolean0 ) ) ) + // InternalRos2Parser.g:3935:2: ( (lv_value_0_0= ruleboolean0 ) ) + { + // InternalRos2Parser.g:3935:2: ( (lv_value_0_0= ruleboolean0 ) ) + // InternalRos2Parser.g:3936:3: (lv_value_0_0= ruleboolean0 ) + { + // InternalRos2Parser.g:3936:3: (lv_value_0_0= ruleboolean0 ) + // InternalRos2Parser.g:3937:4: lv_value_0_0= ruleboolean0 + { + + newCompositeNode(grammarAccess.getParameterBooleanAccess().getValueBoolean0ParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleboolean0(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterBooleanRule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.boolean0"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterBoolean" + + + // $ANTLR start "entryRuleParameterStruct" + // InternalRos2Parser.g:3957:1: entryRuleParameterStruct returns [EObject current=null] : iv_ruleParameterStruct= ruleParameterStruct EOF ; + public final EObject entryRuleParameterStruct() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterStruct = null; + + + try { + // InternalRos2Parser.g:3957:56: (iv_ruleParameterStruct= ruleParameterStruct EOF ) + // InternalRos2Parser.g:3958:2: iv_ruleParameterStruct= ruleParameterStruct EOF + { + newCompositeNode(grammarAccess.getParameterStructRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterStruct=ruleParameterStruct(); + + state._fsp--; + + current =iv_ruleParameterStruct; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterStruct" + + + // $ANTLR start "ruleParameterStruct" + // InternalRos2Parser.g:3964:1: ruleParameterStruct returns [EObject current=null] : ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) ; + public final EObject ruleParameterStruct() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_7=null; + EObject lv_value_2_0 = null; + + EObject lv_value_5_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:3970:2: ( ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) ) + // InternalRos2Parser.g:3971:2: ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) + { + // InternalRos2Parser.g:3971:2: ( () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? ) + // InternalRos2Parser.g:3972:3: () (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? + { + // InternalRos2Parser.g:3972:3: () + // InternalRos2Parser.g:3973:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterStructAccess().getParameterStructAction_0(), + current); + + + } + + // InternalRos2Parser.g:3979:3: (otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket )? + int alt71=2; + int LA71_0 = input.LA(1); + + if ( (LA71_0==LeftSquareBracket) ) { + alt71=1; + } + switch (alt71) { + case 1 : + // InternalRos2Parser.g:3980:4: otherlv_1= LeftSquareBracket ( (lv_value_2_0= ruleParameterStructMember ) ) (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* otherlv_7= RightSquareBracket + { + otherlv_1=(Token)match(input,LeftSquareBracket,FOLLOW_57); + + newLeafNode(otherlv_1, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_0()); + + // InternalRos2Parser.g:3984:4: ( (lv_value_2_0= ruleParameterStructMember ) ) + // InternalRos2Parser.g:3985:5: (lv_value_2_0= ruleParameterStructMember ) + { + // InternalRos2Parser.g:3985:5: (lv_value_2_0= ruleParameterStructMember ) + // InternalRos2Parser.g:3986:6: lv_value_2_0= ruleParameterStructMember + { + + newCompositeNode(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_1_0()); + + pushFollow(FOLLOW_12); + lv_value_2_0=ruleParameterStructMember(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructRule()); + } + add( + current, + "value", + lv_value_2_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructMember"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:4003:4: (otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket )* + loop70: + do { + int alt70=2; + int LA70_0 = input.LA(1); + + if ( (LA70_0==Comma) ) { + alt70=1; + } + + + switch (alt70) { + case 1 : + // InternalRos2Parser.g:4004:5: otherlv_3= Comma otherlv_4= LeftSquareBracket ( (lv_value_5_0= ruleParameterStructMember ) ) otherlv_6= RightSquareBracket + { + otherlv_3=(Token)match(input,Comma,FOLLOW_10); + + newLeafNode(otherlv_3, grammarAccess.getParameterStructAccess().getCommaKeyword_1_2_0()); + + otherlv_4=(Token)match(input,LeftSquareBracket,FOLLOW_57); + + newLeafNode(otherlv_4, grammarAccess.getParameterStructAccess().getLeftSquareBracketKeyword_1_2_1()); + + // InternalRos2Parser.g:4012:5: ( (lv_value_5_0= ruleParameterStructMember ) ) + // InternalRos2Parser.g:4013:6: (lv_value_5_0= ruleParameterStructMember ) + { + // InternalRos2Parser.g:4013:6: (lv_value_5_0= ruleParameterStructMember ) + // InternalRos2Parser.g:4014:7: lv_value_5_0= ruleParameterStructMember + { + + newCompositeNode(grammarAccess.getParameterStructAccess().getValueParameterStructMemberParserRuleCall_1_2_2_0()); + + pushFollow(FOLLOW_58); + lv_value_5_0=ruleParameterStructMember(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructRule()); + } + add( + current, + "value", + lv_value_5_0, + "de.fraunhofer.ipa.ros.Ros.ParameterStructMember"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_6=(Token)match(input,RightSquareBracket,FOLLOW_12); + + newLeafNode(otherlv_6, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_2_3()); + + + } + break; + + default : + break loop70; + } + } while (true); + + otherlv_7=(Token)match(input,RightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_7, grammarAccess.getParameterStructAccess().getRightSquareBracketKeyword_1_3()); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterStruct" + + + // $ANTLR start "entryRuleParameterDate" + // InternalRos2Parser.g:4045:1: entryRuleParameterDate returns [EObject current=null] : iv_ruleParameterDate= ruleParameterDate EOF ; + public final EObject entryRuleParameterDate() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterDate = null; + + + try { + // InternalRos2Parser.g:4045:54: (iv_ruleParameterDate= ruleParameterDate EOF ) + // InternalRos2Parser.g:4046:2: iv_ruleParameterDate= ruleParameterDate EOF + { + newCompositeNode(grammarAccess.getParameterDateRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterDate=ruleParameterDate(); + + state._fsp--; + + current =iv_ruleParameterDate; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterDate" + + + // $ANTLR start "ruleParameterDate" + // InternalRos2Parser.g:4052:1: ruleParameterDate returns [EObject current=null] : ( (lv_value_0_0= ruleDateTime0 ) ) ; + public final EObject ruleParameterDate() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:4058:2: ( ( (lv_value_0_0= ruleDateTime0 ) ) ) + // InternalRos2Parser.g:4059:2: ( (lv_value_0_0= ruleDateTime0 ) ) + { + // InternalRos2Parser.g:4059:2: ( (lv_value_0_0= ruleDateTime0 ) ) + // InternalRos2Parser.g:4060:3: (lv_value_0_0= ruleDateTime0 ) + { + // InternalRos2Parser.g:4060:3: (lv_value_0_0= ruleDateTime0 ) + // InternalRos2Parser.g:4061:4: lv_value_0_0= ruleDateTime0 + { + + newCompositeNode(grammarAccess.getParameterDateAccess().getValueDateTime0ParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleDateTime0(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterDateRule()); + } + set( + current, + "value", + lv_value_0_0, + "de.fraunhofer.ipa.ros.Ros.DateTime0"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterDate" + + + // $ANTLR start "entryRuleParameterStructMember" + // InternalRos2Parser.g:4081:1: entryRuleParameterStructMember returns [EObject current=null] : iv_ruleParameterStructMember= ruleParameterStructMember EOF ; + public final EObject entryRuleParameterStructMember() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterStructMember = null; + + + try { + // InternalRos2Parser.g:4081:62: (iv_ruleParameterStructMember= ruleParameterStructMember EOF ) + // InternalRos2Parser.g:4082:2: iv_ruleParameterStructMember= ruleParameterStructMember EOF + { + newCompositeNode(grammarAccess.getParameterStructMemberRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterStructMember=ruleParameterStructMember(); + + state._fsp--; + + current =iv_ruleParameterStructMember; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterStructMember" + + + // $ANTLR start "ruleParameterStructMember" + // InternalRos2Parser.g:4088:1: ruleParameterStructMember returns [EObject current=null] : (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) ; + public final EObject ruleParameterStructMember() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token this_END_5=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_value_4_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:4094:2: ( (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) ) + // InternalRos2Parser.g:4095:2: (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) + { + // InternalRos2Parser.g:4095:2: (otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END ) + // InternalRos2Parser.g:4096:3: otherlv_0= ParameterStructMember ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_value_4_0= ruleParameterValue ) ) this_END_5= RULE_END + { + otherlv_0=(Token)match(input,ParameterStructMember,FOLLOW_6); + + newLeafNode(otherlv_0, grammarAccess.getParameterStructMemberAccess().getParameterStructMemberKeyword_0()); + + // InternalRos2Parser.g:4100:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos2Parser.g:4101:4: (lv_name_1_0= ruleEString ) + { + // InternalRos2Parser.g:4101:4: (lv_name_1_0= ruleEString ) + // InternalRos2Parser.g:4102:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getParameterStructMemberAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructMemberRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getParameterStructMemberAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_55); + + newLeafNode(this_BEGIN_3, grammarAccess.getParameterStructMemberAccess().getBEGINTerminalRuleCall_3()); + + // InternalRos2Parser.g:4127:3: ( (lv_value_4_0= ruleParameterValue ) ) + // InternalRos2Parser.g:4128:4: (lv_value_4_0= ruleParameterValue ) + { + // InternalRos2Parser.g:4128:4: (lv_value_4_0= ruleParameterValue ) + // InternalRos2Parser.g:4129:5: lv_value_4_0= ruleParameterValue + { + + newCompositeNode(grammarAccess.getParameterStructMemberAccess().getValueParameterValueParserRuleCall_4_0()); + + pushFollow(FOLLOW_13); + lv_value_4_0=ruleParameterValue(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructMemberRule()); + } + set( + current, + "value", + lv_value_4_0, + "de.fraunhofer.ipa.ros.Ros.ParameterValue"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_5=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_5, grammarAccess.getParameterStructMemberAccess().getENDTerminalRuleCall_5()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterStructMember" + + + // $ANTLR start "entryRuleParameterStructTypeMember" + // InternalRos2Parser.g:4154:1: entryRuleParameterStructTypeMember returns [EObject current=null] : iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF ; + public final EObject entryRuleParameterStructTypeMember() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameterStructTypeMember = null; + + + try { + // InternalRos2Parser.g:4154:66: (iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF ) + // InternalRos2Parser.g:4155:2: iv_ruleParameterStructTypeMember= ruleParameterStructTypeMember EOF + { + newCompositeNode(grammarAccess.getParameterStructTypeMemberRule()); + pushFollow(FOLLOW_1); + iv_ruleParameterStructTypeMember=ruleParameterStructTypeMember(); + + state._fsp--; + + current =iv_ruleParameterStructTypeMember; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameterStructTypeMember" + + + // $ANTLR start "ruleParameterStructTypeMember" + // InternalRos2Parser.g:4161:1: ruleParameterStructTypeMember returns [EObject current=null] : ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) ; + public final EObject ruleParameterStructTypeMember() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_name_0_0 = null; + + EObject lv_type_1_0 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:4167:2: ( ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) ) + // InternalRos2Parser.g:4168:2: ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) + { + // InternalRos2Parser.g:4168:2: ( ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) ) + // InternalRos2Parser.g:4169:3: ( (lv_name_0_0= ruleEString ) ) ( (lv_type_1_0= ruleParameterType ) ) + { + // InternalRos2Parser.g:4169:3: ( (lv_name_0_0= ruleEString ) ) + // InternalRos2Parser.g:4170:4: (lv_name_0_0= ruleEString ) + { + // InternalRos2Parser.g:4170:4: (lv_name_0_0= ruleEString ) + // InternalRos2Parser.g:4171:5: lv_name_0_0= ruleEString + { + + newCompositeNode(grammarAccess.getParameterStructTypeMemberAccess().getNameEStringParserRuleCall_0_0()); + + pushFollow(FOLLOW_26); + lv_name_0_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructTypeMemberRule()); + } + set( + current, + "name", + lv_name_0_0, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:4188:3: ( (lv_type_1_0= ruleParameterType ) ) + // InternalRos2Parser.g:4189:4: (lv_type_1_0= ruleParameterType ) + { + // InternalRos2Parser.g:4189:4: (lv_type_1_0= ruleParameterType ) + // InternalRos2Parser.g:4190:5: lv_type_1_0= ruleParameterType + { + + newCompositeNode(grammarAccess.getParameterStructTypeMemberAccess().getTypeParameterTypeParserRuleCall_1_0()); + + pushFollow(FOLLOW_2); + lv_type_1_0=ruleParameterType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterStructTypeMemberRule()); + } + set( + current, + "type", + lv_type_1_0, + "de.fraunhofer.ipa.ros.Ros.ParameterType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameterStructTypeMember" + + + // $ANTLR start "entryRuleBase64Binary" + // InternalRos2Parser.g:4211:1: entryRuleBase64Binary returns [String current=null] : iv_ruleBase64Binary= ruleBase64Binary EOF ; + public final String entryRuleBase64Binary() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleBase64Binary = null; + + + try { + // InternalRos2Parser.g:4211:52: (iv_ruleBase64Binary= ruleBase64Binary EOF ) + // InternalRos2Parser.g:4212:2: iv_ruleBase64Binary= ruleBase64Binary EOF + { + newCompositeNode(grammarAccess.getBase64BinaryRule()); + pushFollow(FOLLOW_1); + iv_ruleBase64Binary=ruleBase64Binary(); + + state._fsp--; + + current =iv_ruleBase64Binary.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleBase64Binary" + + + // $ANTLR start "ruleBase64Binary" + // InternalRos2Parser.g:4218:1: ruleBase64Binary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_BINARY_0= RULE_BINARY ; + public final AntlrDatatypeRuleToken ruleBase64Binary() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_BINARY_0=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4224:2: (this_BINARY_0= RULE_BINARY ) + // InternalRos2Parser.g:4225:2: this_BINARY_0= RULE_BINARY + { + this_BINARY_0=(Token)match(input,RULE_BINARY,FOLLOW_2); + + current.merge(this_BINARY_0); + + + newLeafNode(this_BINARY_0, grammarAccess.getBase64BinaryAccess().getBINARYTerminalRuleCall()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleBase64Binary" + + + // $ANTLR start "entryRuleboolean0" + // InternalRos2Parser.g:4235:1: entryRuleboolean0 returns [String current=null] : iv_ruleboolean0= ruleboolean0 EOF ; + public final String entryRuleboolean0() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleboolean0 = null; + + + try { + // InternalRos2Parser.g:4235:48: (iv_ruleboolean0= ruleboolean0 EOF ) + // InternalRos2Parser.g:4236:2: iv_ruleboolean0= ruleboolean0 EOF + { + newCompositeNode(grammarAccess.getBoolean0Rule()); + pushFollow(FOLLOW_1); + iv_ruleboolean0=ruleboolean0(); + + state._fsp--; + + current =iv_ruleboolean0.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleboolean0" + + + // $ANTLR start "ruleboolean0" + // InternalRos2Parser.g:4242:1: ruleboolean0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_BOOLEAN_0= RULE_BOOLEAN ; + public final AntlrDatatypeRuleToken ruleboolean0() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_BOOLEAN_0=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4248:2: (this_BOOLEAN_0= RULE_BOOLEAN ) + // InternalRos2Parser.g:4249:2: this_BOOLEAN_0= RULE_BOOLEAN + { + this_BOOLEAN_0=(Token)match(input,RULE_BOOLEAN,FOLLOW_2); + + current.merge(this_BOOLEAN_0); + + + newLeafNode(this_BOOLEAN_0, grammarAccess.getBoolean0Access().getBOOLEANTerminalRuleCall()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleboolean0" + + + // $ANTLR start "entryRuleDouble0" + // InternalRos2Parser.g:4259:1: entryRuleDouble0 returns [String current=null] : iv_ruleDouble0= ruleDouble0 EOF ; + public final String entryRuleDouble0() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleDouble0 = null; + + + try { + // InternalRos2Parser.g:4259:47: (iv_ruleDouble0= ruleDouble0 EOF ) + // InternalRos2Parser.g:4260:2: iv_ruleDouble0= ruleDouble0 EOF + { + newCompositeNode(grammarAccess.getDouble0Rule()); + pushFollow(FOLLOW_1); + iv_ruleDouble0=ruleDouble0(); + + state._fsp--; + + current =iv_ruleDouble0.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleDouble0" + + + // $ANTLR start "ruleDouble0" + // InternalRos2Parser.g:4266:1: ruleDouble0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DOUBLE_0= RULE_DOUBLE ; + public final AntlrDatatypeRuleToken ruleDouble0() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_DOUBLE_0=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4272:2: (this_DOUBLE_0= RULE_DOUBLE ) + // InternalRos2Parser.g:4273:2: this_DOUBLE_0= RULE_DOUBLE + { + this_DOUBLE_0=(Token)match(input,RULE_DOUBLE,FOLLOW_2); + + current.merge(this_DOUBLE_0); + + + newLeafNode(this_DOUBLE_0, grammarAccess.getDouble0Access().getDOUBLETerminalRuleCall()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleDouble0" + + + // $ANTLR start "entryRuleInteger0" + // InternalRos2Parser.g:4283:1: entryRuleInteger0 returns [String current=null] : iv_ruleInteger0= ruleInteger0 EOF ; + public final String entryRuleInteger0() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleInteger0 = null; + + + try { + // InternalRos2Parser.g:4283:48: (iv_ruleInteger0= ruleInteger0 EOF ) + // InternalRos2Parser.g:4284:2: iv_ruleInteger0= ruleInteger0 EOF + { + newCompositeNode(grammarAccess.getInteger0Rule()); + pushFollow(FOLLOW_1); + iv_ruleInteger0=ruleInteger0(); + + state._fsp--; + + current =iv_ruleInteger0.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleInteger0" + + + // $ANTLR start "ruleInteger0" + // InternalRos2Parser.g:4290:1: ruleInteger0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DECINT_0= RULE_DECINT ; + public final AntlrDatatypeRuleToken ruleInteger0() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_DECINT_0=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4296:2: (this_DECINT_0= RULE_DECINT ) + // InternalRos2Parser.g:4297:2: this_DECINT_0= RULE_DECINT + { + this_DECINT_0=(Token)match(input,RULE_DECINT,FOLLOW_2); + + current.merge(this_DECINT_0); + + + newLeafNode(this_DECINT_0, grammarAccess.getInteger0Access().getDECINTTerminalRuleCall()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleInteger0" + + + // $ANTLR start "entryRuleDateTime0" + // InternalRos2Parser.g:4307:1: entryRuleDateTime0 returns [String current=null] : iv_ruleDateTime0= ruleDateTime0 EOF ; + public final String entryRuleDateTime0() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleDateTime0 = null; + + + try { + // InternalRos2Parser.g:4307:49: (iv_ruleDateTime0= ruleDateTime0 EOF ) + // InternalRos2Parser.g:4308:2: iv_ruleDateTime0= ruleDateTime0 EOF + { + newCompositeNode(grammarAccess.getDateTime0Rule()); + pushFollow(FOLLOW_1); + iv_ruleDateTime0=ruleDateTime0(); + + state._fsp--; + + current =iv_ruleDateTime0.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleDateTime0" + + + // $ANTLR start "ruleDateTime0" + // InternalRos2Parser.g:4314:1: ruleDateTime0 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_DATE_TIME_0= RULE_DATE_TIME ; + public final AntlrDatatypeRuleToken ruleDateTime0() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_DATE_TIME_0=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4320:2: (this_DATE_TIME_0= RULE_DATE_TIME ) + // InternalRos2Parser.g:4321:2: this_DATE_TIME_0= RULE_DATE_TIME + { + this_DATE_TIME_0=(Token)match(input,RULE_DATE_TIME,FOLLOW_2); + + current.merge(this_DATE_TIME_0); + + + newLeafNode(this_DATE_TIME_0, grammarAccess.getDateTime0Access().getDATE_TIMETerminalRuleCall()); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleDateTime0" + + + // $ANTLR start "entryRuleMessagePart" + // InternalRos2Parser.g:4331:1: entryRuleMessagePart returns [EObject current=null] : iv_ruleMessagePart= ruleMessagePart EOF ; + public final EObject entryRuleMessagePart() throws RecognitionException { + EObject current = null; + + EObject iv_ruleMessagePart = null; + + + try { + // InternalRos2Parser.g:4331:52: (iv_ruleMessagePart= ruleMessagePart EOF ) + // InternalRos2Parser.g:4332:2: iv_ruleMessagePart= ruleMessagePart EOF + { + newCompositeNode(grammarAccess.getMessagePartRule()); + pushFollow(FOLLOW_1); + iv_ruleMessagePart=ruleMessagePart(); + + state._fsp--; + + current =iv_ruleMessagePart; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleMessagePart" + + + // $ANTLR start "ruleMessagePart" + // InternalRos2Parser.g:4338:1: ruleMessagePart returns [EObject current=null] : ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) ; + public final EObject ruleMessagePart() throws RecognitionException { + EObject current = null; + + Token lv_Data_1_2=null; + EObject lv_Type_0_0 = null; + + AntlrDatatypeRuleToken lv_Data_1_1 = null; + + AntlrDatatypeRuleToken lv_Data_1_3 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:4344:2: ( ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) ) + // InternalRos2Parser.g:4345:2: ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) + { + // InternalRos2Parser.g:4345:2: ( ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) ) + // InternalRos2Parser.g:4346:3: ( (lv_Type_0_0= ruleAbstractType ) ) ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) + { + // InternalRos2Parser.g:4346:3: ( (lv_Type_0_0= ruleAbstractType ) ) + // InternalRos2Parser.g:4347:4: (lv_Type_0_0= ruleAbstractType ) + { + // InternalRos2Parser.g:4347:4: (lv_Type_0_0= ruleAbstractType ) + // InternalRos2Parser.g:4348:5: lv_Type_0_0= ruleAbstractType + { + + newCompositeNode(grammarAccess.getMessagePartAccess().getTypeAbstractTypeParserRuleCall_0_0()); + + pushFollow(FOLLOW_59); + lv_Type_0_0=ruleAbstractType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + current, + "Type", + lv_Type_0_0, + "de.fraunhofer.ipa.ros.Ros.AbstractType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos2Parser.g:4365:3: ( ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) ) + // InternalRos2Parser.g:4366:4: ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) + { + // InternalRos2Parser.g:4366:4: ( (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) ) + // InternalRos2Parser.g:4367:5: (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) + { + // InternalRos2Parser.g:4367:5: (lv_Data_1_1= ruleKEYWORD | lv_Data_1_2= RULE_MESSAGE_ASIGMENT | lv_Data_1_3= ruleEString ) + int alt72=3; + switch ( input.LA(1) ) { + case Duration: + case Feedback: + case Message: + case Service: + case Action: + case Result: + case Value: + case Goal: + case Name: + case Time: + case Type: + { + alt72=1; + } + break; + case RULE_MESSAGE_ASIGMENT: + { + alt72=2; + } + break; + case RULE_ID: + case RULE_STRING: + { + alt72=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 72, 0, input); + + throw nvae; + } + + switch (alt72) { + case 1 : + // InternalRos2Parser.g:4368:6: lv_Data_1_1= ruleKEYWORD + { + + newCompositeNode(grammarAccess.getMessagePartAccess().getDataKEYWORDParserRuleCall_1_0_0()); + + pushFollow(FOLLOW_2); + lv_Data_1_1=ruleKEYWORD(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + current, + "Data", + lv_Data_1_1, + "de.fraunhofer.ipa.ros.Ros.KEYWORD"); + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos2Parser.g:4384:6: lv_Data_1_2= RULE_MESSAGE_ASIGMENT + { + lv_Data_1_2=(Token)match(input,RULE_MESSAGE_ASIGMENT,FOLLOW_2); + + newLeafNode(lv_Data_1_2, grammarAccess.getMessagePartAccess().getDataMESSAGE_ASIGMENTTerminalRuleCall_1_0_1()); + + + if (current==null) { + current = createModelElement(grammarAccess.getMessagePartRule()); + } + setWithLastConsumed( + current, + "Data", + lv_Data_1_2, + "de.fraunhofer.ipa.ros.Ros.MESSAGE_ASIGMENT"); + + + } + break; + case 3 : + // InternalRos2Parser.g:4399:6: lv_Data_1_3= ruleEString + { + + newCompositeNode(grammarAccess.getMessagePartAccess().getDataEStringParserRuleCall_1_0_2()); + + pushFollow(FOLLOW_2); + lv_Data_1_3=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getMessagePartRule()); + } + set( + current, + "Data", + lv_Data_1_3, + "de.fraunhofer.ipa.ros.Ros.EString"); + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMessagePart" + + + // $ANTLR start "entryRuleAbstractType" + // InternalRos2Parser.g:4421:1: entryRuleAbstractType returns [EObject current=null] : iv_ruleAbstractType= ruleAbstractType EOF ; + public final EObject entryRuleAbstractType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleAbstractType = null; + + + try { + // InternalRos2Parser.g:4421:53: (iv_ruleAbstractType= ruleAbstractType EOF ) + // InternalRos2Parser.g:4422:2: iv_ruleAbstractType= ruleAbstractType EOF + { + newCompositeNode(grammarAccess.getAbstractTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleAbstractType=ruleAbstractType(); + + state._fsp--; + + current =iv_ruleAbstractType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleAbstractType" + + + // $ANTLR start "ruleAbstractType" + // InternalRos2Parser.g:4428:1: ruleAbstractType returns [EObject current=null] : (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) ; + public final EObject ruleAbstractType() throws RecognitionException { + EObject current = null; + + EObject this_bool_0 = null; + + EObject this_int8_1 = null; + + EObject this_uint8_2 = null; + + EObject this_int16_3 = null; + + EObject this_uint16_4 = null; + + EObject this_int32_5 = null; + + EObject this_uint32_6 = null; + + EObject this_int64_7 = null; + + EObject this_uint64_8 = null; + + EObject this_float32_9 = null; + + EObject this_float64_10 = null; + + EObject this_string0_11 = null; + + EObject this_byte_12 = null; + + EObject this_time_13 = null; + + EObject this_duration_14 = null; + + EObject this_Header_15 = null; + + EObject this_boolArray_16 = null; + + EObject this_int8Array_17 = null; + + EObject this_uint8Array_18 = null; + + EObject this_int16Array_19 = null; + + EObject this_uint16Array_20 = null; + + EObject this_int32Array_21 = null; + + EObject this_uint32Array_22 = null; + + EObject this_int64Array_23 = null; + + EObject this_uint64Array_24 = null; + + EObject this_float32Array_25 = null; + + EObject this_float64Array_26 = null; + + EObject this_string0Array_27 = null; + + EObject this_byteArray_28 = null; + + EObject this_TopicSpecRef_29 = null; + + EObject this_ArrayTopicSpecRef_30 = null; + + + + enterRule(); + + try { + // InternalRos2Parser.g:4434:2: ( (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) ) + // InternalRos2Parser.g:4435:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) + { + // InternalRos2Parser.g:4435:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef ) + int alt73=31; + alt73 = dfa73.predict(input); + switch (alt73) { + case 1 : + // InternalRos2Parser.g:4436:3: this_bool_0= rulebool + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getBoolParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_bool_0=rulebool(); + + state._fsp--; + + + current = this_bool_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos2Parser.g:4445:3: this_int8_1= ruleint8 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt8ParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_int8_1=ruleint8(); + + state._fsp--; + + + current = this_int8_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalRos2Parser.g:4454:3: this_uint8_2= ruleuint8 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint8ParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_uint8_2=ruleuint8(); + + state._fsp--; + + + current = this_uint8_2; + afterParserOrEnumRuleCall(); + + + } + break; + case 4 : + // InternalRos2Parser.g:4463:3: this_int16_3= ruleint16 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt16ParserRuleCall_3()); + + pushFollow(FOLLOW_2); + this_int16_3=ruleint16(); + + state._fsp--; + + + current = this_int16_3; + afterParserOrEnumRuleCall(); + + + } + break; + case 5 : + // InternalRos2Parser.g:4472:3: this_uint16_4= ruleuint16 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint16ParserRuleCall_4()); + + pushFollow(FOLLOW_2); + this_uint16_4=ruleuint16(); + + state._fsp--; + + + current = this_uint16_4; + afterParserOrEnumRuleCall(); + + + } + break; + case 6 : + // InternalRos2Parser.g:4481:3: this_int32_5= ruleint32 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt32ParserRuleCall_5()); + + pushFollow(FOLLOW_2); + this_int32_5=ruleint32(); + + state._fsp--; + + + current = this_int32_5; + afterParserOrEnumRuleCall(); + + + } + break; + case 7 : + // InternalRos2Parser.g:4490:3: this_uint32_6= ruleuint32 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint32ParserRuleCall_6()); + + pushFollow(FOLLOW_2); + this_uint32_6=ruleuint32(); + + state._fsp--; + + + current = this_uint32_6; + afterParserOrEnumRuleCall(); + + + } + break; + case 8 : + // InternalRos2Parser.g:4499:3: this_int64_7= ruleint64 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt64ParserRuleCall_7()); + + pushFollow(FOLLOW_2); + this_int64_7=ruleint64(); + + state._fsp--; + + + current = this_int64_7; + afterParserOrEnumRuleCall(); + + + } + break; + case 9 : + // InternalRos2Parser.g:4508:3: this_uint64_8= ruleuint64 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint64ParserRuleCall_8()); + + pushFollow(FOLLOW_2); + this_uint64_8=ruleuint64(); + + state._fsp--; + + + current = this_uint64_8; + afterParserOrEnumRuleCall(); + + + } + break; + case 10 : + // InternalRos2Parser.g:4517:3: this_float32_9= rulefloat32 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat32ParserRuleCall_9()); + + pushFollow(FOLLOW_2); + this_float32_9=rulefloat32(); + + state._fsp--; + + + current = this_float32_9; + afterParserOrEnumRuleCall(); + + + } + break; + case 11 : + // InternalRos2Parser.g:4526:3: this_float64_10= rulefloat64 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat64ParserRuleCall_10()); + + pushFollow(FOLLOW_2); + this_float64_10=rulefloat64(); + + state._fsp--; + + + current = this_float64_10; + afterParserOrEnumRuleCall(); + + + } + break; + case 12 : + // InternalRos2Parser.g:4535:3: this_string0_11= rulestring0 + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getString0ParserRuleCall_11()); + + pushFollow(FOLLOW_2); + this_string0_11=rulestring0(); + + state._fsp--; + + + current = this_string0_11; + afterParserOrEnumRuleCall(); + + + } + break; + case 13 : + // InternalRos2Parser.g:4544:3: this_byte_12= rulebyte + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getByteParserRuleCall_12()); + + pushFollow(FOLLOW_2); + this_byte_12=rulebyte(); + + state._fsp--; + + + current = this_byte_12; + afterParserOrEnumRuleCall(); + + + } + break; + case 14 : + // InternalRos2Parser.g:4553:3: this_time_13= ruletime + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getTimeParserRuleCall_13()); + + pushFollow(FOLLOW_2); + this_time_13=ruletime(); + + state._fsp--; + + + current = this_time_13; + afterParserOrEnumRuleCall(); + + + } + break; + case 15 : + // InternalRos2Parser.g:4562:3: this_duration_14= ruleduration + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getDurationParserRuleCall_14()); + + pushFollow(FOLLOW_2); + this_duration_14=ruleduration(); + + state._fsp--; + + + current = this_duration_14; + afterParserOrEnumRuleCall(); + + + } + break; + case 16 : + // InternalRos2Parser.g:4571:3: this_Header_15= ruleHeader + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getHeaderParserRuleCall_15()); + + pushFollow(FOLLOW_2); + this_Header_15=ruleHeader(); + + state._fsp--; + + + current = this_Header_15; + afterParserOrEnumRuleCall(); + + + } + break; + case 17 : + // InternalRos2Parser.g:4580:3: this_boolArray_16= ruleboolArray + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getBoolArrayParserRuleCall_16()); + + pushFollow(FOLLOW_2); + this_boolArray_16=ruleboolArray(); + + state._fsp--; + + + current = this_boolArray_16; + afterParserOrEnumRuleCall(); + + + } + break; + case 18 : + // InternalRos2Parser.g:4589:3: this_int8Array_17= ruleint8Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt8ArrayParserRuleCall_17()); + + pushFollow(FOLLOW_2); + this_int8Array_17=ruleint8Array(); + + state._fsp--; + + + current = this_int8Array_17; + afterParserOrEnumRuleCall(); + + + } + break; + case 19 : + // InternalRos2Parser.g:4598:3: this_uint8Array_18= ruleuint8Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint8ArrayParserRuleCall_18()); + + pushFollow(FOLLOW_2); + this_uint8Array_18=ruleuint8Array(); + + state._fsp--; + + + current = this_uint8Array_18; + afterParserOrEnumRuleCall(); + + + } + break; + case 20 : + // InternalRos2Parser.g:4607:3: this_int16Array_19= ruleint16Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt16ArrayParserRuleCall_19()); + + pushFollow(FOLLOW_2); + this_int16Array_19=ruleint16Array(); + + state._fsp--; + + + current = this_int16Array_19; + afterParserOrEnumRuleCall(); + + + } + break; + case 21 : + // InternalRos2Parser.g:4616:3: this_uint16Array_20= ruleuint16Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint16ArrayParserRuleCall_20()); + + pushFollow(FOLLOW_2); + this_uint16Array_20=ruleuint16Array(); + + state._fsp--; + + + current = this_uint16Array_20; + afterParserOrEnumRuleCall(); + + + } + break; + case 22 : + // InternalRos2Parser.g:4625:3: this_int32Array_21= ruleint32Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt32ArrayParserRuleCall_21()); + + pushFollow(FOLLOW_2); + this_int32Array_21=ruleint32Array(); + + state._fsp--; + + + current = this_int32Array_21; + afterParserOrEnumRuleCall(); + + + } + break; + case 23 : + // InternalRos2Parser.g:4634:3: this_uint32Array_22= ruleuint32Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint32ArrayParserRuleCall_22()); + + pushFollow(FOLLOW_2); + this_uint32Array_22=ruleuint32Array(); + + state._fsp--; + + + current = this_uint32Array_22; + afterParserOrEnumRuleCall(); + + + } + break; + case 24 : + // InternalRos2Parser.g:4643:3: this_int64Array_23= ruleint64Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getInt64ArrayParserRuleCall_23()); + + pushFollow(FOLLOW_2); + this_int64Array_23=ruleint64Array(); + + state._fsp--; + + + current = this_int64Array_23; + afterParserOrEnumRuleCall(); + + + } + break; + case 25 : + // InternalRos2Parser.g:4652:3: this_uint64Array_24= ruleuint64Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getUint64ArrayParserRuleCall_24()); + + pushFollow(FOLLOW_2); + this_uint64Array_24=ruleuint64Array(); + + state._fsp--; + + + current = this_uint64Array_24; + afterParserOrEnumRuleCall(); + + + } + break; + case 26 : + // InternalRos2Parser.g:4661:3: this_float32Array_25= rulefloat32Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat32ArrayParserRuleCall_25()); + + pushFollow(FOLLOW_2); + this_float32Array_25=rulefloat32Array(); + + state._fsp--; + + + current = this_float32Array_25; + afterParserOrEnumRuleCall(); + + + } + break; + case 27 : + // InternalRos2Parser.g:4670:3: this_float64Array_26= rulefloat64Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getFloat64ArrayParserRuleCall_26()); + + pushFollow(FOLLOW_2); + this_float64Array_26=rulefloat64Array(); + + state._fsp--; + + + current = this_float64Array_26; + afterParserOrEnumRuleCall(); + + + } + break; + case 28 : + // InternalRos2Parser.g:4679:3: this_string0Array_27= rulestring0Array + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getString0ArrayParserRuleCall_27()); + + pushFollow(FOLLOW_2); + this_string0Array_27=rulestring0Array(); + + state._fsp--; + + + current = this_string0Array_27; + afterParserOrEnumRuleCall(); + + + } + break; + case 29 : + // InternalRos2Parser.g:4688:3: this_byteArray_28= rulebyteArray + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getByteArrayParserRuleCall_28()); + + pushFollow(FOLLOW_2); + this_byteArray_28=rulebyteArray(); + + state._fsp--; + + + current = this_byteArray_28; + afterParserOrEnumRuleCall(); + + + } + break; + case 30 : + // InternalRos2Parser.g:4697:3: this_TopicSpecRef_29= ruleTopicSpecRef + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getTopicSpecRefParserRuleCall_29()); + + pushFollow(FOLLOW_2); + this_TopicSpecRef_29=ruleTopicSpecRef(); + + state._fsp--; + + + current = this_TopicSpecRef_29; + afterParserOrEnumRuleCall(); + + + } + break; + case 31 : + // InternalRos2Parser.g:4706:3: this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef + { + + newCompositeNode(grammarAccess.getAbstractTypeAccess().getArrayTopicSpecRefParserRuleCall_30()); + + pushFollow(FOLLOW_2); + this_ArrayTopicSpecRef_30=ruleArrayTopicSpecRef(); + + state._fsp--; + + + current = this_ArrayTopicSpecRef_30; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleAbstractType" + + + // $ANTLR start "entryRulebool" + // InternalRos2Parser.g:4718:1: entryRulebool returns [EObject current=null] : iv_rulebool= rulebool EOF ; + public final EObject entryRulebool() throws RecognitionException { + EObject current = null; + + EObject iv_rulebool = null; + + + try { + // InternalRos2Parser.g:4718:45: (iv_rulebool= rulebool EOF ) + // InternalRos2Parser.g:4719:2: iv_rulebool= rulebool EOF + { + newCompositeNode(grammarAccess.getBoolRule()); + pushFollow(FOLLOW_1); + iv_rulebool=rulebool(); + + state._fsp--; + + current =iv_rulebool; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulebool" + + + // $ANTLR start "rulebool" + // InternalRos2Parser.g:4725:1: rulebool returns [EObject current=null] : ( () otherlv_1= Bool ) ; + public final EObject rulebool() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4731:2: ( ( () otherlv_1= Bool ) ) + // InternalRos2Parser.g:4732:2: ( () otherlv_1= Bool ) + { + // InternalRos2Parser.g:4732:2: ( () otherlv_1= Bool ) + // InternalRos2Parser.g:4733:3: () otherlv_1= Bool + { + // InternalRos2Parser.g:4733:3: () + // InternalRos2Parser.g:4734:4: + { + + current = forceCreateModelElement( + grammarAccess.getBoolAccess().getBoolAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Bool,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getBoolAccess().getBoolKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulebool" + + + // $ANTLR start "entryRuleint8" + // InternalRos2Parser.g:4748:1: entryRuleint8 returns [EObject current=null] : iv_ruleint8= ruleint8 EOF ; + public final EObject entryRuleint8() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint8 = null; + + + try { + // InternalRos2Parser.g:4748:45: (iv_ruleint8= ruleint8 EOF ) + // InternalRos2Parser.g:4749:2: iv_ruleint8= ruleint8 EOF + { + newCompositeNode(grammarAccess.getInt8Rule()); + pushFollow(FOLLOW_1); + iv_ruleint8=ruleint8(); + + state._fsp--; + + current =iv_ruleint8; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint8" + + + // $ANTLR start "ruleint8" + // InternalRos2Parser.g:4755:1: ruleint8 returns [EObject current=null] : ( () otherlv_1= Int8 ) ; + public final EObject ruleint8() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4761:2: ( ( () otherlv_1= Int8 ) ) + // InternalRos2Parser.g:4762:2: ( () otherlv_1= Int8 ) + { + // InternalRos2Parser.g:4762:2: ( () otherlv_1= Int8 ) + // InternalRos2Parser.g:4763:3: () otherlv_1= Int8 + { + // InternalRos2Parser.g:4763:3: () + // InternalRos2Parser.g:4764:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt8Access().getInt8Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int8,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt8Access().getInt8Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint8" + + + // $ANTLR start "entryRuleuint8" + // InternalRos2Parser.g:4778:1: entryRuleuint8 returns [EObject current=null] : iv_ruleuint8= ruleuint8 EOF ; + public final EObject entryRuleuint8() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint8 = null; + + + try { + // InternalRos2Parser.g:4778:46: (iv_ruleuint8= ruleuint8 EOF ) + // InternalRos2Parser.g:4779:2: iv_ruleuint8= ruleuint8 EOF + { + newCompositeNode(grammarAccess.getUint8Rule()); + pushFollow(FOLLOW_1); + iv_ruleuint8=ruleuint8(); + + state._fsp--; + + current =iv_ruleuint8; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint8" + + + // $ANTLR start "ruleuint8" + // InternalRos2Parser.g:4785:1: ruleuint8 returns [EObject current=null] : ( () otherlv_1= Uint8 ) ; + public final EObject ruleuint8() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4791:2: ( ( () otherlv_1= Uint8 ) ) + // InternalRos2Parser.g:4792:2: ( () otherlv_1= Uint8 ) + { + // InternalRos2Parser.g:4792:2: ( () otherlv_1= Uint8 ) + // InternalRos2Parser.g:4793:3: () otherlv_1= Uint8 + { + // InternalRos2Parser.g:4793:3: () + // InternalRos2Parser.g:4794:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint8Access().getUint8Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint8,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint8Access().getUint8Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint8" + + + // $ANTLR start "entryRuleint16" + // InternalRos2Parser.g:4808:1: entryRuleint16 returns [EObject current=null] : iv_ruleint16= ruleint16 EOF ; + public final EObject entryRuleint16() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint16 = null; + + + try { + // InternalRos2Parser.g:4808:46: (iv_ruleint16= ruleint16 EOF ) + // InternalRos2Parser.g:4809:2: iv_ruleint16= ruleint16 EOF + { + newCompositeNode(grammarAccess.getInt16Rule()); + pushFollow(FOLLOW_1); + iv_ruleint16=ruleint16(); + + state._fsp--; + + current =iv_ruleint16; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint16" + + + // $ANTLR start "ruleint16" + // InternalRos2Parser.g:4815:1: ruleint16 returns [EObject current=null] : ( () otherlv_1= Int16 ) ; + public final EObject ruleint16() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4821:2: ( ( () otherlv_1= Int16 ) ) + // InternalRos2Parser.g:4822:2: ( () otherlv_1= Int16 ) + { + // InternalRos2Parser.g:4822:2: ( () otherlv_1= Int16 ) + // InternalRos2Parser.g:4823:3: () otherlv_1= Int16 + { + // InternalRos2Parser.g:4823:3: () + // InternalRos2Parser.g:4824:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt16Access().getInt16Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int16,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt16Access().getInt16Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint16" + + + // $ANTLR start "entryRuleuint16" + // InternalRos2Parser.g:4838:1: entryRuleuint16 returns [EObject current=null] : iv_ruleuint16= ruleuint16 EOF ; + public final EObject entryRuleuint16() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint16 = null; + + + try { + // InternalRos2Parser.g:4838:47: (iv_ruleuint16= ruleuint16 EOF ) + // InternalRos2Parser.g:4839:2: iv_ruleuint16= ruleuint16 EOF + { + newCompositeNode(grammarAccess.getUint16Rule()); + pushFollow(FOLLOW_1); + iv_ruleuint16=ruleuint16(); + + state._fsp--; + + current =iv_ruleuint16; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint16" + + + // $ANTLR start "ruleuint16" + // InternalRos2Parser.g:4845:1: ruleuint16 returns [EObject current=null] : ( () otherlv_1= Uint16 ) ; + public final EObject ruleuint16() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4851:2: ( ( () otherlv_1= Uint16 ) ) + // InternalRos2Parser.g:4852:2: ( () otherlv_1= Uint16 ) + { + // InternalRos2Parser.g:4852:2: ( () otherlv_1= Uint16 ) + // InternalRos2Parser.g:4853:3: () otherlv_1= Uint16 + { + // InternalRos2Parser.g:4853:3: () + // InternalRos2Parser.g:4854:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint16Access().getUint16Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint16,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint16Access().getUint16Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint16" + + + // $ANTLR start "entryRuleint32" + // InternalRos2Parser.g:4868:1: entryRuleint32 returns [EObject current=null] : iv_ruleint32= ruleint32 EOF ; + public final EObject entryRuleint32() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint32 = null; + + + try { + // InternalRos2Parser.g:4868:46: (iv_ruleint32= ruleint32 EOF ) + // InternalRos2Parser.g:4869:2: iv_ruleint32= ruleint32 EOF + { + newCompositeNode(grammarAccess.getInt32Rule()); + pushFollow(FOLLOW_1); + iv_ruleint32=ruleint32(); + + state._fsp--; + + current =iv_ruleint32; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint32" + + + // $ANTLR start "ruleint32" + // InternalRos2Parser.g:4875:1: ruleint32 returns [EObject current=null] : ( () otherlv_1= Int32 ) ; + public final EObject ruleint32() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4881:2: ( ( () otherlv_1= Int32 ) ) + // InternalRos2Parser.g:4882:2: ( () otherlv_1= Int32 ) + { + // InternalRos2Parser.g:4882:2: ( () otherlv_1= Int32 ) + // InternalRos2Parser.g:4883:3: () otherlv_1= Int32 + { + // InternalRos2Parser.g:4883:3: () + // InternalRos2Parser.g:4884:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt32Access().getInt32Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int32,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt32Access().getInt32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint32" + + + // $ANTLR start "entryRuleuint32" + // InternalRos2Parser.g:4898:1: entryRuleuint32 returns [EObject current=null] : iv_ruleuint32= ruleuint32 EOF ; + public final EObject entryRuleuint32() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint32 = null; + + + try { + // InternalRos2Parser.g:4898:47: (iv_ruleuint32= ruleuint32 EOF ) + // InternalRos2Parser.g:4899:2: iv_ruleuint32= ruleuint32 EOF + { + newCompositeNode(grammarAccess.getUint32Rule()); + pushFollow(FOLLOW_1); + iv_ruleuint32=ruleuint32(); + + state._fsp--; + + current =iv_ruleuint32; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint32" + + + // $ANTLR start "ruleuint32" + // InternalRos2Parser.g:4905:1: ruleuint32 returns [EObject current=null] : ( () otherlv_1= Uint32 ) ; + public final EObject ruleuint32() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4911:2: ( ( () otherlv_1= Uint32 ) ) + // InternalRos2Parser.g:4912:2: ( () otherlv_1= Uint32 ) + { + // InternalRos2Parser.g:4912:2: ( () otherlv_1= Uint32 ) + // InternalRos2Parser.g:4913:3: () otherlv_1= Uint32 + { + // InternalRos2Parser.g:4913:3: () + // InternalRos2Parser.g:4914:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint32Access().getUint32Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint32,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint32Access().getUint32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint32" + + + // $ANTLR start "entryRuleint64" + // InternalRos2Parser.g:4928:1: entryRuleint64 returns [EObject current=null] : iv_ruleint64= ruleint64 EOF ; + public final EObject entryRuleint64() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint64 = null; + + + try { + // InternalRos2Parser.g:4928:46: (iv_ruleint64= ruleint64 EOF ) + // InternalRos2Parser.g:4929:2: iv_ruleint64= ruleint64 EOF + { + newCompositeNode(grammarAccess.getInt64Rule()); + pushFollow(FOLLOW_1); + iv_ruleint64=ruleint64(); + + state._fsp--; + + current =iv_ruleint64; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint64" + + + // $ANTLR start "ruleint64" + // InternalRos2Parser.g:4935:1: ruleint64 returns [EObject current=null] : ( () otherlv_1= Int64 ) ; + public final EObject ruleint64() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4941:2: ( ( () otherlv_1= Int64 ) ) + // InternalRos2Parser.g:4942:2: ( () otherlv_1= Int64 ) + { + // InternalRos2Parser.g:4942:2: ( () otherlv_1= Int64 ) + // InternalRos2Parser.g:4943:3: () otherlv_1= Int64 + { + // InternalRos2Parser.g:4943:3: () + // InternalRos2Parser.g:4944:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt64Access().getInt64Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int64,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt64Access().getInt64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint64" + + + // $ANTLR start "entryRuleuint64" + // InternalRos2Parser.g:4958:1: entryRuleuint64 returns [EObject current=null] : iv_ruleuint64= ruleuint64 EOF ; + public final EObject entryRuleuint64() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint64 = null; + + + try { + // InternalRos2Parser.g:4958:47: (iv_ruleuint64= ruleuint64 EOF ) + // InternalRos2Parser.g:4959:2: iv_ruleuint64= ruleuint64 EOF + { + newCompositeNode(grammarAccess.getUint64Rule()); + pushFollow(FOLLOW_1); + iv_ruleuint64=ruleuint64(); + + state._fsp--; + + current =iv_ruleuint64; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint64" + + + // $ANTLR start "ruleuint64" + // InternalRos2Parser.g:4965:1: ruleuint64 returns [EObject current=null] : ( () otherlv_1= Uint64 ) ; + public final EObject ruleuint64() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:4971:2: ( ( () otherlv_1= Uint64 ) ) + // InternalRos2Parser.g:4972:2: ( () otherlv_1= Uint64 ) + { + // InternalRos2Parser.g:4972:2: ( () otherlv_1= Uint64 ) + // InternalRos2Parser.g:4973:3: () otherlv_1= Uint64 + { + // InternalRos2Parser.g:4973:3: () + // InternalRos2Parser.g:4974:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint64Access().getUint64Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint64,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint64Access().getUint64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint64" + + + // $ANTLR start "entryRulefloat32" + // InternalRos2Parser.g:4988:1: entryRulefloat32 returns [EObject current=null] : iv_rulefloat32= rulefloat32 EOF ; + public final EObject entryRulefloat32() throws RecognitionException { + EObject current = null; + + EObject iv_rulefloat32 = null; + + + try { + // InternalRos2Parser.g:4988:48: (iv_rulefloat32= rulefloat32 EOF ) + // InternalRos2Parser.g:4989:2: iv_rulefloat32= rulefloat32 EOF + { + newCompositeNode(grammarAccess.getFloat32Rule()); + pushFollow(FOLLOW_1); + iv_rulefloat32=rulefloat32(); + + state._fsp--; + + current =iv_rulefloat32; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulefloat32" + + + // $ANTLR start "rulefloat32" + // InternalRos2Parser.g:4995:1: rulefloat32 returns [EObject current=null] : ( () otherlv_1= Float32 ) ; + public final EObject rulefloat32() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5001:2: ( ( () otherlv_1= Float32 ) ) + // InternalRos2Parser.g:5002:2: ( () otherlv_1= Float32 ) + { + // InternalRos2Parser.g:5002:2: ( () otherlv_1= Float32 ) + // InternalRos2Parser.g:5003:3: () otherlv_1= Float32 + { + // InternalRos2Parser.g:5003:3: () + // InternalRos2Parser.g:5004:4: + { + + current = forceCreateModelElement( + grammarAccess.getFloat32Access().getFloat32Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Float32,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getFloat32Access().getFloat32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulefloat32" + + + // $ANTLR start "entryRulefloat64" + // InternalRos2Parser.g:5018:1: entryRulefloat64 returns [EObject current=null] : iv_rulefloat64= rulefloat64 EOF ; + public final EObject entryRulefloat64() throws RecognitionException { + EObject current = null; + + EObject iv_rulefloat64 = null; + + + try { + // InternalRos2Parser.g:5018:48: (iv_rulefloat64= rulefloat64 EOF ) + // InternalRos2Parser.g:5019:2: iv_rulefloat64= rulefloat64 EOF + { + newCompositeNode(grammarAccess.getFloat64Rule()); + pushFollow(FOLLOW_1); + iv_rulefloat64=rulefloat64(); + + state._fsp--; + + current =iv_rulefloat64; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulefloat64" + + + // $ANTLR start "rulefloat64" + // InternalRos2Parser.g:5025:1: rulefloat64 returns [EObject current=null] : ( () otherlv_1= Float64 ) ; + public final EObject rulefloat64() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5031:2: ( ( () otherlv_1= Float64 ) ) + // InternalRos2Parser.g:5032:2: ( () otherlv_1= Float64 ) + { + // InternalRos2Parser.g:5032:2: ( () otherlv_1= Float64 ) + // InternalRos2Parser.g:5033:3: () otherlv_1= Float64 + { + // InternalRos2Parser.g:5033:3: () + // InternalRos2Parser.g:5034:4: + { + + current = forceCreateModelElement( + grammarAccess.getFloat64Access().getFloat64Action_0(), + current); + + + } + + otherlv_1=(Token)match(input,Float64,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getFloat64Access().getFloat64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulefloat64" + + + // $ANTLR start "entryRulestring0" + // InternalRos2Parser.g:5048:1: entryRulestring0 returns [EObject current=null] : iv_rulestring0= rulestring0 EOF ; + public final EObject entryRulestring0() throws RecognitionException { + EObject current = null; + + EObject iv_rulestring0 = null; + + + try { + // InternalRos2Parser.g:5048:48: (iv_rulestring0= rulestring0 EOF ) + // InternalRos2Parser.g:5049:2: iv_rulestring0= rulestring0 EOF + { + newCompositeNode(grammarAccess.getString0Rule()); + pushFollow(FOLLOW_1); + iv_rulestring0=rulestring0(); + + state._fsp--; + + current =iv_rulestring0; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulestring0" + + + // $ANTLR start "rulestring0" + // InternalRos2Parser.g:5055:1: rulestring0 returns [EObject current=null] : ( () otherlv_1= String_1 ) ; + public final EObject rulestring0() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5061:2: ( ( () otherlv_1= String_1 ) ) + // InternalRos2Parser.g:5062:2: ( () otherlv_1= String_1 ) + { + // InternalRos2Parser.g:5062:2: ( () otherlv_1= String_1 ) + // InternalRos2Parser.g:5063:3: () otherlv_1= String_1 + { + // InternalRos2Parser.g:5063:3: () + // InternalRos2Parser.g:5064:4: + { + + current = forceCreateModelElement( + grammarAccess.getString0Access().getStringAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,String_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getString0Access().getStringKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulestring0" + + + // $ANTLR start "entryRulebyte" + // InternalRos2Parser.g:5078:1: entryRulebyte returns [EObject current=null] : iv_rulebyte= rulebyte EOF ; + public final EObject entryRulebyte() throws RecognitionException { + EObject current = null; + + EObject iv_rulebyte = null; + + + try { + // InternalRos2Parser.g:5078:45: (iv_rulebyte= rulebyte EOF ) + // InternalRos2Parser.g:5079:2: iv_rulebyte= rulebyte EOF + { + newCompositeNode(grammarAccess.getByteRule()); + pushFollow(FOLLOW_1); + iv_rulebyte=rulebyte(); + + state._fsp--; + + current =iv_rulebyte; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulebyte" + + + // $ANTLR start "rulebyte" + // InternalRos2Parser.g:5085:1: rulebyte returns [EObject current=null] : ( () otherlv_1= Byte ) ; + public final EObject rulebyte() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5091:2: ( ( () otherlv_1= Byte ) ) + // InternalRos2Parser.g:5092:2: ( () otherlv_1= Byte ) + { + // InternalRos2Parser.g:5092:2: ( () otherlv_1= Byte ) + // InternalRos2Parser.g:5093:3: () otherlv_1= Byte + { + // InternalRos2Parser.g:5093:3: () + // InternalRos2Parser.g:5094:4: + { + + current = forceCreateModelElement( + grammarAccess.getByteAccess().getByteAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Byte,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getByteAccess().getByteKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulebyte" + + + // $ANTLR start "entryRuletime" + // InternalRos2Parser.g:5108:1: entryRuletime returns [EObject current=null] : iv_ruletime= ruletime EOF ; + public final EObject entryRuletime() throws RecognitionException { + EObject current = null; + + EObject iv_ruletime = null; + + + try { + // InternalRos2Parser.g:5108:45: (iv_ruletime= ruletime EOF ) + // InternalRos2Parser.g:5109:2: iv_ruletime= ruletime EOF + { + newCompositeNode(grammarAccess.getTimeRule()); + pushFollow(FOLLOW_1); + iv_ruletime=ruletime(); + + state._fsp--; + + current =iv_ruletime; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuletime" + + + // $ANTLR start "ruletime" + // InternalRos2Parser.g:5115:1: ruletime returns [EObject current=null] : ( () otherlv_1= Time ) ; + public final EObject ruletime() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5121:2: ( ( () otherlv_1= Time ) ) + // InternalRos2Parser.g:5122:2: ( () otherlv_1= Time ) + { + // InternalRos2Parser.g:5122:2: ( () otherlv_1= Time ) + // InternalRos2Parser.g:5123:3: () otherlv_1= Time + { + // InternalRos2Parser.g:5123:3: () + // InternalRos2Parser.g:5124:4: + { + + current = forceCreateModelElement( + grammarAccess.getTimeAccess().getTimeAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Time,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getTimeAccess().getTimeKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruletime" + + + // $ANTLR start "entryRuleduration" + // InternalRos2Parser.g:5138:1: entryRuleduration returns [EObject current=null] : iv_ruleduration= ruleduration EOF ; + public final EObject entryRuleduration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleduration = null; + + + try { + // InternalRos2Parser.g:5138:49: (iv_ruleduration= ruleduration EOF ) + // InternalRos2Parser.g:5139:2: iv_ruleduration= ruleduration EOF + { + newCompositeNode(grammarAccess.getDurationRule()); + pushFollow(FOLLOW_1); + iv_ruleduration=ruleduration(); + + state._fsp--; + + current =iv_ruleduration; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleduration" + + + // $ANTLR start "ruleduration" + // InternalRos2Parser.g:5145:1: ruleduration returns [EObject current=null] : ( () otherlv_1= Duration ) ; + public final EObject ruleduration() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5151:2: ( ( () otherlv_1= Duration ) ) + // InternalRos2Parser.g:5152:2: ( () otherlv_1= Duration ) + { + // InternalRos2Parser.g:5152:2: ( () otherlv_1= Duration ) + // InternalRos2Parser.g:5153:3: () otherlv_1= Duration + { + // InternalRos2Parser.g:5153:3: () + // InternalRos2Parser.g:5154:4: + { + + current = forceCreateModelElement( + grammarAccess.getDurationAccess().getDurationAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Duration,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getDurationAccess().getDurationKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleduration" + + + // $ANTLR start "entryRuleboolArray" + // InternalRos2Parser.g:5168:1: entryRuleboolArray returns [EObject current=null] : iv_ruleboolArray= ruleboolArray EOF ; + public final EObject entryRuleboolArray() throws RecognitionException { + EObject current = null; + + EObject iv_ruleboolArray = null; + + + try { + // InternalRos2Parser.g:5168:50: (iv_ruleboolArray= ruleboolArray EOF ) + // InternalRos2Parser.g:5169:2: iv_ruleboolArray= ruleboolArray EOF + { + newCompositeNode(grammarAccess.getBoolArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleboolArray=ruleboolArray(); + + state._fsp--; + + current =iv_ruleboolArray; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleboolArray" + + + // $ANTLR start "ruleboolArray" + // InternalRos2Parser.g:5175:1: ruleboolArray returns [EObject current=null] : ( () otherlv_1= Bool_1 ) ; + public final EObject ruleboolArray() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5181:2: ( ( () otherlv_1= Bool_1 ) ) + // InternalRos2Parser.g:5182:2: ( () otherlv_1= Bool_1 ) + { + // InternalRos2Parser.g:5182:2: ( () otherlv_1= Bool_1 ) + // InternalRos2Parser.g:5183:3: () otherlv_1= Bool_1 + { + // InternalRos2Parser.g:5183:3: () + // InternalRos2Parser.g:5184:4: + { + + current = forceCreateModelElement( + grammarAccess.getBoolArrayAccess().getBoolArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Bool_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getBoolArrayAccess().getBoolKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleboolArray" + + + // $ANTLR start "entryRuleint8Array" + // InternalRos2Parser.g:5198:1: entryRuleint8Array returns [EObject current=null] : iv_ruleint8Array= ruleint8Array EOF ; + public final EObject entryRuleint8Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint8Array = null; + + + try { + // InternalRos2Parser.g:5198:50: (iv_ruleint8Array= ruleint8Array EOF ) + // InternalRos2Parser.g:5199:2: iv_ruleint8Array= ruleint8Array EOF + { + newCompositeNode(grammarAccess.getInt8ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleint8Array=ruleint8Array(); + + state._fsp--; + + current =iv_ruleint8Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint8Array" + + + // $ANTLR start "ruleint8Array" + // InternalRos2Parser.g:5205:1: ruleint8Array returns [EObject current=null] : ( () otherlv_1= Int8_1 ) ; + public final EObject ruleint8Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5211:2: ( ( () otherlv_1= Int8_1 ) ) + // InternalRos2Parser.g:5212:2: ( () otherlv_1= Int8_1 ) + { + // InternalRos2Parser.g:5212:2: ( () otherlv_1= Int8_1 ) + // InternalRos2Parser.g:5213:3: () otherlv_1= Int8_1 + { + // InternalRos2Parser.g:5213:3: () + // InternalRos2Parser.g:5214:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt8ArrayAccess().getInt8ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int8_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt8ArrayAccess().getInt8Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint8Array" + + + // $ANTLR start "entryRuleuint8Array" + // InternalRos2Parser.g:5228:1: entryRuleuint8Array returns [EObject current=null] : iv_ruleuint8Array= ruleuint8Array EOF ; + public final EObject entryRuleuint8Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint8Array = null; + + + try { + // InternalRos2Parser.g:5228:51: (iv_ruleuint8Array= ruleuint8Array EOF ) + // InternalRos2Parser.g:5229:2: iv_ruleuint8Array= ruleuint8Array EOF + { + newCompositeNode(grammarAccess.getUint8ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleuint8Array=ruleuint8Array(); + + state._fsp--; + + current =iv_ruleuint8Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint8Array" + + + // $ANTLR start "ruleuint8Array" + // InternalRos2Parser.g:5235:1: ruleuint8Array returns [EObject current=null] : ( () otherlv_1= Uint8_1 ) ; + public final EObject ruleuint8Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5241:2: ( ( () otherlv_1= Uint8_1 ) ) + // InternalRos2Parser.g:5242:2: ( () otherlv_1= Uint8_1 ) + { + // InternalRos2Parser.g:5242:2: ( () otherlv_1= Uint8_1 ) + // InternalRos2Parser.g:5243:3: () otherlv_1= Uint8_1 + { + // InternalRos2Parser.g:5243:3: () + // InternalRos2Parser.g:5244:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint8ArrayAccess().getUint8ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint8_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint8ArrayAccess().getUint8Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint8Array" + + + // $ANTLR start "entryRuleint16Array" + // InternalRos2Parser.g:5258:1: entryRuleint16Array returns [EObject current=null] : iv_ruleint16Array= ruleint16Array EOF ; + public final EObject entryRuleint16Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint16Array = null; + + + try { + // InternalRos2Parser.g:5258:51: (iv_ruleint16Array= ruleint16Array EOF ) + // InternalRos2Parser.g:5259:2: iv_ruleint16Array= ruleint16Array EOF + { + newCompositeNode(grammarAccess.getInt16ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleint16Array=ruleint16Array(); + + state._fsp--; + + current =iv_ruleint16Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint16Array" + + + // $ANTLR start "ruleint16Array" + // InternalRos2Parser.g:5265:1: ruleint16Array returns [EObject current=null] : ( () otherlv_1= Int16_1 ) ; + public final EObject ruleint16Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5271:2: ( ( () otherlv_1= Int16_1 ) ) + // InternalRos2Parser.g:5272:2: ( () otherlv_1= Int16_1 ) + { + // InternalRos2Parser.g:5272:2: ( () otherlv_1= Int16_1 ) + // InternalRos2Parser.g:5273:3: () otherlv_1= Int16_1 + { + // InternalRos2Parser.g:5273:3: () + // InternalRos2Parser.g:5274:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt16ArrayAccess().getInt16ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int16_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt16ArrayAccess().getInt16Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint16Array" + + + // $ANTLR start "entryRuleuint16Array" + // InternalRos2Parser.g:5288:1: entryRuleuint16Array returns [EObject current=null] : iv_ruleuint16Array= ruleuint16Array EOF ; + public final EObject entryRuleuint16Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint16Array = null; + + + try { + // InternalRos2Parser.g:5288:52: (iv_ruleuint16Array= ruleuint16Array EOF ) + // InternalRos2Parser.g:5289:2: iv_ruleuint16Array= ruleuint16Array EOF + { + newCompositeNode(grammarAccess.getUint16ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleuint16Array=ruleuint16Array(); + + state._fsp--; + + current =iv_ruleuint16Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint16Array" + + + // $ANTLR start "ruleuint16Array" + // InternalRos2Parser.g:5295:1: ruleuint16Array returns [EObject current=null] : ( () otherlv_1= Uint16_1 ) ; + public final EObject ruleuint16Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5301:2: ( ( () otherlv_1= Uint16_1 ) ) + // InternalRos2Parser.g:5302:2: ( () otherlv_1= Uint16_1 ) + { + // InternalRos2Parser.g:5302:2: ( () otherlv_1= Uint16_1 ) + // InternalRos2Parser.g:5303:3: () otherlv_1= Uint16_1 + { + // InternalRos2Parser.g:5303:3: () + // InternalRos2Parser.g:5304:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint16ArrayAccess().getUint16ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint16_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint16ArrayAccess().getUint16Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint16Array" + + + // $ANTLR start "entryRuleint32Array" + // InternalRos2Parser.g:5318:1: entryRuleint32Array returns [EObject current=null] : iv_ruleint32Array= ruleint32Array EOF ; + public final EObject entryRuleint32Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint32Array = null; + + + try { + // InternalRos2Parser.g:5318:51: (iv_ruleint32Array= ruleint32Array EOF ) + // InternalRos2Parser.g:5319:2: iv_ruleint32Array= ruleint32Array EOF + { + newCompositeNode(grammarAccess.getInt32ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleint32Array=ruleint32Array(); + + state._fsp--; + + current =iv_ruleint32Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint32Array" + + + // $ANTLR start "ruleint32Array" + // InternalRos2Parser.g:5325:1: ruleint32Array returns [EObject current=null] : ( () otherlv_1= Int32_1 ) ; + public final EObject ruleint32Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5331:2: ( ( () otherlv_1= Int32_1 ) ) + // InternalRos2Parser.g:5332:2: ( () otherlv_1= Int32_1 ) + { + // InternalRos2Parser.g:5332:2: ( () otherlv_1= Int32_1 ) + // InternalRos2Parser.g:5333:3: () otherlv_1= Int32_1 + { + // InternalRos2Parser.g:5333:3: () + // InternalRos2Parser.g:5334:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt32ArrayAccess().getInt32ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int32_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt32ArrayAccess().getInt32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint32Array" + + + // $ANTLR start "entryRuleuint32Array" + // InternalRos2Parser.g:5348:1: entryRuleuint32Array returns [EObject current=null] : iv_ruleuint32Array= ruleuint32Array EOF ; + public final EObject entryRuleuint32Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint32Array = null; + + + try { + // InternalRos2Parser.g:5348:52: (iv_ruleuint32Array= ruleuint32Array EOF ) + // InternalRos2Parser.g:5349:2: iv_ruleuint32Array= ruleuint32Array EOF + { + newCompositeNode(grammarAccess.getUint32ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleuint32Array=ruleuint32Array(); + + state._fsp--; + + current =iv_ruleuint32Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint32Array" + + + // $ANTLR start "ruleuint32Array" + // InternalRos2Parser.g:5355:1: ruleuint32Array returns [EObject current=null] : ( () otherlv_1= Uint32_1 ) ; + public final EObject ruleuint32Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5361:2: ( ( () otherlv_1= Uint32_1 ) ) + // InternalRos2Parser.g:5362:2: ( () otherlv_1= Uint32_1 ) + { + // InternalRos2Parser.g:5362:2: ( () otherlv_1= Uint32_1 ) + // InternalRos2Parser.g:5363:3: () otherlv_1= Uint32_1 + { + // InternalRos2Parser.g:5363:3: () + // InternalRos2Parser.g:5364:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint32ArrayAccess().getUint32ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint32_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint32ArrayAccess().getUint32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint32Array" + + + // $ANTLR start "entryRuleint64Array" + // InternalRos2Parser.g:5378:1: entryRuleint64Array returns [EObject current=null] : iv_ruleint64Array= ruleint64Array EOF ; + public final EObject entryRuleint64Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleint64Array = null; + + + try { + // InternalRos2Parser.g:5378:51: (iv_ruleint64Array= ruleint64Array EOF ) + // InternalRos2Parser.g:5379:2: iv_ruleint64Array= ruleint64Array EOF + { + newCompositeNode(grammarAccess.getInt64ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleint64Array=ruleint64Array(); + + state._fsp--; + + current =iv_ruleint64Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleint64Array" + + + // $ANTLR start "ruleint64Array" + // InternalRos2Parser.g:5385:1: ruleint64Array returns [EObject current=null] : ( () otherlv_1= Int64_1 ) ; + public final EObject ruleint64Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5391:2: ( ( () otherlv_1= Int64_1 ) ) + // InternalRos2Parser.g:5392:2: ( () otherlv_1= Int64_1 ) + { + // InternalRos2Parser.g:5392:2: ( () otherlv_1= Int64_1 ) + // InternalRos2Parser.g:5393:3: () otherlv_1= Int64_1 + { + // InternalRos2Parser.g:5393:3: () + // InternalRos2Parser.g:5394:4: + { + + current = forceCreateModelElement( + grammarAccess.getInt64ArrayAccess().getInt64ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Int64_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getInt64ArrayAccess().getInt64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleint64Array" + + + // $ANTLR start "entryRuleuint64Array" + // InternalRos2Parser.g:5408:1: entryRuleuint64Array returns [EObject current=null] : iv_ruleuint64Array= ruleuint64Array EOF ; + public final EObject entryRuleuint64Array() throws RecognitionException { + EObject current = null; + + EObject iv_ruleuint64Array = null; + + + try { + // InternalRos2Parser.g:5408:52: (iv_ruleuint64Array= ruleuint64Array EOF ) + // InternalRos2Parser.g:5409:2: iv_ruleuint64Array= ruleuint64Array EOF + { + newCompositeNode(grammarAccess.getUint64ArrayRule()); + pushFollow(FOLLOW_1); + iv_ruleuint64Array=ruleuint64Array(); + + state._fsp--; + + current =iv_ruleuint64Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleuint64Array" + + + // $ANTLR start "ruleuint64Array" + // InternalRos2Parser.g:5415:1: ruleuint64Array returns [EObject current=null] : ( () otherlv_1= Uint64_1 ) ; + public final EObject ruleuint64Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5421:2: ( ( () otherlv_1= Uint64_1 ) ) + // InternalRos2Parser.g:5422:2: ( () otherlv_1= Uint64_1 ) + { + // InternalRos2Parser.g:5422:2: ( () otherlv_1= Uint64_1 ) + // InternalRos2Parser.g:5423:3: () otherlv_1= Uint64_1 + { + // InternalRos2Parser.g:5423:3: () + // InternalRos2Parser.g:5424:4: + { + + current = forceCreateModelElement( + grammarAccess.getUint64ArrayAccess().getUint64ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Uint64_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getUint64ArrayAccess().getUint64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleuint64Array" + + + // $ANTLR start "entryRulefloat32Array" + // InternalRos2Parser.g:5438:1: entryRulefloat32Array returns [EObject current=null] : iv_rulefloat32Array= rulefloat32Array EOF ; + public final EObject entryRulefloat32Array() throws RecognitionException { + EObject current = null; + + EObject iv_rulefloat32Array = null; + + + try { + // InternalRos2Parser.g:5438:53: (iv_rulefloat32Array= rulefloat32Array EOF ) + // InternalRos2Parser.g:5439:2: iv_rulefloat32Array= rulefloat32Array EOF + { + newCompositeNode(grammarAccess.getFloat32ArrayRule()); + pushFollow(FOLLOW_1); + iv_rulefloat32Array=rulefloat32Array(); + + state._fsp--; + + current =iv_rulefloat32Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulefloat32Array" + + + // $ANTLR start "rulefloat32Array" + // InternalRos2Parser.g:5445:1: rulefloat32Array returns [EObject current=null] : ( () otherlv_1= Float32_1 ) ; + public final EObject rulefloat32Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5451:2: ( ( () otherlv_1= Float32_1 ) ) + // InternalRos2Parser.g:5452:2: ( () otherlv_1= Float32_1 ) + { + // InternalRos2Parser.g:5452:2: ( () otherlv_1= Float32_1 ) + // InternalRos2Parser.g:5453:3: () otherlv_1= Float32_1 + { + // InternalRos2Parser.g:5453:3: () + // InternalRos2Parser.g:5454:4: + { + + current = forceCreateModelElement( + grammarAccess.getFloat32ArrayAccess().getFloat32ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Float32_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getFloat32ArrayAccess().getFloat32Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulefloat32Array" + + + // $ANTLR start "entryRulefloat64Array" + // InternalRos2Parser.g:5468:1: entryRulefloat64Array returns [EObject current=null] : iv_rulefloat64Array= rulefloat64Array EOF ; + public final EObject entryRulefloat64Array() throws RecognitionException { + EObject current = null; + + EObject iv_rulefloat64Array = null; + + + try { + // InternalRos2Parser.g:5468:53: (iv_rulefloat64Array= rulefloat64Array EOF ) + // InternalRos2Parser.g:5469:2: iv_rulefloat64Array= rulefloat64Array EOF + { + newCompositeNode(grammarAccess.getFloat64ArrayRule()); + pushFollow(FOLLOW_1); + iv_rulefloat64Array=rulefloat64Array(); + + state._fsp--; + + current =iv_rulefloat64Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulefloat64Array" + + + // $ANTLR start "rulefloat64Array" + // InternalRos2Parser.g:5475:1: rulefloat64Array returns [EObject current=null] : ( () otherlv_1= Float64_1 ) ; + public final EObject rulefloat64Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5481:2: ( ( () otherlv_1= Float64_1 ) ) + // InternalRos2Parser.g:5482:2: ( () otherlv_1= Float64_1 ) + { + // InternalRos2Parser.g:5482:2: ( () otherlv_1= Float64_1 ) + // InternalRos2Parser.g:5483:3: () otherlv_1= Float64_1 + { + // InternalRos2Parser.g:5483:3: () + // InternalRos2Parser.g:5484:4: + { + + current = forceCreateModelElement( + grammarAccess.getFloat64ArrayAccess().getFloat64ArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Float64_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getFloat64ArrayAccess().getFloat64Keyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulefloat64Array" + + + // $ANTLR start "entryRulestring0Array" + // InternalRos2Parser.g:5498:1: entryRulestring0Array returns [EObject current=null] : iv_rulestring0Array= rulestring0Array EOF ; + public final EObject entryRulestring0Array() throws RecognitionException { + EObject current = null; + + EObject iv_rulestring0Array = null; + + + try { + // InternalRos2Parser.g:5498:53: (iv_rulestring0Array= rulestring0Array EOF ) + // InternalRos2Parser.g:5499:2: iv_rulestring0Array= rulestring0Array EOF + { + newCompositeNode(grammarAccess.getString0ArrayRule()); + pushFollow(FOLLOW_1); + iv_rulestring0Array=rulestring0Array(); + + state._fsp--; + + current =iv_rulestring0Array; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulestring0Array" + + + // $ANTLR start "rulestring0Array" + // InternalRos2Parser.g:5505:1: rulestring0Array returns [EObject current=null] : ( () otherlv_1= String_2 ) ; + public final EObject rulestring0Array() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5511:2: ( ( () otherlv_1= String_2 ) ) + // InternalRos2Parser.g:5512:2: ( () otherlv_1= String_2 ) + { + // InternalRos2Parser.g:5512:2: ( () otherlv_1= String_2 ) + // InternalRos2Parser.g:5513:3: () otherlv_1= String_2 + { + // InternalRos2Parser.g:5513:3: () + // InternalRos2Parser.g:5514:4: + { + + current = forceCreateModelElement( + grammarAccess.getString0ArrayAccess().getStringArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,String_2,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getString0ArrayAccess().getStringKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulestring0Array" + + + // $ANTLR start "entryRulebyteArray" + // InternalRos2Parser.g:5528:1: entryRulebyteArray returns [EObject current=null] : iv_rulebyteArray= rulebyteArray EOF ; + public final EObject entryRulebyteArray() throws RecognitionException { + EObject current = null; + + EObject iv_rulebyteArray = null; + + + try { + // InternalRos2Parser.g:5528:50: (iv_rulebyteArray= rulebyteArray EOF ) + // InternalRos2Parser.g:5529:2: iv_rulebyteArray= rulebyteArray EOF + { + newCompositeNode(grammarAccess.getByteArrayRule()); + pushFollow(FOLLOW_1); + iv_rulebyteArray=rulebyteArray(); + + state._fsp--; + + current =iv_rulebyteArray; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulebyteArray" + + + // $ANTLR start "rulebyteArray" + // InternalRos2Parser.g:5535:1: rulebyteArray returns [EObject current=null] : ( () otherlv_1= Byte_1 ) ; + public final EObject rulebyteArray() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5541:2: ( ( () otherlv_1= Byte_1 ) ) + // InternalRos2Parser.g:5542:2: ( () otherlv_1= Byte_1 ) + { + // InternalRos2Parser.g:5542:2: ( () otherlv_1= Byte_1 ) + // InternalRos2Parser.g:5543:3: () otherlv_1= Byte_1 + { + // InternalRos2Parser.g:5543:3: () + // InternalRos2Parser.g:5544:4: + { + + current = forceCreateModelElement( + grammarAccess.getByteArrayAccess().getByteArrayAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Byte_1,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getByteArrayAccess().getByteKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulebyteArray" + + + // $ANTLR start "entryRuleHeader" + // InternalRos2Parser.g:5558:1: entryRuleHeader returns [EObject current=null] : iv_ruleHeader= ruleHeader EOF ; + public final EObject entryRuleHeader() throws RecognitionException { + EObject current = null; + + EObject iv_ruleHeader = null; + + + try { + // InternalRos2Parser.g:5558:47: (iv_ruleHeader= ruleHeader EOF ) + // InternalRos2Parser.g:5559:2: iv_ruleHeader= ruleHeader EOF + { + newCompositeNode(grammarAccess.getHeaderRule()); + pushFollow(FOLLOW_1); + iv_ruleHeader=ruleHeader(); + + state._fsp--; + + current =iv_ruleHeader; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleHeader" + + + // $ANTLR start "ruleHeader" + // InternalRos2Parser.g:5565:1: ruleHeader returns [EObject current=null] : ( () otherlv_1= Header ) ; + public final EObject ruleHeader() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5571:2: ( ( () otherlv_1= Header ) ) + // InternalRos2Parser.g:5572:2: ( () otherlv_1= Header ) + { + // InternalRos2Parser.g:5572:2: ( () otherlv_1= Header ) + // InternalRos2Parser.g:5573:3: () otherlv_1= Header + { + // InternalRos2Parser.g:5573:3: () + // InternalRos2Parser.g:5574:4: + { + + current = forceCreateModelElement( + grammarAccess.getHeaderAccess().getHeaderAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,Header,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getHeaderAccess().getHeaderKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleHeader" + + + // $ANTLR start "entryRuleTopicSpecRef" + // InternalRos2Parser.g:5588:1: entryRuleTopicSpecRef returns [EObject current=null] : iv_ruleTopicSpecRef= ruleTopicSpecRef EOF ; + public final EObject entryRuleTopicSpecRef() throws RecognitionException { + EObject current = null; + + EObject iv_ruleTopicSpecRef = null; + + + try { + // InternalRos2Parser.g:5588:53: (iv_ruleTopicSpecRef= ruleTopicSpecRef EOF ) + // InternalRos2Parser.g:5589:2: iv_ruleTopicSpecRef= ruleTopicSpecRef EOF + { + newCompositeNode(grammarAccess.getTopicSpecRefRule()); + pushFollow(FOLLOW_1); + iv_ruleTopicSpecRef=ruleTopicSpecRef(); + + state._fsp--; + + current =iv_ruleTopicSpecRef; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleTopicSpecRef" + + + // $ANTLR start "ruleTopicSpecRef" + // InternalRos2Parser.g:5595:1: ruleTopicSpecRef returns [EObject current=null] : ( ( ruleEString ) ) ; + public final EObject ruleTopicSpecRef() throws RecognitionException { + EObject current = null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5601:2: ( ( ( ruleEString ) ) ) + // InternalRos2Parser.g:5602:2: ( ( ruleEString ) ) + { + // InternalRos2Parser.g:5602:2: ( ( ruleEString ) ) + // InternalRos2Parser.g:5603:3: ( ruleEString ) + { + // InternalRos2Parser.g:5603:3: ( ruleEString ) + // InternalRos2Parser.g:5604:4: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getTopicSpecRefRule()); + } + + + newCompositeNode(grammarAccess.getTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0()); + + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleTopicSpecRef" + + + // $ANTLR start "entryRuleArrayTopicSpecRef" + // InternalRos2Parser.g:5621:1: entryRuleArrayTopicSpecRef returns [EObject current=null] : iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF ; + public final EObject entryRuleArrayTopicSpecRef() throws RecognitionException { + EObject current = null; + + EObject iv_ruleArrayTopicSpecRef = null; + + + try { + // InternalRos2Parser.g:5621:58: (iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF ) + // InternalRos2Parser.g:5622:2: iv_ruleArrayTopicSpecRef= ruleArrayTopicSpecRef EOF + { + newCompositeNode(grammarAccess.getArrayTopicSpecRefRule()); + pushFollow(FOLLOW_1); + iv_ruleArrayTopicSpecRef=ruleArrayTopicSpecRef(); + + state._fsp--; + + current =iv_ruleArrayTopicSpecRef; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleArrayTopicSpecRef" + + + // $ANTLR start "ruleArrayTopicSpecRef" + // InternalRos2Parser.g:5628:1: ruleArrayTopicSpecRef returns [EObject current=null] : ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) ; + public final EObject ruleArrayTopicSpecRef() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5634:2: ( ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) ) + // InternalRos2Parser.g:5635:2: ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) + { + // InternalRos2Parser.g:5635:2: ( ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket ) + // InternalRos2Parser.g:5636:3: ( ( ruleEString ) ) otherlv_1= LeftSquareBracketRightSquareBracket + { + // InternalRos2Parser.g:5636:3: ( ( ruleEString ) ) + // InternalRos2Parser.g:5637:4: ( ruleEString ) + { + // InternalRos2Parser.g:5637:4: ( ruleEString ) + // InternalRos2Parser.g:5638:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getArrayTopicSpecRefRule()); + } + + + newCompositeNode(grammarAccess.getArrayTopicSpecRefAccess().getTopicSpecTopicSpecCrossReference_0_0()); + + pushFollow(FOLLOW_60); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_1=(Token)match(input,LeftSquareBracketRightSquareBracket,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getArrayTopicSpecRefAccess().getLeftSquareBracketRightSquareBracketKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleArrayTopicSpecRef" + + + // $ANTLR start "entryRuleKEYWORD" + // InternalRos2Parser.g:5660:1: entryRuleKEYWORD returns [String current=null] : iv_ruleKEYWORD= ruleKEYWORD EOF ; + public final String entryRuleKEYWORD() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleKEYWORD = null; + + + try { + // InternalRos2Parser.g:5660:47: (iv_ruleKEYWORD= ruleKEYWORD EOF ) + // InternalRos2Parser.g:5661:2: iv_ruleKEYWORD= ruleKEYWORD EOF + { + newCompositeNode(grammarAccess.getKEYWORDRule()); + pushFollow(FOLLOW_1); + iv_ruleKEYWORD=ruleKEYWORD(); + + state._fsp--; + + current =iv_ruleKEYWORD.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleKEYWORD" + + + // $ANTLR start "ruleKEYWORD" + // InternalRos2Parser.g:5667:1: ruleKEYWORD returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) ; + public final AntlrDatatypeRuleToken ruleKEYWORD() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalRos2Parser.g:5673:2: ( (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) ) + // InternalRos2Parser.g:5674:2: (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) + { + // InternalRos2Parser.g:5674:2: (kw= Goal | kw= Message | kw= Result | kw= Feedback | kw= Name | kw= Value | kw= Service | kw= Type | kw= Action | kw= Duration | kw= Time ) + int alt74=11; + switch ( input.LA(1) ) { + case Goal: + { + alt74=1; + } + break; + case Message: + { + alt74=2; + } + break; + case Result: + { + alt74=3; + } + break; + case Feedback: + { + alt74=4; + } + break; + case Name: + { + alt74=5; + } + break; + case Value: + { + alt74=6; + } + break; + case Service: + { + alt74=7; + } + break; + case Type: + { + alt74=8; + } + break; + case Action: + { + alt74=9; + } + break; + case Duration: + { + alt74=10; + } + break; + case Time: + { + alt74=11; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 74, 0, input); + + throw nvae; + } + + switch (alt74) { + case 1 : + // InternalRos2Parser.g:5675:3: kw= Goal + { + kw=(Token)match(input,Goal,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getGoalKeyword_0()); + + + } + break; + case 2 : + // InternalRos2Parser.g:5681:3: kw= Message + { + kw=(Token)match(input,Message,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getMessageKeyword_1()); + + + } + break; + case 3 : + // InternalRos2Parser.g:5687:3: kw= Result + { + kw=(Token)match(input,Result,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getResultKeyword_2()); + + + } + break; + case 4 : + // InternalRos2Parser.g:5693:3: kw= Feedback + { + kw=(Token)match(input,Feedback,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getFeedbackKeyword_3()); + + + } + break; + case 5 : + // InternalRos2Parser.g:5699:3: kw= Name + { + kw=(Token)match(input,Name,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getNameKeyword_4()); + + + } + break; + case 6 : + // InternalRos2Parser.g:5705:3: kw= Value + { + kw=(Token)match(input,Value,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getValueKeyword_5()); + + + } + break; + case 7 : + // InternalRos2Parser.g:5711:3: kw= Service + { + kw=(Token)match(input,Service,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getServiceKeyword_6()); + + + } + break; + case 8 : + // InternalRos2Parser.g:5717:3: kw= Type + { + kw=(Token)match(input,Type,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTypeKeyword_7()); + + + } + break; + case 9 : + // InternalRos2Parser.g:5723:3: kw= Action + { + kw=(Token)match(input,Action,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getActionKeyword_8()); + + + } + break; + case 10 : + // InternalRos2Parser.g:5729:3: kw= Duration + { + kw=(Token)match(input,Duration,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getDurationKeyword_9()); + + + } + break; + case 11 : + // InternalRos2Parser.g:5735:3: kw= Time + { + kw=(Token)match(input,Time,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getKEYWORDAccess().getTimeKeyword_10()); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleKEYWORD" + + // Delegated rules + + + protected DFA73 dfa73 = new DFA73(this); + static final String dfa_1s = "\42\uffff"; + static final String dfa_2s = "\36\uffff\2\41\2\uffff"; + static final String dfa_3s = "\1\36\35\uffff\2\42\2\uffff"; + static final String dfa_4s = "\1\157\35\uffff\2\175\2\uffff"; + static final String dfa_5s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\2\uffff\1\37\1\36"; + static final String dfa_6s = "\42\uffff}>"; + static final String[] dfa_7s = { + "\1\32\1\33\2\uffff\1\17\7\uffff\1\34\1\25\1\27\1\31\5\uffff\1\12\1\13\1\24\1\26\1\30\3\uffff\1\23\3\uffff\1\20\3\uffff\1\21\1\35\1\uffff\1\22\2\uffff\1\14\1\5\1\7\1\11\1\uffff\1\4\1\6\1\10\2\uffff\1\3\3\uffff\1\1\1\15\1\uffff\1\2\5\uffff\1\16\14\uffff\1\37\1\uffff\1\36", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\2\41\24\uffff\1\41\1\uffff\1\41\7\uffff\1\41\4\uffff\1\41\14\uffff\1\41\4\uffff\1\41\2\uffff\1\41\3\uffff\2\41\2\uffff\1\40\10\uffff\1\41\1\uffff\1\41\15\uffff\1\41", + "\2\41\24\uffff\1\41\1\uffff\1\41\7\uffff\1\41\4\uffff\1\41\14\uffff\1\41\4\uffff\1\41\2\uffff\1\41\3\uffff\2\41\2\uffff\1\40\10\uffff\1\41\1\uffff\1\41\15\uffff\1\41", + "", + "" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s); + static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s); + + class DFA73 extends DFA { + + public DFA73(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 73; + this.eot = dfa_1; + this.eof = dfa_2; + this.min = dfa_3; + this.max = dfa_4; + this.accept = dfa_5; + this.special = dfa_6; + this.transition = dfa_7; + } + public String getDescription() { + return "4435:2: (this_bool_0= rulebool | this_int8_1= ruleint8 | this_uint8_2= ruleuint8 | this_int16_3= ruleint16 | this_uint16_4= ruleuint16 | this_int32_5= ruleint32 | this_uint32_6= ruleuint32 | this_int64_7= ruleint64 | this_uint64_8= ruleuint64 | this_float32_9= rulefloat32 | this_float64_10= rulefloat64 | this_string0_11= rulestring0 | this_byte_12= rulebyte | this_time_13= ruletime | this_duration_14= ruleduration | this_Header_15= ruleHeader | this_boolArray_16= ruleboolArray | this_int8Array_17= ruleint8Array | this_uint8Array_18= ruleuint8Array | this_int16Array_19= ruleint16Array | this_uint16Array_20= ruleuint16Array | this_int32Array_21= ruleint32Array | this_uint32Array_22= ruleuint32Array | this_int64Array_23= ruleint64Array | this_uint64Array_24= ruleuint64Array | this_float32Array_25= rulefloat32Array | this_float64Array_26= rulefloat64Array | this_string0Array_27= rulestring0Array | this_byteArray_28= rulebyteArray | this_TopicSpecRef_29= ruleTopicSpecRef | this_ArrayTopicSpecRef_30= ruleArrayTopicSpecRef )"; + } + } + + + 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[]{0x0000000000000000L,0x0000004000000000L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000004024000L,0x0000080000000000L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000000000L,0x0000A00000000000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000004004000L,0x0000080000000000L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000000L,0x0000680020000000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000004000L,0x0000080000000000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000000L,0x0000008000000000L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000020L,0x0000A00000000000L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0000012000000000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000000L,0x0000080000000000L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000008488000L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000009000840002L,0x0000000000000020L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000002100000000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000010000200000L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000400000000200L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000000000L,0x0000080840000000L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x00000000000001C0L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000000000L,0x0000080040000000L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000009000840000L,0x0000080000000020L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x7001800000000000L,0x0000000000400003L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000024000L,0x0000080000000100L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000004000L,0x0000080000000100L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0002000000000000L,0x0000080088000000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000000000L,0x0000080000020000L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000000000L,0x0000600020000000L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000003103C00L,0x0000080000000000L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000000L,0x0000A80000000000L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x8000000000000000L,0x0000A00000000001L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000004000000000L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000000L,0x00000C0000000000L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x88F83C04C0000000L,0x0000A8010589DE58L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000020000000000L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000200000000L,0x0000040000000000L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000200000000L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); + public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0200000000000000L,0x0000040000000000L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0200000000000000L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000020000000L,0x0000040000000000L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000020000000L}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x88F83C04C0000002L,0x0000A0010589DE58L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000000002L,0x0000008000000000L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000010000000L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0004000000000002L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); + public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000000L}); + public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L}); + public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0004000000000000L,0x0000080000000000L}); + public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000000L,0x003CA08000000000L}); + public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000000002L,0x0000000000100000L}); + public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000010000000000L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0500000C00000000L,0x2000A00312100084L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/internal/InternalRos2Parser.tokens b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/internal/InternalRos2Parser.tokens new file mode 100644 index 000000000..2c7871a75 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/internal/InternalRos2Parser.tokens @@ -0,0 +1,125 @@ +','=101 +':'=102 +'Any'=98 +'Array:'=60 +'Base64'=61 +'Boolean'=47 +'Date'=85 +'Double'=62 +'ExternalDependency'=5 +'GlobalNamespace'=8 +'GraphName'=28 +'Header'=63 +'Integer'=48 +'List'=86 +'ParameterAny'=16 +'ParameterStructMember'=4 +'PrivateNamespace'=7 +'RelativeNamespace'=6 +'String'=64 +'Struct'=65 +'['=103 +'[]'=100 +']'=104 +'action'=66 +'action:'=49 +'actionclient:'=12 +'actionserver:'=13 +'artifacts:'=26 +'best_effort'=21 +'bool'=87 +'bool[]'=67 +'byte'=88 +'byte[]'=68 +'default'=50 +'default_qos'=22 +'dependencies:'=14 +'depth:'=69 +'durability:'=23 +'duration'=34 +'feedback'=35 +'feedback:'=29 +'float32'=51 +'float32[]'=30 +'float64'=52 +'float64[]'=31 +'fromGitRepo:'=17 +'goal'=89 +'goal:'=77 +'history:'=36 +'int16'=78 +'int16[]'=53 +'int32'=79 +'int32[]'=54 +'int64'=80 +'int64[]'=55 +'int8'=90 +'int8[]'=70 +'keep_all'=37 +'keep_last'=32 +'message'=56 +'message:'=38 +'msg:'=91 +'name'=92 +'node'=93 +'node:'=81 +'ns:'=99 +'parameter_qos'=15 +'parameters:'=24 +'profile:'=39 +'publishers:'=25 +'qos:'=94 +'reliability:'=18 +'reliable'=40 +'request:'=41 +'response:'=33 +'result'=71 +'result:'=57 +'sensor_qos'=27 +'service'=58 +'serviceclient:'=10 +'services_qos'=19 +'serviceserver:'=11 +'specs:'=72 +'srv:'=95 +'string'=73 +'string[]'=42 +'subscribers:'=20 +'time'=96 +'transient_local'=9 +'type'=97 +'type:'=82 +'uint16'=74 +'uint16[]'=43 +'uint32'=75 +'uint32[]'=44 +'uint64'=76 +'uint64[]'=45 +'uint8'=83 +'uint8[]'=59 +'value'=84 +'volatile'=46 +'}'=105 +RULE_ANY_OTHER=128 +RULE_BEGIN=106 +RULE_BINARY=114 +RULE_BOOLEAN=115 +RULE_DATE_TIME=123 +RULE_DAY=118 +RULE_DECINT=116 +RULE_DIGIT=113 +RULE_DOUBLE=117 +RULE_END=107 +RULE_HOUR=121 +RULE_ID=109 +RULE_INT=124 +RULE_MESSAGE_ASIGMENT=125 +RULE_MIN_SEC=122 +RULE_ML_COMMENT=126 +RULE_MONTH=119 +RULE_ROS_CONVENTION_A=110 +RULE_ROS_CONVENTION_PARAM=112 +RULE_SL_COMMENT=108 +RULE_STRING=111 +RULE_WS=127 +RULE_YEAR=120 diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/lexer/InternalRos2Lexer.g b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/lexer/InternalRos2Lexer.g new file mode 100644 index 000000000..4a2e3526f --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/lexer/InternalRos2Lexer.g @@ -0,0 +1,262 @@ +/* + * generated by Xtext 2.25.0 + */ +lexer grammar InternalRos2Lexer; + +@header { +package de.fraunhofer.ipa.ros2.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; +} + +ParameterStructMember : 'ParameterStructMember'; + +ExternalDependency : 'ExternalDependency'; + +RelativeNamespace : 'RelativeNamespace'; + +PrivateNamespace : 'PrivateNamespace'; + +GlobalNamespace : 'GlobalNamespace'; + +Transient_local : 'transient_local'; + +Serviceclient : 'serviceclient:'; + +Serviceserver : 'serviceserver:'; + +Actionclient : 'actionclient:'; + +Actionserver : 'actionserver:'; + +Dependencies : 'dependencies:'; + +Parameter_qos : 'parameter_qos'; + +ParameterAny : 'ParameterAny'; + +FromGitRepo : 'fromGitRepo:'; + +Reliability : 'reliability:'; + +Services_qos : 'services_qos'; + +Subscribers : 'subscribers:'; + +Best_effort : 'best_effort'; + +Default_qos : 'default_qos'; + +Durability : 'durability:'; + +Parameters : 'parameters:'; + +Publishers : 'publishers:'; + +Artifacts : 'artifacts:'; + +Sensor_qos : 'sensor_qos'; + +GraphName : 'GraphName'; + +Feedback_1 : 'feedback:'; + +Float32_1 : 'float32[]'; + +Float64_1 : 'float64[]'; + +Keep_last : 'keep_last'; + +Response : 'response:'; + +Duration : 'duration'; + +Feedback : 'feedback'; + +History : 'history:'; + +Keep_all : 'keep_all'; + +Message_1 : 'message:'; + +Profile : 'profile:'; + +Reliable : 'reliable'; + +Request : 'request:'; + +String_2 : 'string[]'; + +Uint16_1 : 'uint16[]'; + +Uint32_1 : 'uint32[]'; + +Uint64_1 : 'uint64[]'; + +Volatile : 'volatile'; + +Boolean : 'Boolean'; + +Integer : 'Integer'; + +Action_1 : 'action:'; + +Default : 'default'; + +Float32 : 'float32'; + +Float64 : 'float64'; + +Int16_1 : 'int16[]'; + +Int32_1 : 'int32[]'; + +Int64_1 : 'int64[]'; + +Message : 'message'; + +Result_1 : 'result:'; + +Service : 'service'; + +Uint8_1 : 'uint8[]'; + +Array : 'Array:'; + +Base64 : 'Base64'; + +Double : 'Double'; + +Header : 'Header'; + +String : 'String'; + +Struct : 'Struct'; + +Action : 'action'; + +Bool_1 : 'bool[]'; + +Byte_1 : 'byte[]'; + +Depth : 'depth:'; + +Int8_1 : 'int8[]'; + +Result : 'result'; + +Specs : 'specs:'; + +String_1 : 'string'; + +Uint16 : 'uint16'; + +Uint32 : 'uint32'; + +Uint64 : 'uint64'; + +Goal_1 : 'goal:'; + +Int16 : 'int16'; + +Int32 : 'int32'; + +Int64 : 'int64'; + +Node_1 : 'node:'; + +Type_1 : 'type:'; + +Uint8 : 'uint8'; + +Value : 'value'; + +Date : 'Date'; + +List : 'List'; + +Bool : 'bool'; + +Byte : 'byte'; + +Goal : 'goal'; + +Int8 : 'int8'; + +Msg : 'msg:'; + +Name : 'name'; + +Node : 'node'; + +Qos : 'qos:'; + +Srv : 'srv:'; + +Time : 'time'; + +Type : 'type'; + +Any : 'Any'; + +Ns : 'ns:'; + +LeftSquareBracketRightSquareBracket : '[]'; + +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)*; + +fragment RULE_DIGIT : '0'..'9'; + +RULE_BINARY : ('0b'|'0B') ('0'|'1')+; + +RULE_BOOLEAN : ('true'|'false'); + +RULE_DOUBLE : RULE_DIGIT ('.' RULE_DECINT*|('.' RULE_DIGIT*)? ('E'|'e') ('-'|'+')? RULE_DIGIT); + +RULE_DECINT : ('0'|'1'..'9' RULE_DIGIT*|'-' '0'..'9' RULE_DIGIT*); + +fragment RULE_DAY : ('1'..'9'|'1'..'3' '0'..'9'); + +fragment RULE_MONTH : ('1'..'9'|'1' '0'..'2'); + +fragment RULE_YEAR : '0'..'2' '0'..'9' '0'..'9' '0'..'9'; + +fragment RULE_HOUR : ('0'..'1' '0'..'9'|'2' '0'..'3'); + +fragment RULE_MIN_SEC : '0'..'5' '0'..'9'; + +RULE_DATE_TIME : RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC; + +RULE_MESSAGE_ASIGMENT : (RULE_ID|RULE_STRING) '=' (RULE_ID|RULE_STRING|RULE_INT|'-' RULE_INT); + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + +fragment 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.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/lexer/InternalRos2Lexer.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/lexer/InternalRos2Lexer.java new file mode 100644 index 000000000..807d58a73 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/lexer/InternalRos2Lexer.java @@ -0,0 +1,5509 @@ +package de.fraunhofer.ipa.ros2.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 InternalRos2Lexer extends Lexer { + public static final int Float32_1=30; + public static final int Node=93; + public static final int RULE_DATE_TIME=123; + public static final int Uint64_1=45; + public static final int String=64; + public static final int History=36; + public static final int Int16=78; + public static final int Float32=51; + public static final int Goal=89; + public static final int Bool=87; + public static final int Uint16=74; + public static final int Boolean=47; + public static final int ExternalDependency=5; + public static final int Uint8=83; + public static final int Parameters=24; + public static final int RULE_ID=109; + public static final int Actionclient=12; + public static final int RULE_DIGIT=113; + public static final int GlobalNamespace=8; + public static final int Artifacts=26; + public static final int Node_1=81; + public static final int Int16_1=53; + public static final int Header=63; + public static final int RULE_INT=124; + public static final int Byte=88; + public static final int RULE_ML_COMMENT=126; + public static final int LeftSquareBracket=103; + public static final int Specs=72; + public static final int Base64=61; + public static final int Message_1=38; + public static final int Profile=39; + public static final int Depth=69; + public static final int Comma=101; + public static final int RULE_MESSAGE_ASIGMENT=125; + public static final int Goal_1=77; + public static final int LeftSquareBracketRightSquareBracket=100; + public static final int Int32=79; + public static final int Publishers=25; + public static final int Serviceserver=11; + public static final int Parameter_qos=15; + public static final int RightCurlyBracket=105; + public static final int RULE_DECINT=116; + public static final int Reliable=40; + public static final int Uint32=75; + public static final int FromGitRepo=17; + public static final int Msg=91; + public static final int RULE_HOUR=121; + public static final int Int8=90; + public static final int Default=50; + public static final int Actionserver=13; + public static final int Int8_1=70; + public static final int Uint16_1=43; + public static final int Type=97; + public static final int Float64=52; + public static final int Int32_1=54; + public static final int Result_1=57; + public static final int Keep_all=37; + public static final int RULE_BINARY=114; + public static final int String_1=73; + public static final int Subscribers=20; + public static final int String_2=42; + public static final int RULE_BEGIN=106; + public static final int RULE_DAY=118; + public static final int Services_qos=19; + public static final int RULE_BOOLEAN=115; + public static final int RelativeNamespace=6; + public static final int RULE_YEAR=120; + public static final int Feedback_1=29; + public static final int Result=71; + public static final int Name=92; + public static final int RULE_MIN_SEC=122; + public static final int Default_qos=22; + public static final int ParameterAny=16; + public static final int List=86; + public static final int Dependencies=14; + public static final int RightSquareBracket=104; + public static final int PrivateNamespace=7; + public static final int GraphName=28; + public static final int Byte_1=68; + public static final int Float64_1=31; + public static final int Durability=23; + public static final int Duration=34; + public static final int Uint32_1=44; + public static final int Action_1=49; + public static final int Double=62; + public static final int Keep_last=32; + public static final int Type_1=82; + public static final int Value=84; + public static final int Transient_local=9; + public static final int Uint64=76; + public static final int Action=66; + public static final int RULE_END=107; + public static final int Message=56; + public static final int Time=96; + public static final int RULE_STRING=111; + public static final int Best_effort=21; + public static final int Bool_1=67; + public static final int Any=98; + public static final int Struct=65; + public static final int RULE_SL_COMMENT=108; + public static final int Uint8_1=59; + public static final int RULE_DOUBLE=117; + public static final int Feedback=35; + public static final int ParameterStructMember=4; + public static final int Srv=95; + public static final int RULE_ROS_CONVENTION_A=110; + public static final int RULE_ROS_CONVENTION_PARAM=112; + public static final int Colon=102; + public static final int EOF=-1; + public static final int Ns=99; + public static final int RULE_WS=127; + public static final int Request=41; + public static final int Int64_1=55; + public static final int Service=58; + public static final int Sensor_qos=27; + public static final int RULE_ANY_OTHER=128; + public static final int Volatile=46; + public static final int Date=85; + public static final int Response=33; + public static final int Integer=48; + public static final int Array=60; + public static final int Serviceclient=10; + public static final int Qos=94; + public static final int Int64=80; + public static final int RULE_MONTH=119; + public static final int Reliability=18; + + // delegates + // delegators + + public InternalRos2Lexer() {;} + public InternalRos2Lexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public InternalRos2Lexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "InternalRos2Lexer.g"; } + + // $ANTLR start "ParameterStructMember" + public final void mParameterStructMember() throws RecognitionException { + try { + int _type = ParameterStructMember; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:14:23: ( 'ParameterStructMember' ) + // InternalRos2Lexer.g:14:25: 'ParameterStructMember' + { + match("ParameterStructMember"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterStructMember" + + // $ANTLR start "ExternalDependency" + public final void mExternalDependency() throws RecognitionException { + try { + int _type = ExternalDependency; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:16:20: ( 'ExternalDependency' ) + // InternalRos2Lexer.g:16:22: 'ExternalDependency' + { + match("ExternalDependency"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ExternalDependency" + + // $ANTLR start "RelativeNamespace" + public final void mRelativeNamespace() throws RecognitionException { + try { + int _type = RelativeNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:18:19: ( 'RelativeNamespace' ) + // InternalRos2Lexer.g:18:21: 'RelativeNamespace' + { + match("RelativeNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RelativeNamespace" + + // $ANTLR start "PrivateNamespace" + public final void mPrivateNamespace() throws RecognitionException { + try { + int _type = PrivateNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:20:18: ( 'PrivateNamespace' ) + // InternalRos2Lexer.g:20:20: 'PrivateNamespace' + { + match("PrivateNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "PrivateNamespace" + + // $ANTLR start "GlobalNamespace" + public final void mGlobalNamespace() throws RecognitionException { + try { + int _type = GlobalNamespace; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:22:17: ( 'GlobalNamespace' ) + // InternalRos2Lexer.g:22:19: 'GlobalNamespace' + { + match("GlobalNamespace"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GlobalNamespace" + + // $ANTLR start "Transient_local" + public final void mTransient_local() throws RecognitionException { + try { + int _type = Transient_local; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:24:17: ( 'transient_local' ) + // InternalRos2Lexer.g:24:19: 'transient_local' + { + match("transient_local"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Transient_local" + + // $ANTLR start "Serviceclient" + public final void mServiceclient() throws RecognitionException { + try { + int _type = Serviceclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:26:15: ( 'serviceclient:' ) + // InternalRos2Lexer.g:26:17: 'serviceclient:' + { + match("serviceclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceclient" + + // $ANTLR start "Serviceserver" + public final void mServiceserver() throws RecognitionException { + try { + int _type = Serviceserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:28:15: ( 'serviceserver:' ) + // InternalRos2Lexer.g:28:17: 'serviceserver:' + { + match("serviceserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Serviceserver" + + // $ANTLR start "Actionclient" + public final void mActionclient() throws RecognitionException { + try { + int _type = Actionclient; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:30:14: ( 'actionclient:' ) + // InternalRos2Lexer.g:30:16: 'actionclient:' + { + match("actionclient:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionclient" + + // $ANTLR start "Actionserver" + public final void mActionserver() throws RecognitionException { + try { + int _type = Actionserver; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:32:14: ( 'actionserver:' ) + // InternalRos2Lexer.g:32:16: 'actionserver:' + { + match("actionserver:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Actionserver" + + // $ANTLR start "Dependencies" + public final void mDependencies() throws RecognitionException { + try { + int _type = Dependencies; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:34:14: ( 'dependencies:' ) + // InternalRos2Lexer.g:34:16: 'dependencies:' + { + match("dependencies:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Dependencies" + + // $ANTLR start "Parameter_qos" + public final void mParameter_qos() throws RecognitionException { + try { + int _type = Parameter_qos; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:36:15: ( 'parameter_qos' ) + // InternalRos2Lexer.g:36:17: 'parameter_qos' + { + match("parameter_qos"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Parameter_qos" + + // $ANTLR start "ParameterAny" + public final void mParameterAny() throws RecognitionException { + try { + int _type = ParameterAny; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:38:14: ( 'ParameterAny' ) + // InternalRos2Lexer.g:38:16: 'ParameterAny' + { + match("ParameterAny"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ParameterAny" + + // $ANTLR start "FromGitRepo" + public final void mFromGitRepo() throws RecognitionException { + try { + int _type = FromGitRepo; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:40:13: ( 'fromGitRepo:' ) + // InternalRos2Lexer.g:40:15: 'fromGitRepo:' + { + match("fromGitRepo:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FromGitRepo" + + // $ANTLR start "Reliability" + public final void mReliability() throws RecognitionException { + try { + int _type = Reliability; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:42:13: ( 'reliability:' ) + // InternalRos2Lexer.g:42:15: 'reliability:' + { + match("reliability:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Reliability" + + // $ANTLR start "Services_qos" + public final void mServices_qos() throws RecognitionException { + try { + int _type = Services_qos; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:44:14: ( 'services_qos' ) + // InternalRos2Lexer.g:44:16: 'services_qos' + { + match("services_qos"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Services_qos" + + // $ANTLR start "Subscribers" + public final void mSubscribers() throws RecognitionException { + try { + int _type = Subscribers; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:46:13: ( 'subscribers:' ) + // InternalRos2Lexer.g:46:15: 'subscribers:' + { + match("subscribers:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Subscribers" + + // $ANTLR start "Best_effort" + public final void mBest_effort() throws RecognitionException { + try { + int _type = Best_effort; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:48:13: ( 'best_effort' ) + // InternalRos2Lexer.g:48:15: 'best_effort' + { + match("best_effort"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Best_effort" + + // $ANTLR start "Default_qos" + public final void mDefault_qos() throws RecognitionException { + try { + int _type = Default_qos; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:50:13: ( 'default_qos' ) + // InternalRos2Lexer.g:50:15: 'default_qos' + { + match("default_qos"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Default_qos" + + // $ANTLR start "Durability" + public final void mDurability() throws RecognitionException { + try { + int _type = Durability; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:52:12: ( 'durability:' ) + // InternalRos2Lexer.g:52:14: 'durability:' + { + match("durability:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Durability" + + // $ANTLR start "Parameters" + public final void mParameters() throws RecognitionException { + try { + int _type = Parameters; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:54:12: ( 'parameters:' ) + // InternalRos2Lexer.g:54: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; + // InternalRos2Lexer.g:56:12: ( 'publishers:' ) + // InternalRos2Lexer.g:56: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; + // InternalRos2Lexer.g:58:11: ( 'artifacts:' ) + // InternalRos2Lexer.g:58:13: 'artifacts:' + { + match("artifacts:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Artifacts" + + // $ANTLR start "Sensor_qos" + public final void mSensor_qos() throws RecognitionException { + try { + int _type = Sensor_qos; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:60:12: ( 'sensor_qos' ) + // InternalRos2Lexer.g:60:14: 'sensor_qos' + { + match("sensor_qos"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Sensor_qos" + + // $ANTLR start "GraphName" + public final void mGraphName() throws RecognitionException { + try { + int _type = GraphName; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:62:11: ( 'GraphName' ) + // InternalRos2Lexer.g:62:13: 'GraphName' + { + match("GraphName"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "GraphName" + + // $ANTLR start "Feedback_1" + public final void mFeedback_1() throws RecognitionException { + try { + int _type = Feedback_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:64:12: ( 'feedback:' ) + // InternalRos2Lexer.g:64:14: 'feedback:' + { + match("feedback:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback_1" + + // $ANTLR start "Float32_1" + public final void mFloat32_1() throws RecognitionException { + try { + int _type = Float32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:66:11: ( 'float32[]' ) + // InternalRos2Lexer.g:66:13: 'float32[]' + { + match("float32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32_1" + + // $ANTLR start "Float64_1" + public final void mFloat64_1() throws RecognitionException { + try { + int _type = Float64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:68:11: ( 'float64[]' ) + // InternalRos2Lexer.g:68:13: 'float64[]' + { + match("float64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64_1" + + // $ANTLR start "Keep_last" + public final void mKeep_last() throws RecognitionException { + try { + int _type = Keep_last; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:70:11: ( 'keep_last' ) + // InternalRos2Lexer.g:70:13: 'keep_last' + { + match("keep_last"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Keep_last" + + // $ANTLR start "Response" + public final void mResponse() throws RecognitionException { + try { + int _type = Response; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:72:10: ( 'response:' ) + // InternalRos2Lexer.g:72:12: 'response:' + { + match("response:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Response" + + // $ANTLR start "Duration" + public final void mDuration() throws RecognitionException { + try { + int _type = Duration; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:74:10: ( 'duration' ) + // InternalRos2Lexer.g:74:12: 'duration' + { + match("duration"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Duration" + + // $ANTLR start "Feedback" + public final void mFeedback() throws RecognitionException { + try { + int _type = Feedback; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:76:10: ( 'feedback' ) + // InternalRos2Lexer.g:76:12: 'feedback' + { + match("feedback"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Feedback" + + // $ANTLR start "History" + public final void mHistory() throws RecognitionException { + try { + int _type = History; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:78:9: ( 'history:' ) + // InternalRos2Lexer.g:78:11: 'history:' + { + match("history:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "History" + + // $ANTLR start "Keep_all" + public final void mKeep_all() throws RecognitionException { + try { + int _type = Keep_all; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:80:10: ( 'keep_all' ) + // InternalRos2Lexer.g:80:12: 'keep_all' + { + match("keep_all"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Keep_all" + + // $ANTLR start "Message_1" + public final void mMessage_1() throws RecognitionException { + try { + int _type = Message_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:82:11: ( 'message:' ) + // InternalRos2Lexer.g:82:13: 'message:' + { + match("message:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message_1" + + // $ANTLR start "Profile" + public final void mProfile() throws RecognitionException { + try { + int _type = Profile; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:84:9: ( 'profile:' ) + // InternalRos2Lexer.g:84:11: 'profile:' + { + match("profile:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Profile" + + // $ANTLR start "Reliable" + public final void mReliable() throws RecognitionException { + try { + int _type = Reliable; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:86:10: ( 'reliable' ) + // InternalRos2Lexer.g:86:12: 'reliable' + { + match("reliable"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Reliable" + + // $ANTLR start "Request" + public final void mRequest() throws RecognitionException { + try { + int _type = Request; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:88:9: ( 'request:' ) + // InternalRos2Lexer.g:88:11: 'request:' + { + match("request:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Request" + + // $ANTLR start "String_2" + public final void mString_2() throws RecognitionException { + try { + int _type = String_2; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:90:10: ( 'string[]' ) + // InternalRos2Lexer.g:90:12: 'string[]' + { + match("string[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_2" + + // $ANTLR start "Uint16_1" + public final void mUint16_1() throws RecognitionException { + try { + int _type = Uint16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:92:10: ( 'uint16[]' ) + // InternalRos2Lexer.g:92:12: 'uint16[]' + { + match("uint16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16_1" + + // $ANTLR start "Uint32_1" + public final void mUint32_1() throws RecognitionException { + try { + int _type = Uint32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:94:10: ( 'uint32[]' ) + // InternalRos2Lexer.g:94:12: 'uint32[]' + { + match("uint32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32_1" + + // $ANTLR start "Uint64_1" + public final void mUint64_1() throws RecognitionException { + try { + int _type = Uint64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:96:10: ( 'uint64[]' ) + // InternalRos2Lexer.g:96:12: 'uint64[]' + { + match("uint64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64_1" + + // $ANTLR start "Volatile" + public final void mVolatile() throws RecognitionException { + try { + int _type = Volatile; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:98:10: ( 'volatile' ) + // InternalRos2Lexer.g:98:12: 'volatile' + { + match("volatile"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Volatile" + + // $ANTLR start "Boolean" + public final void mBoolean() throws RecognitionException { + try { + int _type = Boolean; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:100:9: ( 'Boolean' ) + // InternalRos2Lexer.g:100:11: 'Boolean' + { + match("Boolean"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Boolean" + + // $ANTLR start "Integer" + public final void mInteger() throws RecognitionException { + try { + int _type = Integer; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:102:9: ( 'Integer' ) + // InternalRos2Lexer.g:102:11: 'Integer' + { + match("Integer"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Integer" + + // $ANTLR start "Action_1" + public final void mAction_1() throws RecognitionException { + try { + int _type = Action_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:104:10: ( 'action:' ) + // InternalRos2Lexer.g:104:12: 'action:' + { + match("action:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action_1" + + // $ANTLR start "Default" + public final void mDefault() throws RecognitionException { + try { + int _type = Default; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:106:9: ( 'default' ) + // InternalRos2Lexer.g:106:11: 'default' + { + match("default"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Default" + + // $ANTLR start "Float32" + public final void mFloat32() throws RecognitionException { + try { + int _type = Float32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:108:9: ( 'float32' ) + // InternalRos2Lexer.g:108:11: 'float32' + { + match("float32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float32" + + // $ANTLR start "Float64" + public final void mFloat64() throws RecognitionException { + try { + int _type = Float64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:110:9: ( 'float64' ) + // InternalRos2Lexer.g:110:11: 'float64' + { + match("float64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Float64" + + // $ANTLR start "Int16_1" + public final void mInt16_1() throws RecognitionException { + try { + int _type = Int16_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:112:9: ( 'int16[]' ) + // InternalRos2Lexer.g:112:11: 'int16[]' + { + match("int16[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16_1" + + // $ANTLR start "Int32_1" + public final void mInt32_1() throws RecognitionException { + try { + int _type = Int32_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:114:9: ( 'int32[]' ) + // InternalRos2Lexer.g:114:11: 'int32[]' + { + match("int32[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32_1" + + // $ANTLR start "Int64_1" + public final void mInt64_1() throws RecognitionException { + try { + int _type = Int64_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:116:9: ( 'int64[]' ) + // InternalRos2Lexer.g:116:11: 'int64[]' + { + match("int64[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64_1" + + // $ANTLR start "Message" + public final void mMessage() throws RecognitionException { + try { + int _type = Message; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:118:9: ( 'message' ) + // InternalRos2Lexer.g:118:11: 'message' + { + match("message"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Message" + + // $ANTLR start "Result_1" + public final void mResult_1() throws RecognitionException { + try { + int _type = Result_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:120:10: ( 'result:' ) + // InternalRos2Lexer.g:120:12: 'result:' + { + match("result:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result_1" + + // $ANTLR start "Service" + public final void mService() throws RecognitionException { + try { + int _type = Service; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:122:9: ( 'service' ) + // InternalRos2Lexer.g:122:11: 'service' + { + match("service"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Service" + + // $ANTLR start "Uint8_1" + public final void mUint8_1() throws RecognitionException { + try { + int _type = Uint8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:124:9: ( 'uint8[]' ) + // InternalRos2Lexer.g:124:11: 'uint8[]' + { + match("uint8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8_1" + + // $ANTLR start "Array" + public final void mArray() throws RecognitionException { + try { + int _type = Array; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:126:7: ( 'Array:' ) + // InternalRos2Lexer.g:126:9: 'Array:' + { + match("Array:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Array" + + // $ANTLR start "Base64" + public final void mBase64() throws RecognitionException { + try { + int _type = Base64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:128:8: ( 'Base64' ) + // InternalRos2Lexer.g:128:10: 'Base64' + { + match("Base64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Base64" + + // $ANTLR start "Double" + public final void mDouble() throws RecognitionException { + try { + int _type = Double; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:130:8: ( 'Double' ) + // InternalRos2Lexer.g:130:10: 'Double' + { + match("Double"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Double" + + // $ANTLR start "Header" + public final void mHeader() throws RecognitionException { + try { + int _type = Header; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:132:8: ( 'Header' ) + // InternalRos2Lexer.g:132:10: 'Header' + { + match("Header"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Header" + + // $ANTLR start "String" + public final void mString() throws RecognitionException { + try { + int _type = String; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:134:8: ( 'String' ) + // InternalRos2Lexer.g:134:10: 'String' + { + match("String"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String" + + // $ANTLR start "Struct" + public final void mStruct() throws RecognitionException { + try { + int _type = Struct; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:136:8: ( 'Struct' ) + // InternalRos2Lexer.g:136:10: 'Struct' + { + match("Struct"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Struct" + + // $ANTLR start "Action" + public final void mAction() throws RecognitionException { + try { + int _type = Action; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:138:8: ( 'action' ) + // InternalRos2Lexer.g:138:10: 'action' + { + match("action"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Action" + + // $ANTLR start "Bool_1" + public final void mBool_1() throws RecognitionException { + try { + int _type = Bool_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:140:8: ( 'bool[]' ) + // InternalRos2Lexer.g:140:10: 'bool[]' + { + match("bool[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool_1" + + // $ANTLR start "Byte_1" + public final void mByte_1() throws RecognitionException { + try { + int _type = Byte_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:142:8: ( 'byte[]' ) + // InternalRos2Lexer.g:142:10: 'byte[]' + { + match("byte[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte_1" + + // $ANTLR start "Depth" + public final void mDepth() throws RecognitionException { + try { + int _type = Depth; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:144:7: ( 'depth:' ) + // InternalRos2Lexer.g:144:9: 'depth:' + { + match("depth:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Depth" + + // $ANTLR start "Int8_1" + public final void mInt8_1() throws RecognitionException { + try { + int _type = Int8_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:146:8: ( 'int8[]' ) + // InternalRos2Lexer.g:146:10: 'int8[]' + { + match("int8[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8_1" + + // $ANTLR start "Result" + public final void mResult() throws RecognitionException { + try { + int _type = Result; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:148:8: ( 'result' ) + // InternalRos2Lexer.g:148:10: 'result' + { + match("result"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Result" + + // $ANTLR start "Specs" + public final void mSpecs() throws RecognitionException { + try { + int _type = Specs; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:150:7: ( 'specs:' ) + // InternalRos2Lexer.g:150:9: 'specs:' + { + match("specs:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Specs" + + // $ANTLR start "String_1" + public final void mString_1() throws RecognitionException { + try { + int _type = String_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:152:10: ( 'string' ) + // InternalRos2Lexer.g:152:12: 'string' + { + match("string"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "String_1" + + // $ANTLR start "Uint16" + public final void mUint16() throws RecognitionException { + try { + int _type = Uint16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:154:8: ( 'uint16' ) + // InternalRos2Lexer.g:154:10: 'uint16' + { + match("uint16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint16" + + // $ANTLR start "Uint32" + public final void mUint32() throws RecognitionException { + try { + int _type = Uint32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:156:8: ( 'uint32' ) + // InternalRos2Lexer.g:156:10: 'uint32' + { + match("uint32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint32" + + // $ANTLR start "Uint64" + public final void mUint64() throws RecognitionException { + try { + int _type = Uint64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:158:8: ( 'uint64' ) + // InternalRos2Lexer.g:158:10: 'uint64' + { + match("uint64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint64" + + // $ANTLR start "Goal_1" + public final void mGoal_1() throws RecognitionException { + try { + int _type = Goal_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:160:8: ( 'goal:' ) + // InternalRos2Lexer.g:160:10: 'goal:' + { + match("goal:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal_1" + + // $ANTLR start "Int16" + public final void mInt16() throws RecognitionException { + try { + int _type = Int16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:162:7: ( 'int16' ) + // InternalRos2Lexer.g:162:9: 'int16' + { + match("int16"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int16" + + // $ANTLR start "Int32" + public final void mInt32() throws RecognitionException { + try { + int _type = Int32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:164:7: ( 'int32' ) + // InternalRos2Lexer.g:164:9: 'int32' + { + match("int32"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int32" + + // $ANTLR start "Int64" + public final void mInt64() throws RecognitionException { + try { + int _type = Int64; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:166:7: ( 'int64' ) + // InternalRos2Lexer.g:166:9: 'int64' + { + match("int64"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int64" + + // $ANTLR start "Node_1" + public final void mNode_1() throws RecognitionException { + try { + int _type = Node_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:168:8: ( 'node:' ) + // InternalRos2Lexer.g:168:10: 'node:' + { + match("node:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node_1" + + // $ANTLR start "Type_1" + public final void mType_1() throws RecognitionException { + try { + int _type = Type_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:170:8: ( 'type:' ) + // InternalRos2Lexer.g:170:10: 'type:' + { + match("type:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type_1" + + // $ANTLR start "Uint8" + public final void mUint8() throws RecognitionException { + try { + int _type = Uint8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:172:7: ( 'uint8' ) + // InternalRos2Lexer.g:172:9: 'uint8' + { + match("uint8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Uint8" + + // $ANTLR start "Value" + public final void mValue() throws RecognitionException { + try { + int _type = Value; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:174:7: ( 'value' ) + // InternalRos2Lexer.g:174:9: 'value' + { + match("value"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Value" + + // $ANTLR start "Date" + public final void mDate() throws RecognitionException { + try { + int _type = Date; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:176:6: ( 'Date' ) + // InternalRos2Lexer.g:176:8: 'Date' + { + match("Date"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Date" + + // $ANTLR start "List" + public final void mList() throws RecognitionException { + try { + int _type = List; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:178:6: ( 'List' ) + // InternalRos2Lexer.g:178:8: 'List' + { + match("List"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "List" + + // $ANTLR start "Bool" + public final void mBool() throws RecognitionException { + try { + int _type = Bool; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:180:6: ( 'bool' ) + // InternalRos2Lexer.g:180:8: 'bool' + { + match("bool"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Bool" + + // $ANTLR start "Byte" + public final void mByte() throws RecognitionException { + try { + int _type = Byte; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:182:6: ( 'byte' ) + // InternalRos2Lexer.g:182:8: 'byte' + { + match("byte"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Byte" + + // $ANTLR start "Goal" + public final void mGoal() throws RecognitionException { + try { + int _type = Goal; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:184:6: ( 'goal' ) + // InternalRos2Lexer.g:184:8: 'goal' + { + match("goal"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Goal" + + // $ANTLR start "Int8" + public final void mInt8() throws RecognitionException { + try { + int _type = Int8; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:186:6: ( 'int8' ) + // InternalRos2Lexer.g:186:8: 'int8' + { + match("int8"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Int8" + + // $ANTLR start "Msg" + public final void mMsg() throws RecognitionException { + try { + int _type = Msg; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:188:5: ( 'msg:' ) + // InternalRos2Lexer.g:188:7: 'msg:' + { + match("msg:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Msg" + + // $ANTLR start "Name" + public final void mName() throws RecognitionException { + try { + int _type = Name; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:190:6: ( 'name' ) + // InternalRos2Lexer.g:190:8: 'name' + { + match("name"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Name" + + // $ANTLR start "Node" + public final void mNode() throws RecognitionException { + try { + int _type = Node; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:192:6: ( 'node' ) + // InternalRos2Lexer.g:192:8: 'node' + { + match("node"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node" + + // $ANTLR start "Qos" + public final void mQos() throws RecognitionException { + try { + int _type = Qos; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:194:5: ( 'qos:' ) + // InternalRos2Lexer.g:194:7: 'qos:' + { + match("qos:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Qos" + + // $ANTLR start "Srv" + public final void mSrv() throws RecognitionException { + try { + int _type = Srv; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:196:5: ( 'srv:' ) + // InternalRos2Lexer.g:196:7: 'srv:' + { + match("srv:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Srv" + + // $ANTLR start "Time" + public final void mTime() throws RecognitionException { + try { + int _type = Time; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:198:6: ( 'time' ) + // InternalRos2Lexer.g:198:8: 'time' + { + match("time"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Time" + + // $ANTLR start "Type" + public final void mType() throws RecognitionException { + try { + int _type = Type; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:200:6: ( 'type' ) + // InternalRos2Lexer.g:200:8: 'type' + { + match("type"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type" + + // $ANTLR start "Any" + public final void mAny() throws RecognitionException { + try { + int _type = Any; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:202:5: ( 'Any' ) + // InternalRos2Lexer.g:202:7: 'Any' + { + match("Any"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Any" + + // $ANTLR start "Ns" + public final void mNs() throws RecognitionException { + try { + int _type = Ns; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:204:4: ( 'ns:' ) + // InternalRos2Lexer.g:204:6: 'ns:' + { + match("ns:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Ns" + + // $ANTLR start "LeftSquareBracketRightSquareBracket" + public final void mLeftSquareBracketRightSquareBracket() throws RecognitionException { + try { + int _type = LeftSquareBracketRightSquareBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:206:37: ( '[]' ) + // InternalRos2Lexer.g:206:39: '[]' + { + match("[]"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LeftSquareBracketRightSquareBracket" + + // $ANTLR start "Comma" + public final void mComma() throws RecognitionException { + try { + int _type = Comma; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:208:7: ( ',' ) + // InternalRos2Lexer.g:208: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; + // InternalRos2Lexer.g:210:7: ( ':' ) + // InternalRos2Lexer.g:210: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; + // InternalRos2Lexer.g:212:19: ( '[' ) + // InternalRos2Lexer.g:212: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; + // InternalRos2Lexer.g:214:20: ( ']' ) + // InternalRos2Lexer.g:214: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; + // InternalRos2Lexer.g:216:19: ( '}' ) + // InternalRos2Lexer.g:216:21: '}' + { + match('}'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RightCurlyBracket" + + // $ANTLR start "RULE_BEGIN" + public final void mRULE_BEGIN() throws RecognitionException { + try { + // InternalRos2Lexer.g:218:21: () + // InternalRos2Lexer.g:218:23: + { + } + + } + finally { + } + } + // $ANTLR end "RULE_BEGIN" + + // $ANTLR start "RULE_END" + public final void mRULE_END() throws RecognitionException { + try { + // InternalRos2Lexer.g:220:19: () + // InternalRos2Lexer.g:220: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; + // InternalRos2Lexer.g:222:17: ( '#' (~ ( ( '\\n' | '\\r' ) ) )* ) + // InternalRos2Lexer.g:222:19: '#' (~ ( ( '\\n' | '\\r' ) ) )* + { + match('#'); + // InternalRos2Lexer.g:222: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 : + // InternalRos2Lexer.g:222: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; + // InternalRos2Lexer.g:224:23: ( ( '/' RULE_ID | RULE_ID '/' )* ) + // InternalRos2Lexer.g:224:25: ( '/' RULE_ID | RULE_ID '/' )* + { + // InternalRos2Lexer.g:224: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 : + // InternalRos2Lexer.g:224:26: '/' RULE_ID + { + match('/'); + mRULE_ID(); + + } + break; + case 2 : + // InternalRos2Lexer.g:224: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; + // InternalRos2Lexer.g:226:27: ( ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* ) + // InternalRos2Lexer.g:226:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* + { + // InternalRos2Lexer.g:226: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 : + // InternalRos2Lexer.g:226:30: '/' RULE_STRING + { + match('/'); + mRULE_STRING(); + + } + break; + case 2 : + // InternalRos2Lexer.g:226:46: RULE_STRING '/' + { + mRULE_STRING(); + match('/'); + + } + break; + case 3 : + // InternalRos2Lexer.g:226: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_DIGIT" + public final void mRULE_DIGIT() throws RecognitionException { + try { + // InternalRos2Lexer.g:228:21: ( '0' .. '9' ) + // InternalRos2Lexer.g:228:23: '0' .. '9' + { + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_DIGIT" + + // $ANTLR start "RULE_BINARY" + public final void mRULE_BINARY() throws RecognitionException { + try { + int _type = RULE_BINARY; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:230:13: ( ( '0b' | '0B' ) ( '0' | '1' )+ ) + // InternalRos2Lexer.g:230:15: ( '0b' | '0B' ) ( '0' | '1' )+ + { + // InternalRos2Lexer.g:230:15: ( '0b' | '0B' ) + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0=='0') ) { + int LA4_1 = input.LA(2); + + if ( (LA4_1=='b') ) { + alt4=1; + } + else if ( (LA4_1=='B') ) { + alt4=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + switch (alt4) { + case 1 : + // InternalRos2Lexer.g:230:16: '0b' + { + match("0b"); + + + } + break; + case 2 : + // InternalRos2Lexer.g:230:21: '0B' + { + match("0B"); + + + } + break; + + } + + // InternalRos2Lexer.g:230:27: ( '0' | '1' )+ + int cnt5=0; + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( ((LA5_0>='0' && LA5_0<='1')) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalRos2Lexer.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='1') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt5 >= 1 ) break loop5; + EarlyExitException eee = + new EarlyExitException(5, input); + throw eee; + } + cnt5++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BINARY" + + // $ANTLR start "RULE_BOOLEAN" + public final void mRULE_BOOLEAN() throws RecognitionException { + try { + int _type = RULE_BOOLEAN; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:232:14: ( ( 'true' | 'false' ) ) + // InternalRos2Lexer.g:232:16: ( 'true' | 'false' ) + { + // InternalRos2Lexer.g:232:16: ( 'true' | 'false' ) + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='t') ) { + alt6=1; + } + else if ( (LA6_0=='f') ) { + alt6=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + switch (alt6) { + case 1 : + // InternalRos2Lexer.g:232:17: 'true' + { + match("true"); + + + } + break; + case 2 : + // InternalRos2Lexer.g:232:24: 'false' + { + match("false"); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_BOOLEAN" + + // $ANTLR start "RULE_DOUBLE" + public final void mRULE_DOUBLE() throws RecognitionException { + try { + int _type = RULE_DOUBLE; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:234:13: ( RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) ) + // InternalRos2Lexer.g:234:15: RULE_DIGIT ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + { + mRULE_DIGIT(); + // InternalRos2Lexer.g:234:26: ( '.' ( RULE_DECINT )* | ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT ) + int alt11=2; + alt11 = dfa11.predict(input); + switch (alt11) { + case 1 : + // InternalRos2Lexer.g:234:27: '.' ( RULE_DECINT )* + { + match('.'); + // InternalRos2Lexer.g:234:31: ( RULE_DECINT )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0=='-'||(LA7_0>='0' && LA7_0<='9')) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalRos2Lexer.g:234:31: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + + default : + break loop7; + } + } while (true); + + + } + break; + case 2 : + // InternalRos2Lexer.g:234:44: ( '.' ( RULE_DIGIT )* )? ( 'E' | 'e' ) ( '-' | '+' )? RULE_DIGIT + { + // InternalRos2Lexer.g:234:44: ( '.' ( RULE_DIGIT )* )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='.') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalRos2Lexer.g:234:45: '.' ( RULE_DIGIT )* + { + match('.'); + // InternalRos2Lexer.g:234:49: ( RULE_DIGIT )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( ((LA8_0>='0' && LA8_0<='9')) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // InternalRos2Lexer.g:234:49: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop8; + } + } while (true); + + + } + break; + + } + + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalRos2Lexer.g:234:73: ( '-' | '+' )? + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='+'||LA10_0=='-') ) { + alt10=1; + } + switch (alt10) { + case 1 : + // InternalRos2Lexer.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_DIGIT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DOUBLE" + + // $ANTLR start "RULE_DECINT" + public final void mRULE_DECINT() throws RecognitionException { + try { + int _type = RULE_DECINT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:236:13: ( ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) ) + // InternalRos2Lexer.g:236:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + { + // InternalRos2Lexer.g:236:15: ( '0' | '1' .. '9' ( RULE_DIGIT )* | '-' '0' .. '9' ( RULE_DIGIT )* ) + int alt14=3; + switch ( input.LA(1) ) { + case '0': + { + alt14=1; + } + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt14=2; + } + break; + case '-': + { + alt14=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + + throw nvae; + } + + switch (alt14) { + case 1 : + // InternalRos2Lexer.g:236:16: '0' + { + match('0'); + + } + break; + case 2 : + // InternalRos2Lexer.g:236:20: '1' .. '9' ( RULE_DIGIT )* + { + matchRange('1','9'); + // InternalRos2Lexer.g:236:29: ( RULE_DIGIT )* + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( ((LA12_0>='0' && LA12_0<='9')) ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalRos2Lexer.g:236:29: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop12; + } + } while (true); + + + } + break; + case 3 : + // InternalRos2Lexer.g:236:41: '-' '0' .. '9' ( RULE_DIGIT )* + { + match('-'); + matchRange('0','9'); + // InternalRos2Lexer.g:236:54: ( RULE_DIGIT )* + loop13: + do { + int alt13=2; + int LA13_0 = input.LA(1); + + if ( ((LA13_0>='0' && LA13_0<='9')) ) { + alt13=1; + } + + + switch (alt13) { + case 1 : + // InternalRos2Lexer.g:236:54: RULE_DIGIT + { + mRULE_DIGIT(); + + } + break; + + default : + break loop13; + } + } while (true); + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DECINT" + + // $ANTLR start "RULE_DAY" + public final void mRULE_DAY() throws RecognitionException { + try { + // InternalRos2Lexer.g:238:19: ( ( '1' .. '9' | '1' .. '3' '0' .. '9' ) ) + // InternalRos2Lexer.g:238:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + { + // InternalRos2Lexer.g:238:21: ( '1' .. '9' | '1' .. '3' '0' .. '9' ) + int alt15=2; + int LA15_0 = input.LA(1); + + if ( ((LA15_0>='1' && LA15_0<='3')) ) { + int LA15_1 = input.LA(2); + + if ( ((LA15_1>='0' && LA15_1<='9')) ) { + alt15=2; + } + else { + alt15=1;} + } + else if ( ((LA15_0>='4' && LA15_0<='9')) ) { + alt15=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + + throw nvae; + } + switch (alt15) { + case 1 : + // InternalRos2Lexer.g:238:22: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRos2Lexer.g:238:31: '1' .. '3' '0' .. '9' + { + matchRange('1','3'); + matchRange('0','9'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_DAY" + + // $ANTLR start "RULE_MONTH" + public final void mRULE_MONTH() throws RecognitionException { + try { + // InternalRos2Lexer.g:240:21: ( ( '1' .. '9' | '1' '0' .. '2' ) ) + // InternalRos2Lexer.g:240:23: ( '1' .. '9' | '1' '0' .. '2' ) + { + // InternalRos2Lexer.g:240:23: ( '1' .. '9' | '1' '0' .. '2' ) + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='1') ) { + int LA16_1 = input.LA(2); + + if ( ((LA16_1>='0' && LA16_1<='2')) ) { + alt16=2; + } + else { + alt16=1;} + } + else if ( ((LA16_0>='2' && LA16_0<='9')) ) { + alt16=1; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + + throw nvae; + } + switch (alt16) { + case 1 : + // InternalRos2Lexer.g:240:24: '1' .. '9' + { + matchRange('1','9'); + + } + break; + case 2 : + // InternalRos2Lexer.g:240:33: '1' '0' .. '2' + { + match('1'); + matchRange('0','2'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_MONTH" + + // $ANTLR start "RULE_YEAR" + public final void mRULE_YEAR() throws RecognitionException { + try { + // InternalRos2Lexer.g:242:20: ( '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' ) + // InternalRos2Lexer.g:242:22: '0' .. '2' '0' .. '9' '0' .. '9' '0' .. '9' + { + matchRange('0','2'); + matchRange('0','9'); + matchRange('0','9'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_YEAR" + + // $ANTLR start "RULE_HOUR" + public final void mRULE_HOUR() throws RecognitionException { + try { + // InternalRos2Lexer.g:244:20: ( ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) ) + // InternalRos2Lexer.g:244:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + { + // InternalRos2Lexer.g:244:22: ( '0' .. '1' '0' .. '9' | '2' '0' .. '3' ) + int alt17=2; + int LA17_0 = input.LA(1); + + if ( ((LA17_0>='0' && LA17_0<='1')) ) { + alt17=1; + } + else if ( (LA17_0=='2') ) { + alt17=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); + + throw nvae; + } + switch (alt17) { + case 1 : + // InternalRos2Lexer.g:244:23: '0' .. '1' '0' .. '9' + { + matchRange('0','1'); + matchRange('0','9'); + + } + break; + case 2 : + // InternalRos2Lexer.g:244:41: '2' '0' .. '3' + { + match('2'); + matchRange('0','3'); + + } + break; + + } + + + } + + } + finally { + } + } + // $ANTLR end "RULE_HOUR" + + // $ANTLR start "RULE_MIN_SEC" + public final void mRULE_MIN_SEC() throws RecognitionException { + try { + // InternalRos2Lexer.g:246:23: ( '0' .. '5' '0' .. '9' ) + // InternalRos2Lexer.g:246:25: '0' .. '5' '0' .. '9' + { + matchRange('0','5'); + matchRange('0','9'); + + } + + } + finally { + } + } + // $ANTLR end "RULE_MIN_SEC" + + // $ANTLR start "RULE_DATE_TIME" + public final void mRULE_DATE_TIME() throws RecognitionException { + try { + int _type = RULE_DATE_TIME; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:248:16: ( RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC ) + // InternalRos2Lexer.g:248:18: RULE_YEAR '-' RULE_MONTH '-' RULE_DAY 'T' RULE_HOUR ':' RULE_MIN_SEC ':' RULE_MIN_SEC + { + mRULE_YEAR(); + match('-'); + mRULE_MONTH(); + match('-'); + mRULE_DAY(); + match('T'); + mRULE_HOUR(); + match(':'); + mRULE_MIN_SEC(); + match(':'); + mRULE_MIN_SEC(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DATE_TIME" + + // $ANTLR start "RULE_MESSAGE_ASIGMENT" + public final void mRULE_MESSAGE_ASIGMENT() throws RecognitionException { + try { + int _type = RULE_MESSAGE_ASIGMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:250:23: ( ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) ) + // InternalRos2Lexer.g:250:25: ( RULE_ID | RULE_STRING ) '=' ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + { + // InternalRos2Lexer.g:250:25: ( RULE_ID | RULE_STRING ) + int alt18=2; + int LA18_0 = input.LA(1); + + if ( ((LA18_0>='A' && LA18_0<='Z')||(LA18_0>='^' && LA18_0<='_')||(LA18_0>='a' && LA18_0<='z')) ) { + alt18=1; + } + else if ( (LA18_0=='\"'||LA18_0=='\'') ) { + alt18=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + + throw nvae; + } + switch (alt18) { + case 1 : + // InternalRos2Lexer.g:250:26: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRos2Lexer.g:250:34: RULE_STRING + { + mRULE_STRING(); + + } + break; + + } + + match('='); + // InternalRos2Lexer.g:250:51: ( RULE_ID | RULE_STRING | RULE_INT | '-' RULE_INT ) + int alt19=4; + switch ( input.LA(1) ) { + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + case 'G': + case 'H': + case 'I': + case 'J': + case 'K': + case 'L': + case 'M': + case 'N': + case 'O': + case 'P': + case 'Q': + case 'R': + case 'S': + case 'T': + case 'U': + case 'V': + case 'W': + case 'X': + case 'Y': + case 'Z': + case '^': + case '_': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'g': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': + { + alt19=1; + } + break; + case '\"': + case '\'': + { + alt19=2; + } + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt19=3; + } + break; + case '-': + { + alt19=4; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 19, 0, input); + + throw nvae; + } + + switch (alt19) { + case 1 : + // InternalRos2Lexer.g:250:52: RULE_ID + { + mRULE_ID(); + + } + break; + case 2 : + // InternalRos2Lexer.g:250:60: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 3 : + // InternalRos2Lexer.g:250:72: RULE_INT + { + mRULE_INT(); + + } + break; + case 4 : + // InternalRos2Lexer.g:250:81: '-' RULE_INT + { + match('-'); + mRULE_INT(); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_MESSAGE_ASIGMENT" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos2Lexer.g:252:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // InternalRos2Lexer.g:252:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + // InternalRos2Lexer.g:252:11: ( '^' )? + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0=='^') ) { + alt20=1; + } + switch (alt20) { + case 1 : + // InternalRos2Lexer.g:252: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;} + + // InternalRos2Lexer.g:252:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop21: + do { + int alt21=2; + int LA21_0 = input.LA(1); + + if ( ((LA21_0>='0' && LA21_0<='9')||(LA21_0>='A' && LA21_0<='Z')||LA21_0=='_'||(LA21_0>='a' && LA21_0<='z')) ) { + alt21=1; + } + + + switch (alt21) { + case 1 : + // InternalRos2Lexer.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 loop21; + } + } 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 { + // InternalRos2Lexer.g:254:19: ( ( '0' .. '9' )+ ) + // InternalRos2Lexer.g:254:21: ( '0' .. '9' )+ + { + // InternalRos2Lexer.g:254:21: ( '0' .. '9' )+ + int cnt22=0; + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( ((LA22_0>='0' && LA22_0<='9')) ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalRos2Lexer.g:254:22: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt22 >= 1 ) break loop22; + EarlyExitException eee = + new EarlyExitException(22, input); + throw eee; + } + cnt22++; + } while (true); + + + } + + } + 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; + // InternalRos2Lexer.g:256:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) + // InternalRos2Lexer.g:256:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + { + // InternalRos2Lexer.g:256:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0=='\"') ) { + alt25=1; + } + else if ( (LA25_0=='\'') ) { + alt25=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); + + throw nvae; + } + switch (alt25) { + case 1 : + // InternalRos2Lexer.g:256:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + { + match('\"'); + // InternalRos2Lexer.g:256:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop23: + do { + int alt23=3; + int LA23_0 = input.LA(1); + + if ( (LA23_0=='\\') ) { + alt23=1; + } + else if ( ((LA23_0>='\u0000' && LA23_0<='!')||(LA23_0>='#' && LA23_0<='[')||(LA23_0>=']' && LA23_0<='\uFFFF')) ) { + alt23=2; + } + + + switch (alt23) { + case 1 : + // InternalRos2Lexer.g:256:21: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos2Lexer.g:256: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 loop23; + } + } while (true); + + match('\"'); + + } + break; + case 2 : + // InternalRos2Lexer.g:256:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + { + match('\''); + // InternalRos2Lexer.g:256:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop24: + do { + int alt24=3; + int LA24_0 = input.LA(1); + + if ( (LA24_0=='\\') ) { + alt24=1; + } + else if ( ((LA24_0>='\u0000' && LA24_0<='&')||(LA24_0>='(' && LA24_0<='[')||(LA24_0>=']' && LA24_0<='\uFFFF')) ) { + alt24=2; + } + + + switch (alt24) { + case 1 : + // InternalRos2Lexer.g:256:54: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos2Lexer.g:256: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 loop24; + } + } 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; + // InternalRos2Lexer.g:258:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalRos2Lexer.g:258:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalRos2Lexer.g:258:24: ( options {greedy=false; } : . )* + loop26: + do { + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0=='*') ) { + int LA26_1 = input.LA(2); + + if ( (LA26_1=='/') ) { + alt26=2; + } + else if ( ((LA26_1>='\u0000' && LA26_1<='.')||(LA26_1>='0' && LA26_1<='\uFFFF')) ) { + alt26=1; + } + + + } + else if ( ((LA26_0>='\u0000' && LA26_0<=')')||(LA26_0>='+' && LA26_0<='\uFFFF')) ) { + alt26=1; + } + + + switch (alt26) { + case 1 : + // InternalRos2Lexer.g:258:52: . + { + matchAny(); + + } + break; + + default : + break loop26; + } + } 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; + // InternalRos2Lexer.g:260:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalRos2Lexer.g:260:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalRos2Lexer.g:260:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt27=0; + loop27: + do { + int alt27=2; + int LA27_0 = input.LA(1); + + if ( ((LA27_0>='\t' && LA27_0<='\n')||LA27_0=='\r'||LA27_0==' ') ) { + alt27=1; + } + + + switch (alt27) { + case 1 : + // InternalRos2Lexer.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 ( cnt27 >= 1 ) break loop27; + EarlyExitException eee = + new EarlyExitException(27, input); + throw eee; + } + cnt27++; + } 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; + // InternalRos2Lexer.g:262:16: ( . ) + // InternalRos2Lexer.g:262:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalRos2Lexer.g:1:8: ( ParameterStructMember | ExternalDependency | RelativeNamespace | PrivateNamespace | GlobalNamespace | Transient_local | Serviceclient | Serviceserver | Actionclient | Actionserver | Dependencies | Parameter_qos | ParameterAny | FromGitRepo | Reliability | Services_qos | Subscribers | Best_effort | Default_qos | Durability | Parameters | Publishers | Artifacts | Sensor_qos | GraphName | Feedback_1 | Float32_1 | Float64_1 | Keep_last | Response | Duration | Feedback | History | Keep_all | Message_1 | Profile | Reliable | Request | String_2 | Uint16_1 | Uint32_1 | Uint64_1 | Volatile | Boolean | Integer | Action_1 | Default | Float32 | Float64 | Int16_1 | Int32_1 | Int64_1 | Message | Result_1 | Service | Uint8_1 | Array | Base64 | Double | Header | String | Struct | Action | Bool_1 | Byte_1 | Depth | Int8_1 | Result | Specs | String_1 | Uint16 | Uint32 | Uint64 | Goal_1 | Int16 | Int32 | Int64 | Node_1 | Type_1 | Uint8 | Value | Date | List | Bool | Byte | Goal | Int8 | Msg | Name | Node | Qos | Srv | Time | Type | Any | Ns | LeftSquareBracketRightSquareBracket | Comma | Colon | LeftSquareBracket | RightSquareBracket | RightCurlyBracket | RULE_SL_COMMENT | RULE_ROS_CONVENTION_A | RULE_ROS_CONVENTION_PARAM | RULE_BINARY | RULE_BOOLEAN | RULE_DOUBLE | RULE_DECINT | RULE_DATE_TIME | RULE_MESSAGE_ASIGMENT | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt28=116; + alt28 = dfa28.predict(input); + switch (alt28) { + case 1 : + // InternalRos2Lexer.g:1:10: ParameterStructMember + { + mParameterStructMember(); + + } + break; + case 2 : + // InternalRos2Lexer.g:1:32: ExternalDependency + { + mExternalDependency(); + + } + break; + case 3 : + // InternalRos2Lexer.g:1:51: RelativeNamespace + { + mRelativeNamespace(); + + } + break; + case 4 : + // InternalRos2Lexer.g:1:69: PrivateNamespace + { + mPrivateNamespace(); + + } + break; + case 5 : + // InternalRos2Lexer.g:1:86: GlobalNamespace + { + mGlobalNamespace(); + + } + break; + case 6 : + // InternalRos2Lexer.g:1:102: Transient_local + { + mTransient_local(); + + } + break; + case 7 : + // InternalRos2Lexer.g:1:118: Serviceclient + { + mServiceclient(); + + } + break; + case 8 : + // InternalRos2Lexer.g:1:132: Serviceserver + { + mServiceserver(); + + } + break; + case 9 : + // InternalRos2Lexer.g:1:146: Actionclient + { + mActionclient(); + + } + break; + case 10 : + // InternalRos2Lexer.g:1:159: Actionserver + { + mActionserver(); + + } + break; + case 11 : + // InternalRos2Lexer.g:1:172: Dependencies + { + mDependencies(); + + } + break; + case 12 : + // InternalRos2Lexer.g:1:185: Parameter_qos + { + mParameter_qos(); + + } + break; + case 13 : + // InternalRos2Lexer.g:1:199: ParameterAny + { + mParameterAny(); + + } + break; + case 14 : + // InternalRos2Lexer.g:1:212: FromGitRepo + { + mFromGitRepo(); + + } + break; + case 15 : + // InternalRos2Lexer.g:1:224: Reliability + { + mReliability(); + + } + break; + case 16 : + // InternalRos2Lexer.g:1:236: Services_qos + { + mServices_qos(); + + } + break; + case 17 : + // InternalRos2Lexer.g:1:249: Subscribers + { + mSubscribers(); + + } + break; + case 18 : + // InternalRos2Lexer.g:1:261: Best_effort + { + mBest_effort(); + + } + break; + case 19 : + // InternalRos2Lexer.g:1:273: Default_qos + { + mDefault_qos(); + + } + break; + case 20 : + // InternalRos2Lexer.g:1:285: Durability + { + mDurability(); + + } + break; + case 21 : + // InternalRos2Lexer.g:1:296: Parameters + { + mParameters(); + + } + break; + case 22 : + // InternalRos2Lexer.g:1:307: Publishers + { + mPublishers(); + + } + break; + case 23 : + // InternalRos2Lexer.g:1:318: Artifacts + { + mArtifacts(); + + } + break; + case 24 : + // InternalRos2Lexer.g:1:328: Sensor_qos + { + mSensor_qos(); + + } + break; + case 25 : + // InternalRos2Lexer.g:1:339: GraphName + { + mGraphName(); + + } + break; + case 26 : + // InternalRos2Lexer.g:1:349: Feedback_1 + { + mFeedback_1(); + + } + break; + case 27 : + // InternalRos2Lexer.g:1:360: Float32_1 + { + mFloat32_1(); + + } + break; + case 28 : + // InternalRos2Lexer.g:1:370: Float64_1 + { + mFloat64_1(); + + } + break; + case 29 : + // InternalRos2Lexer.g:1:380: Keep_last + { + mKeep_last(); + + } + break; + case 30 : + // InternalRos2Lexer.g:1:390: Response + { + mResponse(); + + } + break; + case 31 : + // InternalRos2Lexer.g:1:399: Duration + { + mDuration(); + + } + break; + case 32 : + // InternalRos2Lexer.g:1:408: Feedback + { + mFeedback(); + + } + break; + case 33 : + // InternalRos2Lexer.g:1:417: History + { + mHistory(); + + } + break; + case 34 : + // InternalRos2Lexer.g:1:425: Keep_all + { + mKeep_all(); + + } + break; + case 35 : + // InternalRos2Lexer.g:1:434: Message_1 + { + mMessage_1(); + + } + break; + case 36 : + // InternalRos2Lexer.g:1:444: Profile + { + mProfile(); + + } + break; + case 37 : + // InternalRos2Lexer.g:1:452: Reliable + { + mReliable(); + + } + break; + case 38 : + // InternalRos2Lexer.g:1:461: Request + { + mRequest(); + + } + break; + case 39 : + // InternalRos2Lexer.g:1:469: String_2 + { + mString_2(); + + } + break; + case 40 : + // InternalRos2Lexer.g:1:478: Uint16_1 + { + mUint16_1(); + + } + break; + case 41 : + // InternalRos2Lexer.g:1:487: Uint32_1 + { + mUint32_1(); + + } + break; + case 42 : + // InternalRos2Lexer.g:1:496: Uint64_1 + { + mUint64_1(); + + } + break; + case 43 : + // InternalRos2Lexer.g:1:505: Volatile + { + mVolatile(); + + } + break; + case 44 : + // InternalRos2Lexer.g:1:514: Boolean + { + mBoolean(); + + } + break; + case 45 : + // InternalRos2Lexer.g:1:522: Integer + { + mInteger(); + + } + break; + case 46 : + // InternalRos2Lexer.g:1:530: Action_1 + { + mAction_1(); + + } + break; + case 47 : + // InternalRos2Lexer.g:1:539: Default + { + mDefault(); + + } + break; + case 48 : + // InternalRos2Lexer.g:1:547: Float32 + { + mFloat32(); + + } + break; + case 49 : + // InternalRos2Lexer.g:1:555: Float64 + { + mFloat64(); + + } + break; + case 50 : + // InternalRos2Lexer.g:1:563: Int16_1 + { + mInt16_1(); + + } + break; + case 51 : + // InternalRos2Lexer.g:1:571: Int32_1 + { + mInt32_1(); + + } + break; + case 52 : + // InternalRos2Lexer.g:1:579: Int64_1 + { + mInt64_1(); + + } + break; + case 53 : + // InternalRos2Lexer.g:1:587: Message + { + mMessage(); + + } + break; + case 54 : + // InternalRos2Lexer.g:1:595: Result_1 + { + mResult_1(); + + } + break; + case 55 : + // InternalRos2Lexer.g:1:604: Service + { + mService(); + + } + break; + case 56 : + // InternalRos2Lexer.g:1:612: Uint8_1 + { + mUint8_1(); + + } + break; + case 57 : + // InternalRos2Lexer.g:1:620: Array + { + mArray(); + + } + break; + case 58 : + // InternalRos2Lexer.g:1:626: Base64 + { + mBase64(); + + } + break; + case 59 : + // InternalRos2Lexer.g:1:633: Double + { + mDouble(); + + } + break; + case 60 : + // InternalRos2Lexer.g:1:640: Header + { + mHeader(); + + } + break; + case 61 : + // InternalRos2Lexer.g:1:647: String + { + mString(); + + } + break; + case 62 : + // InternalRos2Lexer.g:1:654: Struct + { + mStruct(); + + } + break; + case 63 : + // InternalRos2Lexer.g:1:661: Action + { + mAction(); + + } + break; + case 64 : + // InternalRos2Lexer.g:1:668: Bool_1 + { + mBool_1(); + + } + break; + case 65 : + // InternalRos2Lexer.g:1:675: Byte_1 + { + mByte_1(); + + } + break; + case 66 : + // InternalRos2Lexer.g:1:682: Depth + { + mDepth(); + + } + break; + case 67 : + // InternalRos2Lexer.g:1:688: Int8_1 + { + mInt8_1(); + + } + break; + case 68 : + // InternalRos2Lexer.g:1:695: Result + { + mResult(); + + } + break; + case 69 : + // InternalRos2Lexer.g:1:702: Specs + { + mSpecs(); + + } + break; + case 70 : + // InternalRos2Lexer.g:1:708: String_1 + { + mString_1(); + + } + break; + case 71 : + // InternalRos2Lexer.g:1:717: Uint16 + { + mUint16(); + + } + break; + case 72 : + // InternalRos2Lexer.g:1:724: Uint32 + { + mUint32(); + + } + break; + case 73 : + // InternalRos2Lexer.g:1:731: Uint64 + { + mUint64(); + + } + break; + case 74 : + // InternalRos2Lexer.g:1:738: Goal_1 + { + mGoal_1(); + + } + break; + case 75 : + // InternalRos2Lexer.g:1:745: Int16 + { + mInt16(); + + } + break; + case 76 : + // InternalRos2Lexer.g:1:751: Int32 + { + mInt32(); + + } + break; + case 77 : + // InternalRos2Lexer.g:1:757: Int64 + { + mInt64(); + + } + break; + case 78 : + // InternalRos2Lexer.g:1:763: Node_1 + { + mNode_1(); + + } + break; + case 79 : + // InternalRos2Lexer.g:1:770: Type_1 + { + mType_1(); + + } + break; + case 80 : + // InternalRos2Lexer.g:1:777: Uint8 + { + mUint8(); + + } + break; + case 81 : + // InternalRos2Lexer.g:1:783: Value + { + mValue(); + + } + break; + case 82 : + // InternalRos2Lexer.g:1:789: Date + { + mDate(); + + } + break; + case 83 : + // InternalRos2Lexer.g:1:794: List + { + mList(); + + } + break; + case 84 : + // InternalRos2Lexer.g:1:799: Bool + { + mBool(); + + } + break; + case 85 : + // InternalRos2Lexer.g:1:804: Byte + { + mByte(); + + } + break; + case 86 : + // InternalRos2Lexer.g:1:809: Goal + { + mGoal(); + + } + break; + case 87 : + // InternalRos2Lexer.g:1:814: Int8 + { + mInt8(); + + } + break; + case 88 : + // InternalRos2Lexer.g:1:819: Msg + { + mMsg(); + + } + break; + case 89 : + // InternalRos2Lexer.g:1:823: Name + { + mName(); + + } + break; + case 90 : + // InternalRos2Lexer.g:1:828: Node + { + mNode(); + + } + break; + case 91 : + // InternalRos2Lexer.g:1:833: Qos + { + mQos(); + + } + break; + case 92 : + // InternalRos2Lexer.g:1:837: Srv + { + mSrv(); + + } + break; + case 93 : + // InternalRos2Lexer.g:1:841: Time + { + mTime(); + + } + break; + case 94 : + // InternalRos2Lexer.g:1:846: Type + { + mType(); + + } + break; + case 95 : + // InternalRos2Lexer.g:1:851: Any + { + mAny(); + + } + break; + case 96 : + // InternalRos2Lexer.g:1:855: Ns + { + mNs(); + + } + break; + case 97 : + // InternalRos2Lexer.g:1:858: LeftSquareBracketRightSquareBracket + { + mLeftSquareBracketRightSquareBracket(); + + } + break; + case 98 : + // InternalRos2Lexer.g:1:894: Comma + { + mComma(); + + } + break; + case 99 : + // InternalRos2Lexer.g:1:900: Colon + { + mColon(); + + } + break; + case 100 : + // InternalRos2Lexer.g:1:906: LeftSquareBracket + { + mLeftSquareBracket(); + + } + break; + case 101 : + // InternalRos2Lexer.g:1:924: RightSquareBracket + { + mRightSquareBracket(); + + } + break; + case 102 : + // InternalRos2Lexer.g:1:943: RightCurlyBracket + { + mRightCurlyBracket(); + + } + break; + case 103 : + // InternalRos2Lexer.g:1:961: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 104 : + // InternalRos2Lexer.g:1:977: RULE_ROS_CONVENTION_A + { + mRULE_ROS_CONVENTION_A(); + + } + break; + case 105 : + // InternalRos2Lexer.g:1:999: RULE_ROS_CONVENTION_PARAM + { + mRULE_ROS_CONVENTION_PARAM(); + + } + break; + case 106 : + // InternalRos2Lexer.g:1:1025: RULE_BINARY + { + mRULE_BINARY(); + + } + break; + case 107 : + // InternalRos2Lexer.g:1:1037: RULE_BOOLEAN + { + mRULE_BOOLEAN(); + + } + break; + case 108 : + // InternalRos2Lexer.g:1:1050: RULE_DOUBLE + { + mRULE_DOUBLE(); + + } + break; + case 109 : + // InternalRos2Lexer.g:1:1062: RULE_DECINT + { + mRULE_DECINT(); + + } + break; + case 110 : + // InternalRos2Lexer.g:1:1074: RULE_DATE_TIME + { + mRULE_DATE_TIME(); + + } + break; + case 111 : + // InternalRos2Lexer.g:1:1089: RULE_MESSAGE_ASIGMENT + { + mRULE_MESSAGE_ASIGMENT(); + + } + break; + case 112 : + // InternalRos2Lexer.g:1:1111: RULE_ID + { + mRULE_ID(); + + } + break; + case 113 : + // InternalRos2Lexer.g:1:1119: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 114 : + // InternalRos2Lexer.g:1:1131: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 115 : + // InternalRos2Lexer.g:1:1147: RULE_WS + { + mRULE_WS(); + + } + break; + case 116 : + // InternalRos2Lexer.g:1:1155: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA11 dfa11 = new DFA11(this); + protected DFA28 dfa28 = new DFA28(this); + static final String DFA11_eotS = + "\1\uffff\1\5\1\uffff\2\5\1\uffff\2\5"; + static final String DFA11_eofS = + "\10\uffff"; + static final String DFA11_minS = + "\1\56\1\60\1\uffff\2\60\1\uffff\2\60"; + static final String DFA11_maxS = + "\2\145\1\uffff\2\145\1\uffff\2\145"; + static final String DFA11_acceptS = + "\2\uffff\1\2\2\uffff\1\1\2\uffff"; + static final String DFA11_specialS = + "\10\uffff}>"; + static final String[] DFA11_transitionS = { + "\1\1\26\uffff\1\2\37\uffff\1\2", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "", + "\1\3\11\4\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2", + "\1\6\11\7\13\uffff\1\2\37\uffff\1\2" + }; + + static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); + static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); + static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); + static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); + static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); + static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); + static final short[][] DFA11_transition; + + static { + int numStates = DFA11_transitionS.length; + DFA11_transition = new short[numStates][]; + for (int i=0; i"; + static final String[] DFA28_transitionS = { + "\11\57\2\56\2\57\1\56\22\57\1\56\1\57\1\47\1\42\3\57\1\50\4\57\1\36\1\54\1\57\1\43\1\52\2\53\7\55\1\37\6\57\1\25\1\22\1\45\1\26\1\2\1\45\1\4\1\27\1\23\2\45\1\33\3\45\1\1\1\45\1\3\1\30\7\45\1\35\1\57\1\40\1\44\1\45\1\57\1\7\1\14\1\45\1\10\1\45\1\12\1\31\1\16\1\24\1\45\1\15\1\45\1\17\1\32\1\45\1\11\1\34\1\13\1\6\1\5\1\20\1\21\4\45\2\57\1\41\1\51\uff81\57", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\60\20\62\1\61\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\27\62\1\65\2\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\66\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\67\5\62\1\70\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\73\10\62\1\71\6\62\1\72\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\74\12\62\1\77\1\62\1\100\1\62\1\76\1\75\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\101\16\62\1\102\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\103\17\62\1\104\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\105\20\62\1\107\2\62\1\106\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\113\3\62\1\111\6\62\1\112\5\62\1\110\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\114\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\115\11\62\1\116\11\62\1\117\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\120\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\121\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\122\15\62\1\123\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\124\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\126\15\62\1\125\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\130\15\62\1\127\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\131\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\132\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\134\3\62\1\133\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\136\15\62\1\135\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\137\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\140\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\141\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\143\15\62\1\142\3\62\1\144\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\145\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\146\13\62", + "\1\147", + "", + "", + "", + "", + "", + "\1\157\4\uffff\1\157\2\uffff\1\156\26\uffff\32\46\3\uffff\2\46\1\uffff\32\46", + "\32\160\4\uffff\1\160\1\uffff\32\160", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\42\162\1\163\71\162\1\161\uffa3\162", + "\47\165\1\166\64\165\1\164\uffa3\165", + "\1\157\4\uffff\1\157", + "\1\172\1\uffff\12\170\10\uffff\1\167\2\uffff\1\172\34\uffff\1\167\2\uffff\1\172", + "\1\172\1\uffff\12\173\13\uffff\1\172\37\uffff\1\172", + "\12\171", + "\1\172\26\uffff\1\172\37\uffff\1\172", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\175\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\176\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\177\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0080\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0081\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0082\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0083\23\62\1\u0084\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0085\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u0086\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0088\3\62\1\u0087\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u0089\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u008a\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u008b\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u008c\4\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u008d\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u008e\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u0090\11\62\1\u008f\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0091\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0092\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u0093\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0094\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0095\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0096\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0097\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0098\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0099\4\62\1\u009b\1\62\1\u009a\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u009c\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u009d\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u009e\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u009f\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00a0\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00a1\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u00a2\23\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u00a3\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00a4\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00a5\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u00a6\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00a7\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00a8\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00a9\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u00aa\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u00ab\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u00ac\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00ad\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00ae\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u00af\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00b0\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u00b1\26\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u00b2\15\62", + "\1\46\12\62\1\u00b3\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00b4\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00b5\7\62", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\0\u00b6", + "\42\162\1\163\71\162\1\161\uffa3\162", + "\1\157\15\uffff\1\64", + "\0\u00b8", + "\47\165\1\166\64\165\1\164\uffa3\165", + "\1\157\15\uffff\1\64", + "", + "", + "", + "", + "\12\u00b9", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00ba\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u00bb\4\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00bc\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00bd\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u00be\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u00bf\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u00c0\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00c1\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00c2\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00c3\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u00c4\4\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00c5\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00c6\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00c7\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u00c8\27\62", + "\1\46\12\62\1\u00c9\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00ca\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00cb\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00cc\16\62\1\u00cd\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00ce\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00cf\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00d0\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00d1\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u00d2\24\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u00d3\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u00d4\26\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00d5\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00d6\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00d7\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u00d8\4\62\1\u00d9\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u00da\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00db\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00dc\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00dd\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u00de\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00df\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00e0\7\62", + "\1\46\12\62\1\u00e1\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00e2\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00e3\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u00e4\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00e5\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00e6\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00e7\25\62", + "\1\46\1\62\1\u00e8\1\62\1\u00e9\2\62\1\u00ea\1\62\1\u00eb\1\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00ec\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u00ee\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00ef\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u00f0\26\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u00f1\13\62\1\u00f2\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u00f3\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00f4\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u00f5\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00f6\6\62", + "\1\46\12\62\1\u00f7\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\42\162\1\163\71\162\1\161\uffa3\162", + "", + "\47\165\1\166\64\165\1\164\uffa3\165", + "\12\u00f8", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u00f9\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00fa\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u00fb\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u00fc\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u00fd\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\7\62\1\u00fe\22\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u00ff\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0101\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0104\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0105\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0106\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0107\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0108\7\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0109\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u010a\24\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u010b\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\7\62\1\u010c\22\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u010d\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u010e\21\62\1\u010f\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u0110\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0111\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0112\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\6\62\1\u0113\23\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u0114\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0115\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0116\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0117\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0118\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0119\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u011a\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u011b\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u011c\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u011e\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u0120\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0121\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0122\31\62", + "", + "\1\46\1\62\1\u0123\1\62\1\u0124\2\62\1\u0125\1\62\1\u0126\1\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0127\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0128\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0129\25\62", + "\1\46\6\62\1\u012a\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u012b\23\62", + "\1\46\6\62\1\u012c\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\2\62\1\u012d\7\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\4\62\1\u012e\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u012f\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u0131\1\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0132\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0134\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0135\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0136\27\62", + "\1\46\12\62\1\u0137\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0139\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\170", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u013d\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u013e\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u013f\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0140\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0141\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\15\62\1\u0142\14\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0143\21\62", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0144\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0145\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0146\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u0147\23\62", + "\1\46\12\62\1\u0148\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0149\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u014a\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u014b\26\62", + "\1\46\12\62\1\u014c\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u014d\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u014e\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u014f\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0150\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0151\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0152\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0153\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0154\31\62", + "\1\46\3\62\1\u0155\2\62\1\u0156\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u0157\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0158\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0159\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u015a\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u015b\25\62", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u015d\12\62\1\u015c\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u015e\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u015f\23\62", + "\1\46\6\62\1\u0160\3\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\2\62\1\u0161\7\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\4\62\1\u0162\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u0163\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0165\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0167\31\62", + "\1\46\4\62\1\u0168\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0169\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u016a\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u016c\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u016e\3\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\46\12\62\1\u0170\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0171\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0172\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\6\62\1\u0173\23\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0174\6\62", + "", + "", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0175\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0176\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0177\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u0178\4\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\15\62\1\u0179\14\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u017a\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u017b\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u017c\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u017d\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u017e\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u017f\3\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\1\u0183\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0181\17\62\1\u0182\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0185\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0186\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0187\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0188\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0189\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u018a\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\7\62\1\u018b\22\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u018c\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u018d\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u018e\27\62", + "\1\46\2\62\1\u018f\7\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\4\62\1\u0190\5\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0191\2\62\1\u0192\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0193\7\62", + "\1\46\12\62\1\u0194\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0196\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u0197\24\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0198\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0199\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u019a\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u019b\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u019c\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u019e\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u01a0\3\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01a2\16\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01a3\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01a5\10\62", + "", + "", + "", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01aa\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\15\62\1\u01ab\14\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01ac\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01ad\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u01ae\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u01af\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01b0\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u01b1\17\62\1\u01b2\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\20\62\1\u01b4\11\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u01b5\30\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01b6\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01b7\25\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u01b8\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01b9\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u01ba\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u01bc\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u01bd\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01be\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01bf\25\62", + "\1\46\12\62\1\u01c0\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\21\62\1\u01c1\10\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\12\62\1\u01c2\17\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u01c3\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\1\u01c5\3\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01c7\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01c8\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01c9\25\62", + "", + "", + "\1\46\12\62\1\u01ca\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\5\62\1\u01cb\24\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u01cc\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01cd\16\62", + "\1\46\12\62\1\u01ce\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u01cf\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01d1\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01d4\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u01d5\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\3\62\1\u01d6\26\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\15\62\1\u01d7\14\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u01d8\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01d9\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u01da\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u01db\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u01dd\1\uffff\4\62\1\u01dc\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u01de\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01df\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u01e0\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01e1\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u01e2\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u01e3\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\20\62\1\u01e4\11\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u01e5\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01e7\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01e8\10\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01e9\25\62", + "\1\46\12\62\1\u01ea\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u01ec\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u01ee\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u01ef\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u01f0\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\1\u01f4\21\62\1\u01f3\7\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u01f5\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01f6\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u01f7\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u01f8\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u01fa\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u01fb\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01fc\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\20\62\1\u01fd\11\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u01fe\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u01ff\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0200\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u0201\4\62", + "\1\46\12\62\1\u0202\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\10\62\1\u0203\21\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0204\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u0205\1\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\u0206\1\uffff\22\62\1\u0207\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0208\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0209\12\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u020a\6\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u020b\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u020d\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u020e\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u020f\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0210\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u0211\15\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0212\7\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0213\16\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0214\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\25\62\1\u0215\4\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0216\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0218\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0219\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u021a\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u021b\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u021c\7\62", + "\1\46\12\62\1\u021d\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\20\62\1\u021e\11\62", + "\1\46\12\62\1\u021f\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0220\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0221\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u0222\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u0223\6\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0224\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u0225\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0226\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0227\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0228\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0229\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u022a\13\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u022b\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u022c\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u022d\7\62", + "", + "\1\46\12\62\1\u022e\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u022f\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0230\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0231\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\16\62\1\u0233\13\62", + "", + "", + "\1\46\12\62\1\u0234\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0235\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\24\62\1\u0237\5\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0239\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u023a\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u023b\7\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u023c\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u023d\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u023e\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u023f\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\1\u0241\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0242\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u0243\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\22\62\1\u0244\7\62", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0245\27\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0246\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\3\62\1\u0247\26\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\17\62\1\u0248\12\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0249\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u024a\31\62", + "\1\46\12\62\1\u024b\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\1\u024c\2\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\23\62\1\u024e\6\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u024f\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0250\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\u0251\31\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0252\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\13\62\1\u0253\16\62", + "", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\14\62\1\u0254\15\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0255\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\15\62\1\u0256\14\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u0257\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u025a\25\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\2\62\1\u025c\27\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u025d\25\62", + "", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\14\62\1\u025e\15\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\30\62\1\u025f\1\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\1\62\1\u0261\30\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\4\62\1\u0263\25\62", + "", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\21\62\1\u0264\10\62", + "\1\46\12\62\3\uffff\1\64\3\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "" + }; + + static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS); + static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS); + static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS); + static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS); + static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS); + static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS); + static final short[][] DFA28_transition; + + static { + int numStates = DFA28_transitionS.length; + DFA28_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA28_114<='!')||(LA28_114>='#' && LA28_114<='[')||(LA28_114>=']' && LA28_114<='\uFFFF')) ) {s = 114;} + + if ( s>=0 ) return s; + break; + case 1 : + int LA28_40 = input.LA(1); + + s = -1; + if ( (LA28_40=='\\') ) {s = 116;} + + else if ( ((LA28_40>='\u0000' && LA28_40<='&')||(LA28_40>='(' && LA28_40<='[')||(LA28_40>=']' && LA28_40<='\uFFFF')) ) {s = 117;} + + else if ( (LA28_40=='\'') ) {s = 118;} + + else s = 47; + + if ( s>=0 ) return s; + break; + case 2 : + int LA28_184 = input.LA(1); + + s = -1; + if ( (LA28_184=='\'') ) {s = 118;} + + else if ( (LA28_184=='\\') ) {s = 116;} + + else if ( ((LA28_184>='\u0000' && LA28_184<='&')||(LA28_184>='(' && LA28_184<='[')||(LA28_184>=']' && LA28_184<='\uFFFF')) ) {s = 117;} + + if ( s>=0 ) return s; + break; + case 3 : + int LA28_117 = input.LA(1); + + s = -1; + if ( (LA28_117=='\'') ) {s = 118;} + + else if ( (LA28_117=='\\') ) {s = 116;} + + else if ( ((LA28_117>='\u0000' && LA28_117<='&')||(LA28_117>='(' && LA28_117<='[')||(LA28_117>=']' && LA28_117<='\uFFFF')) ) {s = 117;} + + if ( s>=0 ) return s; + break; + case 4 : + int LA28_113 = input.LA(1); + + s = -1; + if ( ((LA28_113>='\u0000' && LA28_113<='\uFFFF')) ) {s = 182;} + + if ( s>=0 ) return s; + break; + case 5 : + int LA28_0 = input.LA(1); + + s = -1; + if ( (LA28_0=='P') ) {s = 1;} + + else if ( (LA28_0=='E') ) {s = 2;} + + else if ( (LA28_0=='R') ) {s = 3;} + + else if ( (LA28_0=='G') ) {s = 4;} + + else if ( (LA28_0=='t') ) {s = 5;} + + else if ( (LA28_0=='s') ) {s = 6;} + + else if ( (LA28_0=='a') ) {s = 7;} + + else if ( (LA28_0=='d') ) {s = 8;} + + else if ( (LA28_0=='p') ) {s = 9;} + + else if ( (LA28_0=='f') ) {s = 10;} + + else if ( (LA28_0=='r') ) {s = 11;} + + else if ( (LA28_0=='b') ) {s = 12;} + + else if ( (LA28_0=='k') ) {s = 13;} + + else if ( (LA28_0=='h') ) {s = 14;} + + else if ( (LA28_0=='m') ) {s = 15;} + + else if ( (LA28_0=='u') ) {s = 16;} + + else if ( (LA28_0=='v') ) {s = 17;} + + else if ( (LA28_0=='B') ) {s = 18;} + + else if ( (LA28_0=='I') ) {s = 19;} + + else if ( (LA28_0=='i') ) {s = 20;} + + else if ( (LA28_0=='A') ) {s = 21;} + + else if ( (LA28_0=='D') ) {s = 22;} + + else if ( (LA28_0=='H') ) {s = 23;} + + else if ( (LA28_0=='S') ) {s = 24;} + + else if ( (LA28_0=='g') ) {s = 25;} + + else if ( (LA28_0=='n') ) {s = 26;} + + else if ( (LA28_0=='L') ) {s = 27;} + + else if ( (LA28_0=='q') ) {s = 28;} + + else if ( (LA28_0=='[') ) {s = 29;} + + else if ( (LA28_0==',') ) {s = 30;} + + else if ( (LA28_0==':') ) {s = 31;} + + else if ( (LA28_0==']') ) {s = 32;} + + else if ( (LA28_0=='}') ) {s = 33;} + + else if ( (LA28_0=='#') ) {s = 34;} + + else if ( (LA28_0=='/') ) {s = 35;} + + else if ( (LA28_0=='^') ) {s = 36;} + + else if ( (LA28_0=='C'||LA28_0=='F'||(LA28_0>='J' && LA28_0<='K')||(LA28_0>='M' && LA28_0<='O')||LA28_0=='Q'||(LA28_0>='T' && LA28_0<='Z')||LA28_0=='_'||LA28_0=='c'||LA28_0=='e'||LA28_0=='j'||LA28_0=='l'||LA28_0=='o'||(LA28_0>='w' && LA28_0<='z')) ) {s = 37;} + + else if ( (LA28_0=='\"') ) {s = 39;} + + else if ( (LA28_0=='\'') ) {s = 40;} + + else if ( (LA28_0=='~') ) {s = 41;} + + else if ( (LA28_0=='0') ) {s = 42;} + + else if ( ((LA28_0>='1' && LA28_0<='2')) ) {s = 43;} + + else if ( (LA28_0=='-') ) {s = 44;} + + else if ( ((LA28_0>='3' && LA28_0<='9')) ) {s = 45;} + + else if ( ((LA28_0>='\t' && LA28_0<='\n')||LA28_0=='\r'||LA28_0==' ') ) {s = 46;} + + else if ( ((LA28_0>='\u0000' && LA28_0<='\b')||(LA28_0>='\u000B' && LA28_0<='\f')||(LA28_0>='\u000E' && LA28_0<='\u001F')||LA28_0=='!'||(LA28_0>='$' && LA28_0<='&')||(LA28_0>='(' && LA28_0<='+')||LA28_0=='.'||(LA28_0>=';' && LA28_0<='@')||LA28_0=='\\'||LA28_0=='`'||(LA28_0>='{' && LA28_0<='|')||(LA28_0>='\u007F' && LA28_0<='\uFFFF')) ) {s = 47;} + + else s = 38; + + if ( s>=0 ) return s; + break; + case 6 : + int LA28_116 = input.LA(1); + + s = -1; + if ( ((LA28_116>='\u0000' && LA28_116<='\uFFFF')) ) {s = 184;} + + if ( s>=0 ) return s; + break; + case 7 : + int LA28_39 = input.LA(1); + + s = -1; + if ( (LA28_39=='\\') ) {s = 113;} + + else if ( ((LA28_39>='\u0000' && LA28_39<='!')||(LA28_39>='#' && LA28_39<='[')||(LA28_39>=']' && LA28_39<='\uFFFF')) ) {s = 114;} + + else if ( (LA28_39=='\"') ) {s = 115;} + + else s = 47; + + if ( s>=0 ) return s; + break; + case 8 : + int LA28_182 = input.LA(1); + + s = -1; + if ( (LA28_182=='\"') ) {s = 115;} + + else if ( (LA28_182=='\\') ) {s = 113;} + + else if ( ((LA28_182>='\u0000' && LA28_182<='!')||(LA28_182>='#' && LA28_182<='[')||(LA28_182>=']' && LA28_182<='\uFFFF')) ) {s = 114;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 28, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/lexer/InternalRos2Lexer.tokens b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/lexer/InternalRos2Lexer.tokens new file mode 100644 index 000000000..7e6b6a747 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/parser/antlr/lexer/InternalRos2Lexer.tokens @@ -0,0 +1,125 @@ +Action=66 +Action_1=49 +Actionclient=12 +Actionserver=13 +Any=98 +Array=60 +Artifacts=26 +Base64=61 +Best_effort=21 +Bool=87 +Bool_1=67 +Boolean=47 +Byte=88 +Byte_1=68 +Colon=102 +Comma=101 +Date=85 +Default=50 +Default_qos=22 +Dependencies=14 +Depth=69 +Double=62 +Durability=23 +Duration=34 +ExternalDependency=5 +Feedback=35 +Feedback_1=29 +Float32=51 +Float32_1=30 +Float64=52 +Float64_1=31 +FromGitRepo=17 +GlobalNamespace=8 +Goal=89 +Goal_1=77 +GraphName=28 +Header=63 +History=36 +Int16=78 +Int16_1=53 +Int32=79 +Int32_1=54 +Int64=80 +Int64_1=55 +Int8=90 +Int8_1=70 +Integer=48 +Keep_all=37 +Keep_last=32 +LeftSquareBracket=103 +LeftSquareBracketRightSquareBracket=100 +List=86 +Message=56 +Message_1=38 +Msg=91 +Name=92 +Node=93 +Node_1=81 +Ns=99 +ParameterAny=16 +ParameterStructMember=4 +Parameter_qos=15 +Parameters=24 +PrivateNamespace=7 +Profile=39 +Publishers=25 +Qos=94 +RULE_ANY_OTHER=128 +RULE_BEGIN=106 +RULE_BINARY=114 +RULE_BOOLEAN=115 +RULE_DATE_TIME=123 +RULE_DAY=118 +RULE_DECINT=116 +RULE_DIGIT=113 +RULE_DOUBLE=117 +RULE_END=107 +RULE_HOUR=121 +RULE_ID=109 +RULE_INT=124 +RULE_MESSAGE_ASIGMENT=125 +RULE_MIN_SEC=122 +RULE_ML_COMMENT=126 +RULE_MONTH=119 +RULE_ROS_CONVENTION_A=110 +RULE_ROS_CONVENTION_PARAM=112 +RULE_SL_COMMENT=108 +RULE_STRING=111 +RULE_WS=127 +RULE_YEAR=120 +RelativeNamespace=6 +Reliability=18 +Reliable=40 +Request=41 +Response=33 +Result=71 +Result_1=57 +RightCurlyBracket=105 +RightSquareBracket=104 +Sensor_qos=27 +Service=58 +Serviceclient=10 +Services_qos=19 +Serviceserver=11 +Specs=72 +Srv=95 +String=64 +String_1=73 +String_2=42 +Struct=65 +Subscribers=20 +Time=96 +Transient_local=9 +Type=97 +Type_1=82 +Uint16=74 +Uint16_1=43 +Uint32=75 +Uint32_1=44 +Uint64=76 +Uint64_1=45 +Uint8=83 +Uint8_1=59 +Value=84 +Volatile=46 diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/scoping/AbstractRos2ScopeProvider.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/scoping/AbstractRos2ScopeProvider.java new file mode 100644 index 000000000..e637efea9 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/scoping/AbstractRos2ScopeProvider.java @@ -0,0 +1,9 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.scoping; + +import de.fraunhofer.ipa.ros.scoping.RosScopeProvider; + +public abstract class AbstractRos2ScopeProvider extends RosScopeProvider { +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/serializer/Ros2SemanticSequencer.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/serializer/Ros2SemanticSequencer.java new file mode 100644 index 000000000..25d755c5c --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/serializer/Ros2SemanticSequencer.java @@ -0,0 +1,463 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.serializer; + +import com.google.inject.Inject; +import de.fraunhofer.ipa.ros.serializer.RosSemanticSequencer; +import de.fraunhofer.ipa.ros2.services.Ros2GrammarAccess; +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 primitives.ArrayTopicSpecRef; +import primitives.ByteArray; +import primitives.Header; +import primitives.MessagePart; +import primitives.PrimitivesPackage; +import primitives.TopicSpecRef; +import primitives.bool; +import primitives.boolArray; +import primitives.duration; +import primitives.float32; +import primitives.float32Array; +import primitives.float64; +import primitives.float64Array; +import primitives.int16; +import primitives.int16Array; +import primitives.int32; +import primitives.int32Array; +import primitives.int64; +import primitives.int64Array; +import primitives.int8; +import primitives.int8Array; +import primitives.string; +import primitives.stringArray; +import primitives.time; +import primitives.uint16; +import primitives.uint16Array; +import primitives.uint32; +import primitives.uint32Array; +import primitives.uint64; +import primitives.uint64Array; +import primitives.uint8; +import primitives.uint8Array; +import ros.ActionClient; +import ros.ActionServer; +import ros.ActionSpec; +import ros.AmentPackage; +import ros.Artifact; +import ros.CatkinPackage; +import ros.ExternalDependency; +import ros.GlobalNamespace; +import ros.MessageDefinition; +import ros.Node; +import ros.PackageDependency; +import ros.PackageSet; +import ros.ParameterAny; +import ros.ParameterAnyType; +import ros.ParameterArrayType; +import ros.ParameterBase64; +import ros.ParameterBase64Type; +import ros.ParameterBoolean; +import ros.ParameterBooleanType; +import ros.ParameterDate; +import ros.ParameterDateType; +import ros.ParameterDouble; +import ros.ParameterDoubleType; +import ros.ParameterInteger; +import ros.ParameterIntegerType; +import ros.ParameterListType; +import ros.ParameterSequence; +import ros.ParameterString; +import ros.ParameterStringType; +import ros.ParameterStruct; +import ros.ParameterStructMember; +import ros.ParameterStructType; +import ros.ParameterStructTypeMember; +import ros.PrivateNamespace; +import ros.Publisher; +import ros.QualityOfService; +import ros.RelativeNamespace; +import ros.RosPackage; +import ros.ServiceClient; +import ros.ServiceServer; +import ros.ServiceSpec; +import ros.Subscriber; +import ros.TopicSpec; + +@SuppressWarnings("all") +public class Ros2SemanticSequencer extends RosSemanticSequencer { + + @Inject + private Ros2GrammarAccess 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 == PrimitivesPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case PrimitivesPackage.ARRAY_TOPIC_SPEC_REF: + sequence_ArrayTopicSpecRef(context, (ArrayTopicSpecRef) semanticObject); + return; + case PrimitivesPackage.BYTE: + sequence_byte(context, (primitives.Byte) semanticObject); + return; + case PrimitivesPackage.BYTE_ARRAY: + sequence_byteArray(context, (ByteArray) semanticObject); + return; + case PrimitivesPackage.HEADER: + sequence_Header(context, (Header) semanticObject); + return; + case PrimitivesPackage.MESSAGE_PART: + sequence_MessagePart(context, (MessagePart) semanticObject); + return; + case PrimitivesPackage.TOPIC_SPEC_REF: + sequence_TopicSpecRef(context, (TopicSpecRef) semanticObject); + return; + case PrimitivesPackage.BOOL: + sequence_bool(context, (bool) semanticObject); + return; + case PrimitivesPackage.BOOL_ARRAY: + sequence_boolArray(context, (boolArray) semanticObject); + return; + case PrimitivesPackage.DURATION: + sequence_duration(context, (duration) semanticObject); + return; + case PrimitivesPackage.FLOAT32: + sequence_float32(context, (float32) semanticObject); + return; + case PrimitivesPackage.FLOAT32_ARRAY: + sequence_float32Array(context, (float32Array) semanticObject); + return; + case PrimitivesPackage.FLOAT64: + sequence_float64(context, (float64) semanticObject); + return; + case PrimitivesPackage.FLOAT64_ARRAY: + sequence_float64Array(context, (float64Array) semanticObject); + return; + case PrimitivesPackage.INT16: + sequence_int16(context, (int16) semanticObject); + return; + case PrimitivesPackage.INT16_ARRAY: + sequence_int16Array(context, (int16Array) semanticObject); + return; + case PrimitivesPackage.INT32: + sequence_int32(context, (int32) semanticObject); + return; + case PrimitivesPackage.INT32_ARRAY: + sequence_int32Array(context, (int32Array) semanticObject); + return; + case PrimitivesPackage.INT64: + sequence_int64(context, (int64) semanticObject); + return; + case PrimitivesPackage.INT64_ARRAY: + sequence_int64Array(context, (int64Array) semanticObject); + return; + case PrimitivesPackage.INT8: + sequence_int8(context, (int8) semanticObject); + return; + case PrimitivesPackage.INT8_ARRAY: + sequence_int8Array(context, (int8Array) semanticObject); + return; + case PrimitivesPackage.STRING: + sequence_string0(context, (string) semanticObject); + return; + case PrimitivesPackage.STRING_ARRAY: + sequence_string0Array(context, (stringArray) semanticObject); + return; + case PrimitivesPackage.TIME: + sequence_time(context, (time) semanticObject); + return; + case PrimitivesPackage.UINT16: + sequence_uint16(context, (uint16) semanticObject); + return; + case PrimitivesPackage.UINT16_ARRAY: + sequence_uint16Array(context, (uint16Array) semanticObject); + return; + case PrimitivesPackage.UINT32: + sequence_uint32(context, (uint32) semanticObject); + return; + case PrimitivesPackage.UINT32_ARRAY: + sequence_uint32Array(context, (uint32Array) semanticObject); + return; + case PrimitivesPackage.UINT64: + sequence_uint64(context, (uint64) semanticObject); + return; + case PrimitivesPackage.UINT64_ARRAY: + sequence_uint64Array(context, (uint64Array) semanticObject); + return; + case PrimitivesPackage.UINT8: + sequence_uint8(context, (uint8) semanticObject); + return; + case PrimitivesPackage.UINT8_ARRAY: + sequence_uint8Array(context, (uint8Array) semanticObject); + return; + } + else if (epackage == RosPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case RosPackage.ACTION_CLIENT: + sequence_ActionClient(context, (ActionClient) semanticObject); + return; + case RosPackage.ACTION_SERVER: + sequence_ActionServer(context, (ActionServer) semanticObject); + return; + case RosPackage.ACTION_SPEC: + sequence_ActionSpec(context, (ActionSpec) semanticObject); + return; + case RosPackage.AMENT_PACKAGE: + sequence_AmentPackage(context, (AmentPackage) semanticObject); + return; + 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.GLOBAL_NAMESPACE: + sequence_GlobalNamespace(context, (GlobalNamespace) semanticObject); + return; + case RosPackage.MESSAGE_DEFINITION: + sequence_MessageDefinition(context, (MessageDefinition) semanticObject); + return; + case RosPackage.NODE: + sequence_Node(context, (Node) semanticObject); + return; + case RosPackage.PACKAGE: + sequence_Package_Impl(context, (ros.Package) semanticObject); + return; + case RosPackage.PACKAGE_DEPENDENCY: + sequence_PackageDependency(context, (PackageDependency) semanticObject); + return; + case RosPackage.PACKAGE_SET: + sequence_PackageSet(context, (PackageSet) semanticObject); + return; + case RosPackage.PARAMETER: + sequence_Parameter(context, (ros.Parameter) semanticObject); + return; + case RosPackage.PARAMETER_ANY: + sequence_ParameterAny(context, (ParameterAny) semanticObject); + return; + case RosPackage.PARAMETER_ANY_TYPE: + sequence_ParameterAnyType(context, (ParameterAnyType) semanticObject); + return; + case RosPackage.PARAMETER_ARRAY_TYPE: + sequence_ParameterArrayType(context, (ParameterArrayType) semanticObject); + return; + case RosPackage.PARAMETER_BASE64: + sequence_ParameterBase64(context, (ParameterBase64) semanticObject); + return; + case RosPackage.PARAMETER_BASE64_TYPE: + sequence_ParameterBase64Type(context, (ParameterBase64Type) semanticObject); + return; + case RosPackage.PARAMETER_BOOLEAN: + sequence_ParameterBoolean(context, (ParameterBoolean) semanticObject); + return; + case RosPackage.PARAMETER_BOOLEAN_TYPE: + sequence_ParameterBooleanType(context, (ParameterBooleanType) semanticObject); + return; + case RosPackage.PARAMETER_DATE: + sequence_ParameterDate(context, (ParameterDate) semanticObject); + return; + case RosPackage.PARAMETER_DATE_TYPE: + sequence_ParameterDateType(context, (ParameterDateType) semanticObject); + return; + case RosPackage.PARAMETER_DOUBLE: + sequence_ParameterDouble(context, (ParameterDouble) semanticObject); + return; + case RosPackage.PARAMETER_DOUBLE_TYPE: + sequence_ParameterDoubleType(context, (ParameterDoubleType) semanticObject); + return; + case RosPackage.PARAMETER_INTEGER: + sequence_ParameterInteger(context, (ParameterInteger) semanticObject); + return; + case RosPackage.PARAMETER_INTEGER_TYPE: + sequence_ParameterIntegerType(context, (ParameterIntegerType) semanticObject); + return; + case RosPackage.PARAMETER_LIST_TYPE: + sequence_ParameterListType(context, (ParameterListType) semanticObject); + return; + case RosPackage.PARAMETER_SEQUENCE: + sequence_ParameterList(context, (ParameterSequence) semanticObject); + return; + case RosPackage.PARAMETER_STRING: + sequence_ParameterString(context, (ParameterString) semanticObject); + return; + case RosPackage.PARAMETER_STRING_TYPE: + sequence_ParameterStringType(context, (ParameterStringType) semanticObject); + return; + case RosPackage.PARAMETER_STRUCT: + sequence_ParameterStruct(context, (ParameterStruct) semanticObject); + return; + case RosPackage.PARAMETER_STRUCT_MEMBER: + sequence_ParameterStructMember(context, (ParameterStructMember) semanticObject); + return; + case RosPackage.PARAMETER_STRUCT_TYPE: + sequence_ParameterStructType(context, (ParameterStructType) semanticObject); + return; + case RosPackage.PARAMETER_STRUCT_TYPE_MEMBER: + sequence_ParameterStructTypeMember(context, (ParameterStructTypeMember) semanticObject); + return; + case RosPackage.PRIVATE_NAMESPACE: + sequence_PrivateNamespace(context, (PrivateNamespace) semanticObject); + return; + case RosPackage.PUBLISHER: + sequence_Publisher(context, (Publisher) semanticObject); + return; + case RosPackage.QUALITY_OF_SERVICE: + sequence_QualityOfService(context, (QualityOfService) semanticObject); + return; + case RosPackage.RELATIVE_NAMESPACE: + sequence_RelativeNamespace_Impl(context, (RelativeNamespace) semanticObject); + return; + case RosPackage.SERVICE_CLIENT: + sequence_ServiceClient(context, (ServiceClient) semanticObject); + return; + case RosPackage.SERVICE_SERVER: + sequence_ServiceServer(context, (ServiceServer) semanticObject); + return; + case RosPackage.SERVICE_SPEC: + sequence_ServiceSpec(context, (ServiceSpec) semanticObject); + return; + case RosPackage.SUBSCRIBER: + sequence_Subscriber(context, (Subscriber) semanticObject); + return; + case RosPackage.TOPIC_SPEC: + sequence_TopicSpec(context, (TopicSpec) semanticObject); + return; + } + if (errorAcceptor != null) + errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); + } + + /** + * Contexts: + * ActionClient returns ActionClient + * + * Constraint: + * (name=EString action=[ActionSpec|EString] namespace=Namespace? qos=QualityOfService?) + */ + protected void sequence_ActionClient(ISerializationContext context, ActionClient semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * ActionServer returns ActionServer + * + * Constraint: + * (name=EString action=[ActionSpec|EString] namespace=Namespace? qos=QualityOfService?) + */ + protected void sequence_ActionServer(ISerializationContext context, ActionServer semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Package returns AmentPackage + * AmentPackage returns AmentPackage + * + * Constraint: + * (name=RosNames fromGitRepo=EString? artifact+=Artifact* (dependency+=Dependency dependency+=Dependency*)?) + */ + protected void sequence_AmentPackage(ISerializationContext context, AmentPackage semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Parameter returns Parameter + * + * Constraint: + * (name=EString type=ParameterType namespace=Namespace? qos=QualityOfService?) + */ + protected void sequence_Parameter(ISerializationContext context, ros.Parameter semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Publisher returns Publisher + * + * Constraint: + * (name=EString message=[TopicSpec|EString] namespace=Namespace? qos=QualityOfService?) + */ + protected void sequence_Publisher(ISerializationContext context, Publisher semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * QualityOfService returns QualityOfService + * + * Constraint: + * ( + * QoSProfile='default_qos' | + * QoSProfile='services_qos' | + * QoSProfile='sensor_qos' | + * QoSProfile='parameter_qos' | + * History='keep_last' | + * History='keep_all' | + * Depth=Integer0 | + * Reliability='best_effort' | + * Reliability='reliable' | + * Durability='transient_local' | + * Durability='volatile' + * )* + */ + protected void sequence_QualityOfService(ISerializationContext context, QualityOfService semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * ServiceClient returns ServiceClient + * + * Constraint: + * (name=EString service=[ServiceSpec|EString] namespace=Namespace? qos=QualityOfService?) + */ + protected void sequence_ServiceClient(ISerializationContext context, ServiceClient semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * ServiceServer returns ServiceServer + * + * Constraint: + * (name=EString service=[ServiceSpec|EString] namespace=Namespace? qos=QualityOfService?) + */ + protected void sequence_ServiceServer(ISerializationContext context, ServiceServer semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Subscriber returns Subscriber + * + * Constraint: + * (name=EString message=[TopicSpec|EString] namespace=Namespace? qos=QualityOfService?) + */ + protected void sequence_Subscriber(ISerializationContext context, Subscriber semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/serializer/Ros2SyntacticSequencer.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/serializer/Ros2SyntacticSequencer.java new file mode 100644 index 000000000..4f0d0d16e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/serializer/Ros2SyntacticSequencer.java @@ -0,0 +1,2848 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.serializer; + +import com.google.inject.Inject; +import de.fraunhofer.ipa.ros2.services.Ros2GrammarAccess; +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.AlternativeAlias; +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 Ros2SyntacticSequencer extends AbstractSyntacticSequencer { + + protected Ros2GrammarAccess grammarAccess; + protected AbstractElementAlias match_AmentPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q; + protected AbstractElementAlias match_CatkinPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q; + protected AbstractElementAlias match_Node___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a; + protected AbstractElementAlias match_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a; + protected AbstractElementAlias match_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p; + protected AbstractElementAlias match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p; + protected AbstractElementAlias match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p; + protected AbstractElementAlias match_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q; + + @Inject + protected void init(IGrammarAccess access) { + grammarAccess = (Ros2GrammarAccess) access; + match_AmentPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getAmentPackageAccess().getArtifactsKeyword_5_0()), new TokenAlias(false, false, grammarAccess.getAmentPackageAccess().getBEGINTerminalRuleCall_5_1()), new TokenAlias(false, false, grammarAccess.getAmentPackageAccess().getENDTerminalRuleCall_5_3())); + 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___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1())); + match_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1())); + match_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1())); + match_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1())); + match_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1())); + match_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1())); + match_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))), new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1())); + match_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3())))); + match_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a = new GroupAlias(true, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()), new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a = new AlternativeAlias(true, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3()))); + match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionclientKeyword_3_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_5_3()))); + match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p = new GroupAlias(true, false, new AlternativeAlias(false, true, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_3_6_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_6_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_6_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_0_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_0_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceclientKeyword_3_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getServiceserverKeyword_3_2_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_2_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_2_3())), new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_3_1_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_1_3()))), new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getActionserverKeyword_3_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_4_3()))); + match_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getPackage_ImplAccess().getSpecsKeyword_5_0()), new TokenAlias(false, false, grammarAccess.getPackage_ImplAccess().getBEGINTerminalRuleCall_5_1()), new TokenAlias(false, false, grammarAccess.getPackage_ImplAccess().getENDTerminalRuleCall_5_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_AmentPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q.equals(syntax)) + emit_AmentPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q(semanticObject, getLastNavigableState(), syntaxNodes); + else 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___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a.equals(syntax)) + emit_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a.equals(syntax)) + emit_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a.equals(syntax)) + emit_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a.equals(syntax)) + emit_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p.equals(syntax)) + emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p.equals(syntax)) + emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p.equals(syntax)) + emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q.equals(syntax)) + emit_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_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_AmentPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 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: + * ( + * 'actionclient:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'actionserver:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + * publisher+=Publisher (ambiguity) publisher+=Publisher + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'publishers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'publishers:' + * BEGIN + * (ambiguity) + * publisher+=Publisher + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_0_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + * subscriber+=Subscriber (ambiguity) subscriber+=Subscriber + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'subscribers:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'subscribers:' + * BEGIN + * (ambiguity) + * subscriber+=Subscriber + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_1_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + * serviceserver+=ServiceServer (ambiguity) serviceserver+=ServiceServer + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'serviceserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'serviceserver:' + * BEGIN + * (ambiguity) + * serviceserver+=ServiceServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_2_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + * serviceclient+=ServiceClient (ambiguity) serviceclient+=ServiceClient + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'serviceclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'serviceclient:' + * BEGIN + * (ambiguity) + * serviceclient+=ServiceClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_3_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + * actionserver+=ActionServer (ambiguity) actionserver+=ActionServer + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'actionserver:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'actionserver:' + * BEGIN + * (ambiguity) + * actionserver+=ActionServer + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_4_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))* + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + * actionclient+=ActionClient (ambiguity) actionclient+=ActionClient + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? ('parameters:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'actionclient:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'actionclient:' + * BEGIN + * (ambiguity) + * actionclient+=ActionClient + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_5_3_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) + * )* + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * name=RosNames + * BEGIN + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))* + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + * parameter+=Parameter (ambiguity) parameter+=Parameter + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * ((('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('subscribers:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('serviceserver:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('serviceclient:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * ((('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? ('publishers:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionserver+=ActionServer + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? ('actionserver:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * END + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * 'parameters:' + * BEGIN + * )* + * + * This ambiguous syntax occurs at: + * ( + * actionclient+=ActionClient + * END + * ((('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? ('actionclient:' BEGIN END)?)+ + * 'parameters:' + * BEGIN + * (ambiguity) + * parameter+=Parameter + * ) + */ + protected void emit_Node___ENDTerminalRuleCall_3_6_3_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p_ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'parameters:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * parameter+=Parameter + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'publishers:' + * BEGIN + * END + * ( + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * publisher+=Publisher + * END + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'serviceclient:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceclient+=ServiceClient + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'serviceserver:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * serviceserver+=ServiceServer + * END + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * 'subscribers:' + * BEGIN + * END + * ( + * ('publishers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * )* + * + * This ambiguous syntax occurs at: + * ( + * subscriber+=Subscriber + * END + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))* + * (ambiguity) + * END + * (rule end) + * ) + */ + protected void emit_Node___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a__a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + * subscriber+=Subscriber END (ambiguity) ('subscribers:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + * serviceserver+=ServiceServer END (ambiguity) ('serviceserver:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + * serviceclient+=ServiceClient END (ambiguity) ('serviceclient:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + * publisher+=Publisher END (ambiguity) ('publishers:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('actionclient:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + * parameter+=Parameter END (ambiguity) ('parameters:' BEGIN END (ambiguity))* END (rule end) + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionclient:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) ('actionserver:' BEGIN END (ambiguity))* END (rule end) + * name=RosNames BEGIN (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_____ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * ('publishers:' BEGIN END) | + * ('subscribers:' BEGIN END) | + * ('serviceserver:' BEGIN END) | + * ('serviceclient:' BEGIN END) | + * ('actionserver:' BEGIN END) | + * ('parameters:' BEGIN END) + * )* + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) ('actionclient:' BEGIN END (ambiguity))* END (rule end) + * name=RosNames BEGIN (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_____ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionclient:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'subscribers:' BEGIN (END (ambiguity) 'subscribers:' BEGIN)* subscriber+=Subscriber + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('subscribers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * subscriber+=Subscriber END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3____q___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'serviceserver:' BEGIN (END (ambiguity) 'serviceserver:' BEGIN)* serviceserver+=ServiceServer + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceserver+=ServiceServer END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'serviceclient:' BEGIN (END (ambiguity) 'serviceclient:' BEGIN)* serviceclient+=ServiceClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('serviceclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * serviceclient+=ServiceClient END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'publishers:' BEGIN (END (ambiguity) 'publishers:' BEGIN)* publisher+=Publisher + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END) | ('parameters:' BEGIN END))? + * ('publishers:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * publisher+=Publisher END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'parameters:' BEGIN (END (ambiguity) 'parameters:' BEGIN)* parameter+=Parameter + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('actionserver:' BEGIN END))? + * ('parameters:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * parameter+=Parameter END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionclient:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionclient+=ActionClient END (ambiguity) 'actionserver:' BEGIN (END (ambiguity) 'actionserver:' BEGIN)* actionserver+=ActionServer + */ + protected void emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionclientKeyword_3_5_0_BEGINTerminalRuleCall_3_5_1_ENDTerminalRuleCall_3_5_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ( + * (('publishers:' BEGIN END) | ('subscribers:' BEGIN END) | ('serviceserver:' BEGIN END) | ('serviceclient:' BEGIN END) | ('parameters:' BEGIN END))? + * ('actionserver:' BEGIN END)? + * )+ + * + * This ambiguous syntax occurs at: + * actionserver+=ActionServer END (ambiguity) 'actionclient:' BEGIN (END (ambiguity) 'actionclient:' BEGIN)* actionclient+=ActionClient + */ + protected void emit_Node_______ParametersKeyword_3_6_0_BEGINTerminalRuleCall_3_6_1_ENDTerminalRuleCall_3_6_3___or___PublishersKeyword_3_0_0_BEGINTerminalRuleCall_3_0_1_ENDTerminalRuleCall_3_0_3___or___ServiceclientKeyword_3_3_0_BEGINTerminalRuleCall_3_3_1_ENDTerminalRuleCall_3_3_3___or___ServiceserverKeyword_3_2_0_BEGINTerminalRuleCall_3_2_1_ENDTerminalRuleCall_3_2_3___or___SubscribersKeyword_3_1_0_BEGINTerminalRuleCall_3_1_1_ENDTerminalRuleCall_3_1_3____q___ActionserverKeyword_3_4_0_BEGINTerminalRuleCall_3_4_1_ENDTerminalRuleCall_3_4_3__q__p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ('specs:' 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_Package_Impl___SpecsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/services/Ros2GrammarAccess.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/services/Ros2GrammarAccess.java new file mode 100644 index 000000000..4afc8a0b9 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/services/Ros2GrammarAccess.java @@ -0,0 +1,2462 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.services; + +import com.google.inject.Inject; +import com.google.inject.Singleton; +import de.fraunhofer.ipa.ros.services.RosGrammarAccess; +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.UnorderedGroup; +import org.eclipse.xtext.common.services.TerminalsGrammarAccess; +import org.eclipse.xtext.service.AbstractElementFinder; +import org.eclipse.xtext.service.GrammarProvider; + +@Singleton +public class Ros2GrammarAccess extends AbstractElementFinder.AbstractGrammarElementFinder { + + public class PackageElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros2.Ros2.Package"); + private final RuleCall cAmentPackageParserRuleCall = (RuleCall)rule.eContents().get(1); + + //@Override + //Package returns Package: + // AmentPackage + // ; + @Override public ParserRule getRule() { return rule; } + + //AmentPackage + public RuleCall getAmentPackageParserRuleCall() { return cAmentPackageParserRuleCall; } + } + public class AmentPackageElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros2.Ros2.AmentPackage"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cAmentPackageAction_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); + + //@Override + //AmentPackage returns AmentPackage: + // {AmentPackage} + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; + @Override public ParserRule getRule() { return rule; } + + //{AmentPackage} + //name=RosNames':' + //BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + //END + public Group getGroup() { return cGroup; } + + //{AmentPackage} + public Action getAmentPackageAction_0() { return cAmentPackageAction_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 QualityOfServiceElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros2.Ros2.QualityOfService"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cQualityOfServiceAction_0 = (Action)cGroup.eContents().get(0); + private final UnorderedGroup cUnorderedGroup_1 = (UnorderedGroup)cGroup.eContents().get(1); + private final Group cGroup_1_0 = (Group)cUnorderedGroup_1.eContents().get(0); + private final Keyword cProfileKeyword_1_0_0 = (Keyword)cGroup_1_0.eContents().get(0); + private final Assignment cQoSProfileAssignment_1_0_1 = (Assignment)cGroup_1_0.eContents().get(1); + private final Alternatives cQoSProfileAlternatives_1_0_1_0 = (Alternatives)cQoSProfileAssignment_1_0_1.eContents().get(0); + private final Keyword cQoSProfileDefault_qosKeyword_1_0_1_0_0 = (Keyword)cQoSProfileAlternatives_1_0_1_0.eContents().get(0); + private final Keyword cQoSProfileServices_qosKeyword_1_0_1_0_1 = (Keyword)cQoSProfileAlternatives_1_0_1_0.eContents().get(1); + private final Keyword cQoSProfileSensor_qosKeyword_1_0_1_0_2 = (Keyword)cQoSProfileAlternatives_1_0_1_0.eContents().get(2); + private final Keyword cQoSProfileParameter_qosKeyword_1_0_1_0_3 = (Keyword)cQoSProfileAlternatives_1_0_1_0.eContents().get(3); + private final Group cGroup_1_1 = (Group)cUnorderedGroup_1.eContents().get(1); + private final Keyword cHistoryKeyword_1_1_0 = (Keyword)cGroup_1_1.eContents().get(0); + private final Assignment cHistoryAssignment_1_1_1 = (Assignment)cGroup_1_1.eContents().get(1); + private final Alternatives cHistoryAlternatives_1_1_1_0 = (Alternatives)cHistoryAssignment_1_1_1.eContents().get(0); + private final Keyword cHistoryKeep_lastKeyword_1_1_1_0_0 = (Keyword)cHistoryAlternatives_1_1_1_0.eContents().get(0); + private final Keyword cHistoryKeep_allKeyword_1_1_1_0_1 = (Keyword)cHistoryAlternatives_1_1_1_0.eContents().get(1); + private final Group cGroup_1_2 = (Group)cUnorderedGroup_1.eContents().get(2); + private final Keyword cDepthKeyword_1_2_0 = (Keyword)cGroup_1_2.eContents().get(0); + private final Assignment cDepthAssignment_1_2_1 = (Assignment)cGroup_1_2.eContents().get(1); + private final RuleCall cDepthInteger0ParserRuleCall_1_2_1_0 = (RuleCall)cDepthAssignment_1_2_1.eContents().get(0); + private final Group cGroup_1_3 = (Group)cUnorderedGroup_1.eContents().get(3); + private final Keyword cReliabilityKeyword_1_3_0 = (Keyword)cGroup_1_3.eContents().get(0); + private final Assignment cReliabilityAssignment_1_3_1 = (Assignment)cGroup_1_3.eContents().get(1); + private final Alternatives cReliabilityAlternatives_1_3_1_0 = (Alternatives)cReliabilityAssignment_1_3_1.eContents().get(0); + private final Keyword cReliabilityBest_effortKeyword_1_3_1_0_0 = (Keyword)cReliabilityAlternatives_1_3_1_0.eContents().get(0); + private final Keyword cReliabilityReliableKeyword_1_3_1_0_1 = (Keyword)cReliabilityAlternatives_1_3_1_0.eContents().get(1); + private final Group cGroup_1_4 = (Group)cUnorderedGroup_1.eContents().get(4); + private final Keyword cDurabilityKeyword_1_4_0 = (Keyword)cGroup_1_4.eContents().get(0); + private final Assignment cDurabilityAssignment_1_4_1 = (Assignment)cGroup_1_4.eContents().get(1); + private final Alternatives cDurabilityAlternatives_1_4_1_0 = (Alternatives)cDurabilityAssignment_1_4_1.eContents().get(0); + private final Keyword cDurabilityTransient_localKeyword_1_4_1_0_0 = (Keyword)cDurabilityAlternatives_1_4_1_0.eContents().get(0); + private final Keyword cDurabilityVolatileKeyword_1_4_1_0_1 = (Keyword)cDurabilityAlternatives_1_4_1_0.eContents().get(1); + + ///////////////////// + //// Quality of Service + ///////////////////// + //QualityOfService returns QualityOfService: + // {QualityOfService} + // (('profile:' QoSProfile=('default_qos'|'services_qos'|'sensor_qos'|'parameter_qos'))? & + // ('history:' History=('keep_last'|'keep_all'))? & + // ('depth:' Depth=Integer0)? & + // ('reliability:' Reliability=('best_effort'|'reliable'))? & + // ('durability:' Durability=('transient_local'|'volatile'))?) + // ; + @Override public ParserRule getRule() { return rule; } + + //{QualityOfService} + // (('profile:' QoSProfile=('default_qos'|'services_qos'|'sensor_qos'|'parameter_qos'))? & + // ('history:' History=('keep_last'|'keep_all'))? & + // ('depth:' Depth=Integer0)? & + // ('reliability:' Reliability=('best_effort'|'reliable'))? & + // ('durability:' Durability=('transient_local'|'volatile'))?) + public Group getGroup() { return cGroup; } + + //{QualityOfService} + public Action getQualityOfServiceAction_0() { return cQualityOfServiceAction_0; } + + //(('profile:' QoSProfile=('default_qos'|'services_qos'|'sensor_qos'|'parameter_qos'))? & + //('history:' History=('keep_last'|'keep_all'))? & + //('depth:' Depth=Integer0)? & + //('reliability:' Reliability=('best_effort'|'reliable'))? & + //('durability:' Durability=('transient_local'|'volatile'))?) + public UnorderedGroup getUnorderedGroup_1() { return cUnorderedGroup_1; } + + //('profile:' QoSProfile=('default_qos'|'services_qos'|'sensor_qos'|'parameter_qos'))? + public Group getGroup_1_0() { return cGroup_1_0; } + + //'profile:' + public Keyword getProfileKeyword_1_0_0() { return cProfileKeyword_1_0_0; } + + //QoSProfile=('default_qos'|'services_qos'|'sensor_qos'|'parameter_qos') + public Assignment getQoSProfileAssignment_1_0_1() { return cQoSProfileAssignment_1_0_1; } + + //('default_qos'|'services_qos'|'sensor_qos'|'parameter_qos') + public Alternatives getQoSProfileAlternatives_1_0_1_0() { return cQoSProfileAlternatives_1_0_1_0; } + + //'default_qos' + public Keyword getQoSProfileDefault_qosKeyword_1_0_1_0_0() { return cQoSProfileDefault_qosKeyword_1_0_1_0_0; } + + //'services_qos' + public Keyword getQoSProfileServices_qosKeyword_1_0_1_0_1() { return cQoSProfileServices_qosKeyword_1_0_1_0_1; } + + //'sensor_qos' + public Keyword getQoSProfileSensor_qosKeyword_1_0_1_0_2() { return cQoSProfileSensor_qosKeyword_1_0_1_0_2; } + + //'parameter_qos' + public Keyword getQoSProfileParameter_qosKeyword_1_0_1_0_3() { return cQoSProfileParameter_qosKeyword_1_0_1_0_3; } + + //('history:' History=('keep_last'|'keep_all'))? + public Group getGroup_1_1() { return cGroup_1_1; } + + //'history:' + public Keyword getHistoryKeyword_1_1_0() { return cHistoryKeyword_1_1_0; } + + //History=('keep_last'|'keep_all') + public Assignment getHistoryAssignment_1_1_1() { return cHistoryAssignment_1_1_1; } + + //('keep_last'|'keep_all') + public Alternatives getHistoryAlternatives_1_1_1_0() { return cHistoryAlternatives_1_1_1_0; } + + //'keep_last' + public Keyword getHistoryKeep_lastKeyword_1_1_1_0_0() { return cHistoryKeep_lastKeyword_1_1_1_0_0; } + + //'keep_all' + public Keyword getHistoryKeep_allKeyword_1_1_1_0_1() { return cHistoryKeep_allKeyword_1_1_1_0_1; } + + //('depth:' Depth=Integer0)? + public Group getGroup_1_2() { return cGroup_1_2; } + + //'depth:' + public Keyword getDepthKeyword_1_2_0() { return cDepthKeyword_1_2_0; } + + //Depth=Integer0 + public Assignment getDepthAssignment_1_2_1() { return cDepthAssignment_1_2_1; } + + //Integer0 + public RuleCall getDepthInteger0ParserRuleCall_1_2_1_0() { return cDepthInteger0ParserRuleCall_1_2_1_0; } + + //('reliability:' Reliability=('best_effort'|'reliable'))? + public Group getGroup_1_3() { return cGroup_1_3; } + + //'reliability:' + public Keyword getReliabilityKeyword_1_3_0() { return cReliabilityKeyword_1_3_0; } + + //Reliability=('best_effort'|'reliable') + public Assignment getReliabilityAssignment_1_3_1() { return cReliabilityAssignment_1_3_1; } + + //('best_effort'|'reliable') + public Alternatives getReliabilityAlternatives_1_3_1_0() { return cReliabilityAlternatives_1_3_1_0; } + + //'best_effort' + public Keyword getReliabilityBest_effortKeyword_1_3_1_0_0() { return cReliabilityBest_effortKeyword_1_3_1_0_0; } + + //'reliable' + public Keyword getReliabilityReliableKeyword_1_3_1_0_1() { return cReliabilityReliableKeyword_1_3_1_0_1; } + + //('durability:' Durability=('transient_local'|'volatile'))? + public Group getGroup_1_4() { return cGroup_1_4; } + + //'durability:' + public Keyword getDurabilityKeyword_1_4_0() { return cDurabilityKeyword_1_4_0; } + + //Durability=('transient_local'|'volatile') + public Assignment getDurabilityAssignment_1_4_1() { return cDurabilityAssignment_1_4_1; } + + //('transient_local'|'volatile') + public Alternatives getDurabilityAlternatives_1_4_1_0() { return cDurabilityAlternatives_1_4_1_0; } + + //'transient_local' + public Keyword getDurabilityTransient_localKeyword_1_4_1_0_0() { return cDurabilityTransient_localKeyword_1_4_1_0_0; } + + //'volatile' + public Keyword getDurabilityVolatileKeyword_1_4_1_0_1() { return cDurabilityVolatileKeyword_1_4_1_0_1; } + } + public class PublisherElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros2.Ros2.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 Group cGroup_6 = (Group)cGroup.eContents().get(6); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); + private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); + private final Group cGroup_7 = (Group)cGroup.eContents().get(7); + private final Keyword cQosKeyword_7_0 = (Keyword)cGroup_7.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_7_1 = (RuleCall)cGroup_7.eContents().get(1); + private final Assignment cQosAssignment_7_2 = (Assignment)cGroup_7.eContents().get(2); + private final RuleCall cQosQualityOfServiceParserRuleCall_7_2_0 = (RuleCall)cQosAssignment_7_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_7_3 = (RuleCall)cGroup_7.eContents().get(3); + private final RuleCall cENDTerminalRuleCall_8 = (RuleCall)cGroup.eContents().get(8); + + ///////////////////// + ////INTERFACES + ///////////////////// + //@Override + //Publisher returns Publisher: + // {Publisher} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' BEGIN qos=QualityOfService END)? + // END + // ; + @Override public ParserRule getRule() { return rule; } + + //{Publisher} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' BEGIN qos=QualityOfService END)? + // END + public Group getGroup() { return cGroup; } + + //{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=[TopicSpec|EString] + public Assignment getMessageAssignment_5() { return cMessageAssignment_5; } + + //[TopicSpec|EString] + public CrossReference getMessageTopicSpecCrossReference_5_0() { return cMessageTopicSpecCrossReference_5_0; } + + //EString + public RuleCall getMessageTopicSpecEStringParserRuleCall_5_0_1() { return cMessageTopicSpecEStringParserRuleCall_5_0_1; } + + //('ns:' namespace=Namespace)? + public Group getGroup_6() { return cGroup_6; } + + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } + + //namespace=Namespace + public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } + + //Namespace + public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } + + //('qos:' BEGIN qos=QualityOfService END)? + public Group getGroup_7() { return cGroup_7; } + + //'qos:' + public Keyword getQosKeyword_7_0() { return cQosKeyword_7_0; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_7_1() { return cBEGINTerminalRuleCall_7_1; } + + //qos=QualityOfService + public Assignment getQosAssignment_7_2() { return cQosAssignment_7_2; } + + //QualityOfService + public RuleCall getQosQualityOfServiceParserRuleCall_7_2_0() { return cQosQualityOfServiceParserRuleCall_7_2_0; } + + //END + public RuleCall getENDTerminalRuleCall_7_3() { return cENDTerminalRuleCall_7_3; } + + //END + public RuleCall getENDTerminalRuleCall_8() { return cENDTerminalRuleCall_8; } + } + public class SubscriberElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros2.Ros2.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 Group cGroup_6 = (Group)cGroup.eContents().get(6); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); + private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); + private final Group cGroup_7 = (Group)cGroup.eContents().get(7); + private final Keyword cQosKeyword_7_0 = (Keyword)cGroup_7.eContents().get(0); + private final Assignment cQosAssignment_7_1 = (Assignment)cGroup_7.eContents().get(1); + private final RuleCall cQosQualityOfServiceParserRuleCall_7_1_0 = (RuleCall)cQosAssignment_7_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_8 = (RuleCall)cGroup.eContents().get(8); + + //@Override + //Subscriber returns Subscriber: + // {Subscriber} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // ; + @Override public ParserRule getRule() { return rule; } + + //{Subscriber} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + public Group getGroup() { return cGroup; } + + //{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=[TopicSpec|EString] + public Assignment getMessageAssignment_5() { return cMessageAssignment_5; } + + //[TopicSpec|EString] + public CrossReference getMessageTopicSpecCrossReference_5_0() { return cMessageTopicSpecCrossReference_5_0; } + + //EString + public RuleCall getMessageTopicSpecEStringParserRuleCall_5_0_1() { return cMessageTopicSpecEStringParserRuleCall_5_0_1; } + + //('ns:' namespace=Namespace)? + public Group getGroup_6() { return cGroup_6; } + + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } + + //namespace=Namespace + public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } + + //Namespace + public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } + + //('qos:' qos=QualityOfService)? + public Group getGroup_7() { return cGroup_7; } + + //'qos:' + public Keyword getQosKeyword_7_0() { return cQosKeyword_7_0; } + + //qos=QualityOfService + public Assignment getQosAssignment_7_1() { return cQosAssignment_7_1; } + + //QualityOfService + public RuleCall getQosQualityOfServiceParserRuleCall_7_1_0() { return cQosQualityOfServiceParserRuleCall_7_1_0; } + + //END + public RuleCall getENDTerminalRuleCall_8() { return cENDTerminalRuleCall_8; } + } + public class ServiceServerElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros2.Ros2.ServiceServer"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cServiceServerAction_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 cServiceAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final CrossReference cServiceServiceSpecCrossReference_5_0 = (CrossReference)cServiceAssignment_5.eContents().get(0); + private final RuleCall cServiceServiceSpecEStringParserRuleCall_5_0_1 = (RuleCall)cServiceServiceSpecCrossReference_5_0.eContents().get(1); + private final Group cGroup_6 = (Group)cGroup.eContents().get(6); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); + private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); + private final Group cGroup_7 = (Group)cGroup.eContents().get(7); + private final Keyword cQosKeyword_7_0 = (Keyword)cGroup_7.eContents().get(0); + private final Assignment cQosAssignment_7_1 = (Assignment)cGroup_7.eContents().get(1); + private final RuleCall cQosQualityOfServiceParserRuleCall_7_1_0 = (RuleCall)cQosAssignment_7_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_8 = (RuleCall)cGroup.eContents().get(8); + + //@Override + //ServiceServer returns ServiceServer: + // {ServiceServer} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // ; + @Override public ParserRule getRule() { return rule; } + + //{ServiceServer} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + public Group getGroup() { return cGroup; } + + //{ServiceServer} + public Action getServiceServerAction_0() { return cServiceServerAction_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; } + + //service=[ServiceSpec|EString] + public Assignment getServiceAssignment_5() { return cServiceAssignment_5; } + + //[ServiceSpec|EString] + public CrossReference getServiceServiceSpecCrossReference_5_0() { return cServiceServiceSpecCrossReference_5_0; } + + //EString + public RuleCall getServiceServiceSpecEStringParserRuleCall_5_0_1() { return cServiceServiceSpecEStringParserRuleCall_5_0_1; } + + //('ns:' namespace=Namespace)? + public Group getGroup_6() { return cGroup_6; } + + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } + + //namespace=Namespace + public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } + + //Namespace + public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } + + //('qos:' qos=QualityOfService)? + public Group getGroup_7() { return cGroup_7; } + + //'qos:' + public Keyword getQosKeyword_7_0() { return cQosKeyword_7_0; } + + //qos=QualityOfService + public Assignment getQosAssignment_7_1() { return cQosAssignment_7_1; } + + //QualityOfService + public RuleCall getQosQualityOfServiceParserRuleCall_7_1_0() { return cQosQualityOfServiceParserRuleCall_7_1_0; } + + //END + public RuleCall getENDTerminalRuleCall_8() { return cENDTerminalRuleCall_8; } + } + public class ServiceClientElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros2.Ros2.ServiceClient"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cServiceClientAction_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 cServiceAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final CrossReference cServiceServiceSpecCrossReference_5_0 = (CrossReference)cServiceAssignment_5.eContents().get(0); + private final RuleCall cServiceServiceSpecEStringParserRuleCall_5_0_1 = (RuleCall)cServiceServiceSpecCrossReference_5_0.eContents().get(1); + private final Group cGroup_6 = (Group)cGroup.eContents().get(6); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); + private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); + private final Group cGroup_7 = (Group)cGroup.eContents().get(7); + private final Keyword cQosKeyword_7_0 = (Keyword)cGroup_7.eContents().get(0); + private final Assignment cQosAssignment_7_1 = (Assignment)cGroup_7.eContents().get(1); + private final RuleCall cQosQualityOfServiceParserRuleCall_7_1_0 = (RuleCall)cQosAssignment_7_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_8 = (RuleCall)cGroup.eContents().get(8); + + //@Override + //ServiceClient returns ServiceClient: + // {ServiceClient} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // ; + @Override public ParserRule getRule() { return rule; } + + //{ServiceClient} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + public Group getGroup() { return cGroup; } + + //{ServiceClient} + public Action getServiceClientAction_0() { return cServiceClientAction_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; } + + //service=[ServiceSpec|EString] + public Assignment getServiceAssignment_5() { return cServiceAssignment_5; } + + //[ServiceSpec|EString] + public CrossReference getServiceServiceSpecCrossReference_5_0() { return cServiceServiceSpecCrossReference_5_0; } + + //EString + public RuleCall getServiceServiceSpecEStringParserRuleCall_5_0_1() { return cServiceServiceSpecEStringParserRuleCall_5_0_1; } + + //('ns:' namespace=Namespace)? + public Group getGroup_6() { return cGroup_6; } + + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } + + //namespace=Namespace + public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } + + //Namespace + public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } + + //('qos:' qos=QualityOfService)? + public Group getGroup_7() { return cGroup_7; } + + //'qos:' + public Keyword getQosKeyword_7_0() { return cQosKeyword_7_0; } + + //qos=QualityOfService + public Assignment getQosAssignment_7_1() { return cQosAssignment_7_1; } + + //QualityOfService + public RuleCall getQosQualityOfServiceParserRuleCall_7_1_0() { return cQosQualityOfServiceParserRuleCall_7_1_0; } + + //END + public RuleCall getENDTerminalRuleCall_8() { return cENDTerminalRuleCall_8; } + } + public class ActionServerElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros2.Ros2.ActionServer"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cActionServerAction_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 cActionAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final CrossReference cActionActionSpecCrossReference_5_0 = (CrossReference)cActionAssignment_5.eContents().get(0); + private final RuleCall cActionActionSpecEStringParserRuleCall_5_0_1 = (RuleCall)cActionActionSpecCrossReference_5_0.eContents().get(1); + private final Group cGroup_6 = (Group)cGroup.eContents().get(6); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); + private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); + private final Group cGroup_7 = (Group)cGroup.eContents().get(7); + private final Keyword cQosKeyword_7_0 = (Keyword)cGroup_7.eContents().get(0); + private final Assignment cQosAssignment_7_1 = (Assignment)cGroup_7.eContents().get(1); + private final RuleCall cQosQualityOfServiceParserRuleCall_7_1_0 = (RuleCall)cQosAssignment_7_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_8 = (RuleCall)cGroup.eContents().get(8); + + //@Override + //ActionServer returns ActionServer: + // {ActionServer} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // ; + @Override public ParserRule getRule() { return rule; } + + //{ActionServer} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + public Group getGroup() { return cGroup; } + + //{ActionServer} + public Action getActionServerAction_0() { return cActionServerAction_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; } + + //action=[ActionSpec|EString] + public Assignment getActionAssignment_5() { return cActionAssignment_5; } + + //[ActionSpec|EString] + public CrossReference getActionActionSpecCrossReference_5_0() { return cActionActionSpecCrossReference_5_0; } + + //EString + public RuleCall getActionActionSpecEStringParserRuleCall_5_0_1() { return cActionActionSpecEStringParserRuleCall_5_0_1; } + + //('ns:' namespace=Namespace)? + public Group getGroup_6() { return cGroup_6; } + + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } + + //namespace=Namespace + public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } + + //Namespace + public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } + + //('qos:' qos=QualityOfService)? + public Group getGroup_7() { return cGroup_7; } + + //'qos:' + public Keyword getQosKeyword_7_0() { return cQosKeyword_7_0; } + + //qos=QualityOfService + public Assignment getQosAssignment_7_1() { return cQosAssignment_7_1; } + + //QualityOfService + public RuleCall getQosQualityOfServiceParserRuleCall_7_1_0() { return cQosQualityOfServiceParserRuleCall_7_1_0; } + + //END + public RuleCall getENDTerminalRuleCall_8() { return cENDTerminalRuleCall_8; } + } + public class ActionClientElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros2.Ros2.ActionClient"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cActionClientAction_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 cActionAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final CrossReference cActionActionSpecCrossReference_5_0 = (CrossReference)cActionAssignment_5.eContents().get(0); + private final RuleCall cActionActionSpecEStringParserRuleCall_5_0_1 = (RuleCall)cActionActionSpecCrossReference_5_0.eContents().get(1); + private final Group cGroup_6 = (Group)cGroup.eContents().get(6); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); + private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); + private final Group cGroup_7 = (Group)cGroup.eContents().get(7); + private final Keyword cQosKeyword_7_0 = (Keyword)cGroup_7.eContents().get(0); + private final Assignment cQosAssignment_7_1 = (Assignment)cGroup_7.eContents().get(1); + private final RuleCall cQosQualityOfServiceParserRuleCall_7_1_0 = (RuleCall)cQosAssignment_7_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_8 = (RuleCall)cGroup.eContents().get(8); + + //@Override + //ActionClient returns ActionClient: + // {ActionClient} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // ; + @Override public ParserRule getRule() { return rule; } + + //{ActionClient} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + public Group getGroup() { return cGroup; } + + //{ActionClient} + public Action getActionClientAction_0() { return cActionClientAction_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; } + + //action=[ActionSpec|EString] + public Assignment getActionAssignment_5() { return cActionAssignment_5; } + + //[ActionSpec|EString] + public CrossReference getActionActionSpecCrossReference_5_0() { return cActionActionSpecCrossReference_5_0; } + + //EString + public RuleCall getActionActionSpecEStringParserRuleCall_5_0_1() { return cActionActionSpecEStringParserRuleCall_5_0_1; } + + //('ns:' namespace=Namespace)? + public Group getGroup_6() { return cGroup_6; } + + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } + + //namespace=Namespace + public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } + + //Namespace + public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } + + //('qos:' qos=QualityOfService)? + public Group getGroup_7() { return cGroup_7; } + + //'qos:' + public Keyword getQosKeyword_7_0() { return cQosKeyword_7_0; } + + //qos=QualityOfService + public Assignment getQosAssignment_7_1() { return cQosAssignment_7_1; } + + //QualityOfService + public RuleCall getQosQualityOfServiceParserRuleCall_7_1_0() { return cQosQualityOfServiceParserRuleCall_7_1_0; } + + //END + public RuleCall getENDTerminalRuleCall_8() { return cENDTerminalRuleCall_8; } + } + public class ParameterElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros2.Ros2.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 Keyword cTypeKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Assignment cTypeAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final RuleCall cTypeParameterTypeParserRuleCall_5_0 = (RuleCall)cTypeAssignment_5.eContents().get(0); + private final Group cGroup_6 = (Group)cGroup.eContents().get(6); + private final Keyword cNsKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Assignment cNamespaceAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1); + private final RuleCall cNamespaceNamespaceParserRuleCall_6_1_0 = (RuleCall)cNamespaceAssignment_6_1.eContents().get(0); + private final Group cGroup_7 = (Group)cGroup.eContents().get(7); + private final Keyword cQosKeyword_7_0 = (Keyword)cGroup_7.eContents().get(0); + private final Assignment cQosAssignment_7_1 = (Assignment)cGroup_7.eContents().get(1); + private final RuleCall cQosQualityOfServiceParserRuleCall_7_1_0 = (RuleCall)cQosAssignment_7_1.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_8 = (RuleCall)cGroup.eContents().get(8); + private final Keyword cRightCurlyBracketKeyword_9 = (Keyword)cGroup.eContents().get(9); + + //@Override + //Parameter returns Parameter: + // {Parameter} + // name=EString':' + // BEGIN + // 'type' type=ParameterType + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // '}'; + @Override public ParserRule getRule() { return rule; } + + //{Parameter} + // name=EString':' + // BEGIN + // 'type' type=ParameterType + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + //'}' + public Group getGroup() { return cGroup; } + + //{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' + public Keyword getTypeKeyword_4() { return cTypeKeyword_4; } + + //type=ParameterType + public Assignment getTypeAssignment_5() { return cTypeAssignment_5; } + + //ParameterType + public RuleCall getTypeParameterTypeParserRuleCall_5_0() { return cTypeParameterTypeParserRuleCall_5_0; } + + //('ns:' namespace=Namespace)? + public Group getGroup_6() { return cGroup_6; } + + //'ns:' + public Keyword getNsKeyword_6_0() { return cNsKeyword_6_0; } + + //namespace=Namespace + public Assignment getNamespaceAssignment_6_1() { return cNamespaceAssignment_6_1; } + + //Namespace + public RuleCall getNamespaceNamespaceParserRuleCall_6_1_0() { return cNamespaceNamespaceParserRuleCall_6_1_0; } + + //('qos:' qos=QualityOfService)? + public Group getGroup_7() { return cGroup_7; } + + //'qos:' + public Keyword getQosKeyword_7_0() { return cQosKeyword_7_0; } + + //qos=QualityOfService + public Assignment getQosAssignment_7_1() { return cQosAssignment_7_1; } + + //QualityOfService + public RuleCall getQosQualityOfServiceParserRuleCall_7_1_0() { return cQosQualityOfServiceParserRuleCall_7_1_0; } + + //END + public RuleCall getENDTerminalRuleCall_8() { return cENDTerminalRuleCall_8; } + + //'}' + public Keyword getRightCurlyBracketKeyword_9() { return cRightCurlyBracketKeyword_9; } + } + + + private final PackageElements pPackage; + private final AmentPackageElements pAmentPackage; + private final QualityOfServiceElements pQualityOfService; + private final PublisherElements pPublisher; + private final SubscriberElements pSubscriber; + private final ServiceServerElements pServiceServer; + private final ServiceClientElements pServiceClient; + private final ActionServerElements pActionServer; + private final ActionClientElements pActionClient; + private final ParameterElements pParameter; + + private final Grammar grammar; + + private final RosGrammarAccess gaRos; + + private final TerminalsGrammarAccess gaTerminals; + + @Inject + public Ros2GrammarAccess(GrammarProvider grammarProvider, + RosGrammarAccess gaRos, + TerminalsGrammarAccess gaTerminals) { + this.grammar = internalFindGrammar(grammarProvider); + this.gaRos = gaRos; + this.gaTerminals = gaTerminals; + this.pPackage = new PackageElements(); + this.pAmentPackage = new AmentPackageElements(); + this.pQualityOfService = new QualityOfServiceElements(); + this.pPublisher = new PublisherElements(); + this.pSubscriber = new SubscriberElements(); + this.pServiceServer = new ServiceServerElements(); + this.pServiceClient = new ServiceClientElements(); + this.pActionServer = new ActionServerElements(); + this.pActionClient = new ActionClientElements(); + this.pParameter = new ParameterElements(); + } + + protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { + Grammar grammar = grammarProvider.getGrammar(this); + while (grammar != null) { + if ("de.fraunhofer.ipa.ros2.Ros2".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 RosGrammarAccess getRosGrammarAccess() { + return gaRos; + } + + public TerminalsGrammarAccess getTerminalsGrammarAccess() { + return gaTerminals; + } + + + //@Override + //Package returns Package: + // AmentPackage + // ; + public PackageElements getPackageAccess() { + return pPackage; + } + + public ParserRule getPackageRule() { + return getPackageAccess().getRule(); + } + + //@Override + //AmentPackage returns AmentPackage: + // {AmentPackage} + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; + public AmentPackageElements getAmentPackageAccess() { + return pAmentPackage; + } + + public ParserRule getAmentPackageRule() { + return getAmentPackageAccess().getRule(); + } + + ///////////////////// + //// Quality of Service + ///////////////////// + //QualityOfService returns QualityOfService: + // {QualityOfService} + // (('profile:' QoSProfile=('default_qos'|'services_qos'|'sensor_qos'|'parameter_qos'))? & + // ('history:' History=('keep_last'|'keep_all'))? & + // ('depth:' Depth=Integer0)? & + // ('reliability:' Reliability=('best_effort'|'reliable'))? & + // ('durability:' Durability=('transient_local'|'volatile'))?) + // ; + public QualityOfServiceElements getQualityOfServiceAccess() { + return pQualityOfService; + } + + public ParserRule getQualityOfServiceRule() { + return getQualityOfServiceAccess().getRule(); + } + + ///////////////////// + ////INTERFACES + ///////////////////// + //@Override + //Publisher returns Publisher: + // {Publisher} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' BEGIN qos=QualityOfService END)? + // END + // ; + public PublisherElements getPublisherAccess() { + return pPublisher; + } + + public ParserRule getPublisherRule() { + return getPublisherAccess().getRule(); + } + + //@Override + //Subscriber returns Subscriber: + // {Subscriber} + // name=EString':' + // BEGIN + // 'type:' message=[TopicSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // ; + public SubscriberElements getSubscriberAccess() { + return pSubscriber; + } + + public ParserRule getSubscriberRule() { + return getSubscriberAccess().getRule(); + } + + //@Override + //ServiceServer returns ServiceServer: + // {ServiceServer} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // ; + public ServiceServerElements getServiceServerAccess() { + return pServiceServer; + } + + public ParserRule getServiceServerRule() { + return getServiceServerAccess().getRule(); + } + + //@Override + //ServiceClient returns ServiceClient: + // {ServiceClient} + // name=EString':' + // BEGIN + // 'type:' service=[ServiceSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // ; + public ServiceClientElements getServiceClientAccess() { + return pServiceClient; + } + + public ParserRule getServiceClientRule() { + return getServiceClientAccess().getRule(); + } + + //@Override + //ActionServer returns ActionServer: + // {ActionServer} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // ; + public ActionServerElements getActionServerAccess() { + return pActionServer; + } + + public ParserRule getActionServerRule() { + return getActionServerAccess().getRule(); + } + + //@Override + //ActionClient returns ActionClient: + // {ActionClient} + // name=EString':' + // BEGIN + // 'type:' action=[ActionSpec|EString] + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // ; + public ActionClientElements getActionClientAccess() { + return pActionClient; + } + + public ParserRule getActionClientRule() { + return getActionClientAccess().getRule(); + } + + //@Override + //Parameter returns Parameter: + // {Parameter} + // name=EString':' + // BEGIN + // 'type' type=ParameterType + // ('ns:' namespace=Namespace)? + // ('qos:' qos=QualityOfService)? + // END + // '}'; + public ParameterElements getParameterAccess() { + return pParameter; + } + + public ParserRule getParameterRule() { + return getParameterAccess().getRule(); + } + + //PackageSet returns PackageSet: + // {PackageSet} + // package+=Package_Impl* + // ; + public RosGrammarAccess.PackageSetElements getPackageSetAccess() { + return gaRos.getPackageSetAccess(); + } + + public ParserRule getPackageSetRule() { + return getPackageSetAccess().getRule(); + } + + ///////////////////// + //// YAML format + ///////////////////// + //terminal BEGIN: 'synthetic:BEGIN'; + public TerminalRule getBEGINRule() { + return gaRos.getBEGINRule(); + } + + //terminal END: 'synthetic:END'; + public TerminalRule getENDRule() { + return gaRos.getENDRule(); + } + + //@Override + //terminal SL_COMMENT: '#' !('\n'|'\r')*; + public TerminalRule getSL_COMMENTRule() { + return gaRos.getSL_COMMENTRule(); + } + + ///////////////////// + //// CONVENTIONS AND NAMES + ///////////////////// + //EString returns ecore::EString: + // STRING | ID; + public RosGrammarAccess.EStringElements getEStringAccess() { + return gaRos.getEStringAccess(); + } + + public ParserRule getEStringRule() { + return getEStringAccess().getRule(); + } + + //RosNames returns ecore::EString: + // ROS_CONVENTION_A | ID | 'node' + //; + public RosGrammarAccess.RosNamesElements getRosNamesAccess() { + return gaRos.getRosNamesAccess(); + } + + public ParserRule getRosNamesRule() { + return getRosNamesAccess().getRule(); + } + + //terminal ROS_CONVENTION_A: + // ( ('/' ID ) | ( ID '/' ) )* ; + public TerminalRule getROS_CONVENTION_ARule() { + return gaRos.getROS_CONVENTION_ARule(); + } + + //terminal ROS_CONVENTION_PARAM: + // ( ('/' STRING ) | ( STRING '/' ) | ('~' STRING ) )* ; + public TerminalRule getROS_CONVENTION_PARAMRule() { + return gaRos.getROS_CONVENTION_PARAMRule(); + } + + //Package_Impl returns Package: + // {Package} + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('specs:' + // BEGIN + // spec+=SpecBase* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; + public RosGrammarAccess.Package_ImplElements getPackage_ImplAccess() { + return gaRos.getPackage_ImplAccess(); + } + + public ParserRule getPackage_ImplRule() { + return getPackage_ImplAccess().getRule(); + } + + //CatkinPackage returns CatkinPackage: + // {CatkinPackage} + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; + public RosGrammarAccess.CatkinPackageElements getCatkinPackageAccess() { + return gaRos.getCatkinPackageAccess(); + } + + public ParserRule getCatkinPackageRule() { + return getCatkinPackageAccess().getRule(); + } + + ///////////////////// + ////ARTIFACT AND NODE + ///////////////////// + //Artifact returns Artifact: + // {Artifact} + // name=RosNames':' + // BEGIN + // (node=Node)? + // END; + public RosGrammarAccess.ArtifactElements getArtifactAccess() { + return gaRos.getArtifactAccess(); + } + + public ParserRule getArtifactRule() { + return getArtifactAccess().getRule(); + } + + //Node returns Node: + // 'node:' name=RosNames + // BEGIN + // ( + // ('publishers:' + // BEGIN + // publisher+=Publisher* + // END + // )| + // ('subscribers:' + // BEGIN + // subscriber+=Subscriber* + // END + // )| + // ('serviceserver:' + // BEGIN + // serviceserver+=ServiceServer* + // END + // )| + // ('serviceclient:' + // BEGIN + // serviceclient+=ServiceClient* + // END + // )| + // ('actionserver:' + // BEGIN + // actionserver+=ActionServer* + // END + // )| + // ('actionclient:' + // BEGIN + // actionclient+=ActionClient* + // END + // )| + // ('parameters:' + // BEGIN + // parameter+=Parameter* + // END + // ) + // )*END + // ; + public RosGrammarAccess.NodeElements getNodeAccess() { + return gaRos.getNodeAccess(); + } + + public ParserRule getNodeRule() { + return getNodeAccess().getRule(); + } + + ///////////////////// + ////OBJECTS/SPECIFICATIONS + ///////////////////// + //SpecBase returns SpecBase: + // TopicSpec | ServiceSpec | ActionSpec; + public RosGrammarAccess.SpecBaseElements getSpecBaseAccess() { + return gaRos.getSpecBaseAccess(); + } + + public ParserRule getSpecBaseRule() { + return getSpecBaseAccess().getRule(); + } + + //TopicSpec returns TopicSpec: + // {TopicSpec} + // 'msg:'name=(EString|'Header'|'String') + // BEGIN + // 'message:' (BEGIN message=MessageDefinition END)? + // END + // ; + public RosGrammarAccess.TopicSpecElements getTopicSpecAccess() { + return gaRos.getTopicSpecAccess(); + } + + public ParserRule getTopicSpecRule() { + return getTopicSpecAccess().getRule(); + } + + //ServiceSpec returns ServiceSpec: + // {ServiceSpec} + // 'srv:'name=EString + // BEGIN + // 'request:' (BEGIN request=MessageDefinition END)? + // 'response:' (BEGIN response=MessageDefinition END)? + // END; + public RosGrammarAccess.ServiceSpecElements getServiceSpecAccess() { + return gaRos.getServiceSpecAccess(); + } + + public ParserRule getServiceSpecRule() { + return getServiceSpecAccess().getRule(); + } + + //ActionSpec returns ActionSpec: + // {ActionSpec} + // 'action:'name=EString + // BEGIN + // 'goal:' (BEGIN goal=MessageDefinition END)? + // 'result:' (BEGIN result=MessageDefinition END)? + // 'feedback:' (BEGIN feedback=MessageDefinition END)? + // END; + public RosGrammarAccess.ActionSpecElements getActionSpecAccess() { + return gaRos.getActionSpecAccess(); + } + + public ParserRule getActionSpecRule() { + return getActionSpecAccess().getRule(); + } + + //MessageDefinition returns MessageDefinition: + // {MessageDefinition} + // MessagePart+=MessagePart*; + public RosGrammarAccess.MessageDefinitionElements getMessageDefinitionAccess() { + return gaRos.getMessageDefinitionAccess(); + } + + public ParserRule getMessageDefinitionRule() { + return getMessageDefinitionAccess().getRule(); + } + + ///////////////////// + ////DEPENDENCIES + ///////////////////// + //Dependency returns Dependency: + // PackageDependency | ExternalDependency; + public RosGrammarAccess.DependencyElements getDependencyAccess() { + return gaRos.getDependencyAccess(); + } + + public ParserRule getDependencyRule() { + return getDependencyAccess().getRule(); + } + + //PackageDependency returns PackageDependency: + // package=[Package|EString]; + public RosGrammarAccess.PackageDependencyElements getPackageDependencyAccess() { + return gaRos.getPackageDependencyAccess(); + } + + public ParserRule getPackageDependencyRule() { + return getPackageDependencyAccess().getRule(); + } + + //ExternalDependency returns ExternalDependency: + // {ExternalDependency} + // 'ExternalDependency' + // name=EString; + public RosGrammarAccess.ExternalDependencyElements getExternalDependencyAccess() { + return gaRos.getExternalDependencyAccess(); + } + + public ParserRule getExternalDependencyRule() { + return getExternalDependencyAccess().getRule(); + } + + ///////////////////// + ////NAMESPACES + ///////////////////// + //Namespace returns Namespace: + // GlobalNamespace | RelativeNamespace_Impl | PrivateNamespace; + public RosGrammarAccess.NamespaceElements getNamespaceAccess() { + return gaRos.getNamespaceAccess(); + } + + public ParserRule getNamespaceRule() { + return getNamespaceAccess().getRule(); + } + + //GraphName returns GraphName: + // 'GraphName' ; + public RosGrammarAccess.GraphNameElements getGraphNameAccess() { + return gaRos.getGraphNameAccess(); + } + + public ParserRule getGraphNameRule() { + return getGraphNameAccess().getRule(); + } + + //GlobalNamespace returns GlobalNamespace: + // {GlobalNamespace} + // 'GlobalNamespace' + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; + public RosGrammarAccess.GlobalNamespaceElements getGlobalNamespaceAccess() { + return gaRos.getGlobalNamespaceAccess(); + } + + public ParserRule getGlobalNamespaceRule() { + return getGlobalNamespaceAccess().getRule(); + } + + //RelativeNamespace_Impl returns RelativeNamespace: + // {RelativeNamespace} + // 'RelativeNamespace' + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; + public RosGrammarAccess.RelativeNamespace_ImplElements getRelativeNamespace_ImplAccess() { + return gaRos.getRelativeNamespace_ImplAccess(); + } + + public ParserRule getRelativeNamespace_ImplRule() { + return getRelativeNamespace_ImplAccess().getRule(); + } + + //PrivateNamespace returns PrivateNamespace: + // {PrivateNamespace} + // 'PrivateNamespace' + // ('[' parts+=GraphName ( "," parts+=GraphName)* ']' )?; + public RosGrammarAccess.PrivateNamespaceElements getPrivateNamespaceAccess() { + return gaRos.getPrivateNamespaceAccess(); + } + + public ParserRule getPrivateNamespaceRule() { + return getPrivateNamespaceAccess().getRule(); + } + + ///////////////////// + ////PARAMETERS DEFINITION + ///////////////////// + //RosParamNames returns ecore::EString: + // ROS_CONVENTION_PARAM | ID + //; + public RosGrammarAccess.RosParamNamesElements getRosParamNamesAccess() { + return gaRos.getRosParamNamesAccess(); + } + + public ParserRule getRosParamNamesRule() { + return getRosParamNamesAccess().getRule(); + } + + //ParameterType returns ParameterType: + // ParameterListType | ParameterStructType | ParameterIntegerType | ParameterStringType | ParameterDoubleType | ParameterBooleanType | ParameterBase64Type | ParameterArrayType; + public RosGrammarAccess.ParameterTypeElements getParameterTypeAccess() { + return gaRos.getParameterTypeAccess(); + } + + public ParserRule getParameterTypeRule() { + return getParameterTypeAccess().getRule(); + } + + // // | ParameterDateType; + //ParameterValue returns ParameterValue: + // ParameterString | ParameterBase64 | ParameterInteger | ParameterDouble | ParameterBoolean | ParameterList | ParameterStruct; + public RosGrammarAccess.ParameterValueElements getParameterValueAccess() { + return gaRos.getParameterValueAccess(); + } + + public ParserRule getParameterValueRule() { + return getParameterValueAccess().getRule(); + } + + // // | ParameterDate; + //ParameterListType returns ParameterListType: + // {ParameterListType} + // 'List' + // '[' + // sequence+=ParameterType ( ',' sequence+=ParameterType )* + // ']'; + public RosGrammarAccess.ParameterListTypeElements getParameterListTypeAccess() { + return gaRos.getParameterListTypeAccess(); + } + + public ParserRule getParameterListTypeRule() { + return getParameterListTypeAccess().getRule(); + } + + //ParameterStructType returns ParameterStructType: + // {ParameterStructType} + // 'Struct' + // '[' + // parameterstructypetmember+=ParameterStructTypeMember ( "," parameterstructypetmember+=ParameterStructTypeMember)* + // ']'; + public RosGrammarAccess.ParameterStructTypeElements getParameterStructTypeAccess() { + return gaRos.getParameterStructTypeAccess(); + } + + public ParserRule getParameterStructTypeRule() { + return getParameterStructTypeAccess().getRule(); + } + + //ParameterIntegerType returns ParameterIntegerType: + // {ParameterIntegerType} + // 'Integer' + // ('default' default=ParameterInteger)?; + public RosGrammarAccess.ParameterIntegerTypeElements getParameterIntegerTypeAccess() { + return gaRos.getParameterIntegerTypeAccess(); + } + + public ParserRule getParameterIntegerTypeRule() { + return getParameterIntegerTypeAccess().getRule(); + } + + //ParameterStringType returns ParameterStringType: + // {ParameterStringType} + // 'String' + // ('default' default=ParameterString)?; + public RosGrammarAccess.ParameterStringTypeElements getParameterStringTypeAccess() { + return gaRos.getParameterStringTypeAccess(); + } + + public ParserRule getParameterStringTypeRule() { + return getParameterStringTypeAccess().getRule(); + } + + //ParameterDoubleType returns ParameterDoubleType: + // {ParameterDoubleType} + // 'Double' + // ('default' default=ParameterDouble)?; + public RosGrammarAccess.ParameterDoubleTypeElements getParameterDoubleTypeAccess() { + return gaRos.getParameterDoubleTypeAccess(); + } + + public ParserRule getParameterDoubleTypeRule() { + return getParameterDoubleTypeAccess().getRule(); + } + + //ParameterDateType returns ParameterDateType: + // {ParameterDateType} + // 'Date' + // ('default' default=ParameterDate)?; + public RosGrammarAccess.ParameterDateTypeElements getParameterDateTypeAccess() { + return gaRos.getParameterDateTypeAccess(); + } + + public ParserRule getParameterDateTypeRule() { + return getParameterDateTypeAccess().getRule(); + } + + //ParameterBooleanType returns ParameterBooleanType: + // {ParameterBooleanType} + // 'Boolean' + // ('default' default=ParameterBoolean)?; + public RosGrammarAccess.ParameterBooleanTypeElements getParameterBooleanTypeAccess() { + return gaRos.getParameterBooleanTypeAccess(); + } + + public ParserRule getParameterBooleanTypeRule() { + return getParameterBooleanTypeAccess().getRule(); + } + + //ParameterBase64Type returns ParameterBase64Type: + // {ParameterBase64Type} + // 'Base64' + // ('default' default=ParameterBase64)?; + public RosGrammarAccess.ParameterBase64TypeElements getParameterBase64TypeAccess() { + return gaRos.getParameterBase64TypeAccess(); + } + + public ParserRule getParameterBase64TypeRule() { + return getParameterBase64TypeAccess().getRule(); + } + + //ParameterAnyType returns ParameterAnyType: + // {ParameterAnyType} + // 'Any' + // ('default' default=ParameterAny)?; + public RosGrammarAccess.ParameterAnyTypeElements getParameterAnyTypeAccess() { + return gaRos.getParameterAnyTypeAccess(); + } + + public ParserRule getParameterAnyTypeRule() { + return getParameterAnyTypeAccess().getRule(); + } + + //ParameterArrayType returns ParameterArrayType: + // 'Array:' + // BEGIN + // 'type' type=ParameterType + // ('default' default=ParameterList)? + // END; + public RosGrammarAccess.ParameterArrayTypeElements getParameterArrayTypeAccess() { + return gaRos.getParameterArrayTypeAccess(); + } + + public ParserRule getParameterArrayTypeRule() { + return getParameterArrayTypeAccess().getRule(); + } + + //ParameterList returns ParameterSequence: + // {ParameterSequence} + // '[' value+=ParameterValue ( ',' value+=ParameterValue )* ']' + //; + public RosGrammarAccess.ParameterListElements getParameterListAccess() { + return gaRos.getParameterListAccess(); + } + + public ParserRule getParameterListRule() { + return getParameterListAccess().getRule(); + } + + //ParameterAny returns ParameterAny: + // {ParameterAny} + // 'ParameterAny' + // ('value' value=EString)? + // ; + public RosGrammarAccess.ParameterAnyElements getParameterAnyAccess() { + return gaRos.getParameterAnyAccess(); + } + + public ParserRule getParameterAnyRule() { + return getParameterAnyAccess().getRule(); + } + + //ParameterString returns ParameterString: + // value=EString + //; + public RosGrammarAccess.ParameterStringElements getParameterStringAccess() { + return gaRos.getParameterStringAccess(); + } + + public ParserRule getParameterStringRule() { + return getParameterStringAccess().getRule(); + } + + //ParameterBase64 returns ParameterBase64: + // value=Base64Binary + //; + public RosGrammarAccess.ParameterBase64Elements getParameterBase64Access() { + return gaRos.getParameterBase64Access(); + } + + public ParserRule getParameterBase64Rule() { + return getParameterBase64Access().getRule(); + } + + //ParameterInteger returns ParameterInteger: + // value=Integer0 + //; + public RosGrammarAccess.ParameterIntegerElements getParameterIntegerAccess() { + return gaRos.getParameterIntegerAccess(); + } + + public ParserRule getParameterIntegerRule() { + return getParameterIntegerAccess().getRule(); + } + + //ParameterDouble returns ParameterDouble: + // value=Double0 + //; + public RosGrammarAccess.ParameterDoubleElements getParameterDoubleAccess() { + return gaRos.getParameterDoubleAccess(); + } + + public ParserRule getParameterDoubleRule() { + return getParameterDoubleAccess().getRule(); + } + + //ParameterBoolean returns ParameterBoolean: + // value=boolean0 + //; + public RosGrammarAccess.ParameterBooleanElements getParameterBooleanAccess() { + return gaRos.getParameterBooleanAccess(); + } + + public ParserRule getParameterBooleanRule() { + return getParameterBooleanAccess().getRule(); + } + + //ParameterStruct returns ParameterStruct: + // {ParameterStruct} + // ('[' value+=ParameterStructMember ( "," '[' value+=ParameterStructMember ']')* ']' )? + //; + public RosGrammarAccess.ParameterStructElements getParameterStructAccess() { + return gaRos.getParameterStructAccess(); + } + + public ParserRule getParameterStructRule() { + return getParameterStructAccess().getRule(); + } + + //ParameterDate returns ParameterDate: + // value=DateTime0 + // ; + public RosGrammarAccess.ParameterDateElements getParameterDateAccess() { + return gaRos.getParameterDateAccess(); + } + + public ParserRule getParameterDateRule() { + return getParameterDateAccess().getRule(); + } + + //ParameterStructMember returns ParameterStructMember: + // 'ParameterStructMember' + // name=EString':' + // BEGIN + // value=ParameterValue + // END; + public RosGrammarAccess.ParameterStructMemberElements getParameterStructMemberAccess() { + return gaRos.getParameterStructMemberAccess(); + } + + public ParserRule getParameterStructMemberRule() { + return getParameterStructMemberAccess().getRule(); + } + + //ParameterStructTypeMember returns ParameterStructTypeMember: + // name=EString + // type=ParameterType + // ; + public RosGrammarAccess.ParameterStructTypeMemberElements getParameterStructTypeMemberAccess() { + return gaRos.getParameterStructTypeMemberAccess(); + } + + public ParserRule getParameterStructTypeMemberRule() { + return getParameterStructTypeMemberAccess().getRule(); + } + + ///////////////////// + ////PARAMETERS PRIMITIVES TYPES + ///////////////////// + //terminal DIGIT: '0'..'9'; + public TerminalRule getDIGITRule() { + return gaRos.getDIGITRule(); + } + + //terminal BINARY: ('0b'|'0B')('0'|'1')+; + public TerminalRule getBINARYRule() { + return gaRos.getBINARYRule(); + } + + //terminal BOOLEAN: 'true'|'false'; + public TerminalRule getBOOLEANRule() { + return gaRos.getBOOLEANRule(); + } + + //terminal DOUBLE returns ecore::EDouble: DIGIT (('.' DECINT*) | (('.' DIGIT*)? ('E'|'e') ('-'|'+')? DIGIT)); + public TerminalRule getDOUBLERule() { + return gaRos.getDOUBLERule(); + } + + // // Use terminal to avoid 'e' turning into a keyword + //terminal DECINT: '0' | ('1'..'9' DIGIT*) | ('-''0'..'9' DIGIT*) ; + public TerminalRule getDECINTRule() { + return gaRos.getDECINTRule(); + } + + //terminal DAY:'1'..'9' | '1'..'3' '0'..'9'; + public TerminalRule getDAYRule() { + return gaRos.getDAYRule(); + } + + //terminal MONTH:'1'..'9' | '1' '0'..'2'; + public TerminalRule getMONTHRule() { + return gaRos.getMONTHRule(); + } + + //terminal YEAR:'0'..'2' '0'..'9' '0'..'9' '0'..'9'; + public TerminalRule getYEARRule() { + return gaRos.getYEARRule(); + } + + //terminal HOUR: ('0'..'1')('0'..'9') | ('2')('0'..'3'); + public TerminalRule getHOURRule() { + return gaRos.getHOURRule(); + } + + //terminal MIN_SEC:('0'..'5')('0'..'9'); + public TerminalRule getMIN_SECRule() { + return gaRos.getMIN_SECRule(); + } + + //terminal DATE_TIME: YEAR'-'MONTH'-'DAY'T'HOUR':'MIN_SEC':'MIN_SEC; + public TerminalRule getDATE_TIMERule() { + return gaRos.getDATE_TIMERule(); + } + + //Base64Binary returns type::Base64Binary: + // BINARY ; + public RosGrammarAccess.Base64BinaryElements getBase64BinaryAccess() { + return gaRos.getBase64BinaryAccess(); + } + + public ParserRule getBase64BinaryRule() { + return getBase64BinaryAccess().getRule(); + } + + //boolean0 returns type::Boolean: + // BOOLEAN; + public RosGrammarAccess.Boolean0Elements getBoolean0Access() { + return gaRos.getBoolean0Access(); + } + + public ParserRule getBoolean0Rule() { + return getBoolean0Access().getRule(); + } + + //Double0 returns type::Double: + // DOUBLE; + public RosGrammarAccess.Double0Elements getDouble0Access() { + return gaRos.getDouble0Access(); + } + + public ParserRule getDouble0Rule() { + return getDouble0Access().getRule(); + } + + //Integer0 returns type::Int: + // DECINT; + public RosGrammarAccess.Integer0Elements getInteger0Access() { + return gaRos.getInteger0Access(); + } + + public ParserRule getInteger0Rule() { + return getInteger0Access().getRule(); + } + + //DateTime0 returns type::DateTime: + // DATE_TIME; + public RosGrammarAccess.DateTime0Elements getDateTime0Access() { + return gaRos.getDateTime0Access(); + } + + public ParserRule getDateTime0Rule() { + return getDateTime0Access().getRule(); + } + + ///////////////////// + ////MESSAGE PRIMITIVES DEFINITION + ///////////////////// + //MessagePart returns primitives::MessagePart: + // Type = AbstractType + // Data =(KEYWORD | MESSAGE_ASIGMENT | EString) + //; + public RosGrammarAccess.MessagePartElements getMessagePartAccess() { + return gaRos.getMessagePartAccess(); + } + + public ParserRule getMessagePartRule() { + return getMessagePartAccess().getRule(); + } + + //terminal MESSAGE_ASIGMENT: + // ((ID|STRING)'='(ID|STRING|INT|'-'INT)) + //; + public TerminalRule getMESSAGE_ASIGMENTRule() { + return gaRos.getMESSAGE_ASIGMENTRule(); + } + + //AbstractType returns primitives::AbstractType: + // bool | int8 | uint8 | int16 | uint16 | int32 | uint32 | int64 | uint64 | float32 | float64 | string0 | byte | time | duration | Header | + // boolArray | int8Array | uint8Array | int16Array | uint16Array | int32Array | uint32Array | int64Array | uint64Array | float32Array | float64Array | string0Array | byteArray | + // TopicSpecRef | ArrayTopicSpecRef ; + public RosGrammarAccess.AbstractTypeElements getAbstractTypeAccess() { + return gaRos.getAbstractTypeAccess(); + } + + public ParserRule getAbstractTypeRule() { + return getAbstractTypeAccess().getRule(); + } + + //bool returns primitives::bool: + // {primitives::bool} + // 'bool' + // ; + public RosGrammarAccess.BoolElements getBoolAccess() { + return gaRos.getBoolAccess(); + } + + public ParserRule getBoolRule() { + return getBoolAccess().getRule(); + } + + //int8 returns primitives::int8: + // {primitives::int8} + // 'int8' + // ; + public RosGrammarAccess.Int8Elements getInt8Access() { + return gaRos.getInt8Access(); + } + + public ParserRule getInt8Rule() { + return getInt8Access().getRule(); + } + + //uint8 returns primitives::uint8: + // {primitives::uint8} + // 'uint8' + // ; + public RosGrammarAccess.Uint8Elements getUint8Access() { + return gaRos.getUint8Access(); + } + + public ParserRule getUint8Rule() { + return getUint8Access().getRule(); + } + + //int16 returns primitives::int16: + // {primitives::int16} + // 'int16' + // ; + public RosGrammarAccess.Int16Elements getInt16Access() { + return gaRos.getInt16Access(); + } + + public ParserRule getInt16Rule() { + return getInt16Access().getRule(); + } + + //uint16 returns primitives::uint16: + // {primitives::uint16} + // 'uint16' + // ; + public RosGrammarAccess.Uint16Elements getUint16Access() { + return gaRos.getUint16Access(); + } + + public ParserRule getUint16Rule() { + return getUint16Access().getRule(); + } + + //int32 returns primitives::int32: + // {primitives::int32} + // 'int32' + // ; + public RosGrammarAccess.Int32Elements getInt32Access() { + return gaRos.getInt32Access(); + } + + public ParserRule getInt32Rule() { + return getInt32Access().getRule(); + } + + //uint32 returns primitives::uint32: + // {primitives::uint32} + // 'uint32' + // ; + public RosGrammarAccess.Uint32Elements getUint32Access() { + return gaRos.getUint32Access(); + } + + public ParserRule getUint32Rule() { + return getUint32Access().getRule(); + } + + //int64 returns primitives::int64: + // {primitives::int64} + // 'int64' + // ; + public RosGrammarAccess.Int64Elements getInt64Access() { + return gaRos.getInt64Access(); + } + + public ParserRule getInt64Rule() { + return getInt64Access().getRule(); + } + + //uint64 returns primitives::uint64: + // {primitives::uint64} + // 'uint64' + // ; + public RosGrammarAccess.Uint64Elements getUint64Access() { + return gaRos.getUint64Access(); + } + + public ParserRule getUint64Rule() { + return getUint64Access().getRule(); + } + + //float32 returns primitives::float32: + // {primitives::float32} + // 'float32' + // ; + public RosGrammarAccess.Float32Elements getFloat32Access() { + return gaRos.getFloat32Access(); + } + + public ParserRule getFloat32Rule() { + return getFloat32Access().getRule(); + } + + //float64 returns primitives::float64: + // {primitives::float64} + // 'float64' + // ; + public RosGrammarAccess.Float64Elements getFloat64Access() { + return gaRos.getFloat64Access(); + } + + public ParserRule getFloat64Rule() { + return getFloat64Access().getRule(); + } + + //string0 returns primitives::string: + // {primitives::string} + // 'string' + // ; + public RosGrammarAccess.String0Elements getString0Access() { + return gaRos.getString0Access(); + } + + public ParserRule getString0Rule() { + return getString0Access().getRule(); + } + + //byte returns primitives::Byte: + // {primitives::Byte} + // 'byte' + // ; + public RosGrammarAccess.ByteElements getByteAccess() { + return gaRos.getByteAccess(); + } + + public ParserRule getByteRule() { + return getByteAccess().getRule(); + } + + //time returns primitives::time: + // {primitives::time} + // 'time' + // ; + public RosGrammarAccess.TimeElements getTimeAccess() { + return gaRos.getTimeAccess(); + } + + public ParserRule getTimeRule() { + return getTimeAccess().getRule(); + } + + //duration returns primitives::duration: + // {primitives::duration} + // 'duration' + // ; + public RosGrammarAccess.DurationElements getDurationAccess() { + return gaRos.getDurationAccess(); + } + + public ParserRule getDurationRule() { + return getDurationAccess().getRule(); + } + + //boolArray returns primitives::boolArray: + // {primitives::boolArray} + // 'bool[]' + // ; + public RosGrammarAccess.BoolArrayElements getBoolArrayAccess() { + return gaRos.getBoolArrayAccess(); + } + + public ParserRule getBoolArrayRule() { + return getBoolArrayAccess().getRule(); + } + + //int8Array returns primitives::int8Array: + // {primitives::int8Array} + // 'int8[]' + // ; + public RosGrammarAccess.Int8ArrayElements getInt8ArrayAccess() { + return gaRos.getInt8ArrayAccess(); + } + + public ParserRule getInt8ArrayRule() { + return getInt8ArrayAccess().getRule(); + } + + //uint8Array returns primitives::uint8Array: + // {primitives::uint8Array} + // 'uint8[]' + // ; + public RosGrammarAccess.Uint8ArrayElements getUint8ArrayAccess() { + return gaRos.getUint8ArrayAccess(); + } + + public ParserRule getUint8ArrayRule() { + return getUint8ArrayAccess().getRule(); + } + + //int16Array returns primitives::int16Array: + // {primitives::int16Array} + // 'int16[]' + // ; + public RosGrammarAccess.Int16ArrayElements getInt16ArrayAccess() { + return gaRos.getInt16ArrayAccess(); + } + + public ParserRule getInt16ArrayRule() { + return getInt16ArrayAccess().getRule(); + } + + //uint16Array returns primitives::uint16Array: + // {primitives::uint16Array} + // 'uint16[]' + // ; + public RosGrammarAccess.Uint16ArrayElements getUint16ArrayAccess() { + return gaRos.getUint16ArrayAccess(); + } + + public ParserRule getUint16ArrayRule() { + return getUint16ArrayAccess().getRule(); + } + + //int32Array returns primitives::int32Array: + // {primitives::int32Array} + // 'int32[]' + // ; + public RosGrammarAccess.Int32ArrayElements getInt32ArrayAccess() { + return gaRos.getInt32ArrayAccess(); + } + + public ParserRule getInt32ArrayRule() { + return getInt32ArrayAccess().getRule(); + } + + //uint32Array returns primitives::uint32Array: + // {primitives::uint32Array} + // 'uint32[]' + // ; + public RosGrammarAccess.Uint32ArrayElements getUint32ArrayAccess() { + return gaRos.getUint32ArrayAccess(); + } + + public ParserRule getUint32ArrayRule() { + return getUint32ArrayAccess().getRule(); + } + + //int64Array returns primitives::int64Array: + // {primitives::int64Array} + // 'int64[]' + // ; + public RosGrammarAccess.Int64ArrayElements getInt64ArrayAccess() { + return gaRos.getInt64ArrayAccess(); + } + + public ParserRule getInt64ArrayRule() { + return getInt64ArrayAccess().getRule(); + } + + //uint64Array returns primitives::uint64Array: + // {primitives::uint64Array} + // 'uint64[]' + // ; + public RosGrammarAccess.Uint64ArrayElements getUint64ArrayAccess() { + return gaRos.getUint64ArrayAccess(); + } + + public ParserRule getUint64ArrayRule() { + return getUint64ArrayAccess().getRule(); + } + + //float32Array returns primitives::float32Array: + // {primitives::float32Array} + // 'float32[]' + // ; + public RosGrammarAccess.Float32ArrayElements getFloat32ArrayAccess() { + return gaRos.getFloat32ArrayAccess(); + } + + public ParserRule getFloat32ArrayRule() { + return getFloat32ArrayAccess().getRule(); + } + + //float64Array returns primitives::float64Array: + // {primitives::float64Array} + // 'float64[]' + // ; + public RosGrammarAccess.Float64ArrayElements getFloat64ArrayAccess() { + return gaRos.getFloat64ArrayAccess(); + } + + public ParserRule getFloat64ArrayRule() { + return getFloat64ArrayAccess().getRule(); + } + + //string0Array returns primitives::stringArray: + // {primitives::stringArray} + // 'string[]' + // ; + public RosGrammarAccess.String0ArrayElements getString0ArrayAccess() { + return gaRos.getString0ArrayAccess(); + } + + public ParserRule getString0ArrayRule() { + return getString0ArrayAccess().getRule(); + } + + //byteArray returns primitives::ByteArray: + // {primitives::ByteArray} + // 'byte[]' + // ; + public RosGrammarAccess.ByteArrayElements getByteArrayAccess() { + return gaRos.getByteArrayAccess(); + } + + public ParserRule getByteArrayRule() { + return getByteArrayAccess().getRule(); + } + + //Header returns primitives::Header: + // {primitives::Header} + // 'Header' + //; + public RosGrammarAccess.HeaderElements getHeaderAccess() { + return gaRos.getHeaderAccess(); + } + + public ParserRule getHeaderRule() { + return getHeaderAccess().getRule(); + } + + //TopicSpecRef returns primitives::TopicSpecRef: + // TopicSpec=[TopicSpec|EString] + //; + public RosGrammarAccess.TopicSpecRefElements getTopicSpecRefAccess() { + return gaRos.getTopicSpecRefAccess(); + } + + public ParserRule getTopicSpecRefRule() { + return getTopicSpecRefAccess().getRule(); + } + + //ArrayTopicSpecRef returns primitives::ArrayTopicSpecRef: + // TopicSpec=[TopicSpec|EString]'[]' + //; + public RosGrammarAccess.ArrayTopicSpecRefElements getArrayTopicSpecRefAccess() { + return gaRos.getArrayTopicSpecRefAccess(); + } + + public ParserRule getArrayTopicSpecRefRule() { + return getArrayTopicSpecRefAccess().getRule(); + } + + //KEYWORD: 'goal' | 'message' | 'result' | 'feedback' | 'name' | 'value' | 'service' | 'type' | 'action' | 'duration' | 'time' ; + public RosGrammarAccess.KEYWORDElements getKEYWORDAccess() { + return gaRos.getKEYWORDAccess(); + } + + public ParserRule getKEYWORDRule() { + return getKEYWORDAccess().getRule(); + } + + //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.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/validation/AbstractRos2Validator.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/validation/AbstractRos2Validator.java new file mode 100644 index 000000000..06a59b880 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/validation/AbstractRos2Validator.java @@ -0,0 +1,20 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.validation; + +import de.fraunhofer.ipa.ros.validation.RosValidator; +import java.util.ArrayList; +import java.util.List; +import org.eclipse.emf.ecore.EPackage; + +public abstract class AbstractRos2Validator extends RosValidator { + + @Override + protected List getEPackages() { + List result = new ArrayList(super.getEPackages()); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.ipa.fraunhofer.de/ros")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.ipa.fraunhofer.de/primitives")); + return result; + } +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/validation/Ros2ConfigurableIssueCodesProvider.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/validation/Ros2ConfigurableIssueCodesProvider.java new file mode 100644 index 000000000..fa3e4277e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src-gen/de/fraunhofer/ipa/ros2/validation/Ros2ConfigurableIssueCodesProvider.java @@ -0,0 +1,22 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.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 Ros2ConfigurableIssueCodesProvider extends ConfigurableIssueCodesProvider { + protected static final String ISSUE_CODE_PREFIX = "de.fraunhofer.ipa.ros2."; + + 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.ros2.xtext/src/de/fraunhofer/ipa/ros2/GenerateRos2.mwe2 b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/GenerateRos2.mwe2 new file mode 100644 index 000000000..fbc67eb07 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/GenerateRos2.mwe2 @@ -0,0 +1,61 @@ +module de.fraunhofer.ipa.ros2.GenerateRos2 + +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.ros2.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.ros2.Ros2" + fileExtensions = "ros2" + referencedResource = "platform:/resource/de.fraunhofer.ipa.ros/model/ros.genmodel" + + fragment = ecore2xtext.Ecore2XtextValueConverterServiceFragment2 auto-inject {} + + formatter = { + generateStub = true + 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.ros2.xtext/src/de/fraunhofer/ipa/ros2/Ros2.xtext b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/Ros2.xtext new file mode 100644 index 000000000..008748d82 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/Ros2.xtext @@ -0,0 +1,118 @@ +// automatically generated by Xtext +grammar de.fraunhofer.ipa.ros2.Ros2 with de.fraunhofer.ipa.ros.Ros + +import "http://www.ipa.fraunhofer.de/primitives" +import "http://www.eclipse.org/emf/2002/Ecore" as ecore +import "http://www.ipa.fraunhofer.de/ros" + +@Override +Package returns Package: + AmentPackage + ; + +@Override +AmentPackage returns AmentPackage: + {AmentPackage} + name=RosNames':' + BEGIN + ('fromGitRepo:' fromGitRepo=EString)? + ('artifacts:' + BEGIN + artifact+=Artifact* + END + )? + ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + END; + +/////////////////// +// Quality of Service +/////////////////// + +QualityOfService returns QualityOfService: + {QualityOfService} + (('profile:' QoSProfile=('default_qos'|'services_qos'|'sensor_qos'|'parameter_qos'))? & + ('history:' History=('keep_last'|'keep_all'))? & + ('depth:' Depth=Integer0)? & + ('reliability:' Reliability=('best_effort'|'reliable'))? & + ('durability:' Durability=('transient_local'|'volatile'))?) + ; + +/////////////////// +//INTERFACES +/////////////////// +@Override +Publisher returns Publisher: + {Publisher} + name=EString':' + BEGIN + 'type:' message=[TopicSpec|EString] + ('ns:' namespace=Namespace)? + ('qos:' BEGIN qos=QualityOfService END)? + END + ; + +@Override +Subscriber returns Subscriber: + {Subscriber} + name=EString':' + BEGIN + 'type:' message=[TopicSpec|EString] + ('ns:' namespace=Namespace)? + ('qos:' qos=QualityOfService)? + END + ; + +@Override +ServiceServer returns ServiceServer: + {ServiceServer} + name=EString':' + BEGIN + 'type:' service=[ServiceSpec|EString] + ('ns:' namespace=Namespace)? + ('qos:' qos=QualityOfService)? + END + ; + +@Override +ServiceClient returns ServiceClient: + {ServiceClient} + name=EString':' + BEGIN + 'type:' service=[ServiceSpec|EString] + ('ns:' namespace=Namespace)? + ('qos:' qos=QualityOfService)? + END + ; + +@Override +ActionServer returns ActionServer: + {ActionServer} + name=EString':' + BEGIN + 'type:' action=[ActionSpec|EString] + ('ns:' namespace=Namespace)? + ('qos:' qos=QualityOfService)? + END + ; + +@Override +ActionClient returns ActionClient: + {ActionClient} + name=EString':' + BEGIN + 'type:' action=[ActionSpec|EString] + ('ns:' namespace=Namespace)? + ('qos:' qos=QualityOfService)? + END + ; + +@Override +Parameter returns Parameter: + {Parameter} + name=EString':' + BEGIN + 'type' type=ParameterType + ('ns:' namespace=Namespace)? + ('qos:' qos=QualityOfService)? + END + '}'; \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/Ros2RuntimeModule.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/Ros2RuntimeModule.java new file mode 100644 index 000000000..1956cfb35 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/Ros2RuntimeModule.java @@ -0,0 +1,11 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2; + + +/** + * Use this class to register components to be used at runtime / without the Equinox extension registry. + */ +public class Ros2RuntimeModule extends AbstractRos2RuntimeModule { +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/Ros2StandaloneSetup.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/Ros2StandaloneSetup.java new file mode 100644 index 000000000..1ead3a5b2 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/Ros2StandaloneSetup.java @@ -0,0 +1,19 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2; + +import org.eclipse.xtext.resource.XtextResourceSet; + +import com.google.inject.Injector; + +/** + * Initialization support for running Xtext languages without Equinox extension registry. + */ +public class Ros2StandaloneSetup extends Ros2StandaloneSetupGenerated { + + public static void doSetup() { + Injector injector = new Ros2StandaloneSetup().createInjectorAndDoEMFRegistration(); + XtextResourceSet resourceSet = injector.getInstance(XtextResourceSet.class); + } +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/formatting2/Ros2Formatter.xtend b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/formatting2/Ros2Formatter.xtend new file mode 100644 index 000000000..7d0824b3e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/formatting2/Ros2Formatter.xtend @@ -0,0 +1,26 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.formatting2 + +import com.google.inject.Inject +import de.fraunhofer.ipa.ros.formatting2.RosFormatter +import de.fraunhofer.ipa.ros2.services.Ros2GrammarAccess +import org.eclipse.xtext.formatting2.IFormattableDocument +import ros.AmentPackage + +class Ros2Formatter extends RosFormatter { + + @Inject extension Ros2GrammarAccess + + def dispatch void format(AmentPackage amentPackage, extension IFormattableDocument document) { + // TODO: format HiddenRegions around keywords, attributes, cross references, etc. + for (artifact : amentPackage.artifact) { + artifact.format + } + for (dependency : amentPackage.dependency) { + dependency.format + } + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/generator/Ros2Generator.xtend b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/generator/Ros2Generator.xtend new file mode 100644 index 000000000..0a631c725 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/generator/Ros2Generator.xtend @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.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 Ros2Generator 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.ros2.xtext/src/de/fraunhofer/ipa/ros2/parser/antlr/Ros2TokenSource.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/parser/antlr/Ros2TokenSource.java new file mode 100644 index 000000000..a922fb253 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/parser/antlr/Ros2TokenSource.java @@ -0,0 +1,35 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.parser.antlr; + +import de.fraunhofer.ipa.ros2.parser.antlr.internal.InternalRos2Parser; +import org.antlr.runtime.Token; +import org.antlr.runtime.TokenSource; +import org.eclipse.xtext.parser.antlr.AbstractIndentationTokenSource; + +public class Ros2TokenSource extends AbstractIndentationTokenSource { + + public Ros2TokenSource(TokenSource delegate) { + super(delegate); + } + + @Override + protected boolean shouldSplitTokenImpl(Token token) { + // TODO Review assumption + return token.getType() == InternalRos2Parser.RULE_WS; + } + + @Override + protected int getBeginTokenType() { + // TODO Review assumption + return InternalRos2Parser.RULE_BEGIN; + } + + @Override + protected int getEndTokenType() { + // TODO Review assumption + return InternalRos2Parser.RULE_END; + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/scoping/Ros2ScopeProvider.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/scoping/Ros2ScopeProvider.java new file mode 100644 index 000000000..dec29faeb --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/scoping/Ros2ScopeProvider.java @@ -0,0 +1,15 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.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 Ros2ScopeProvider extends AbstractRos2ScopeProvider { + +} diff --git a/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/validation/Ros2Validator.java b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/validation/Ros2Validator.java new file mode 100644 index 000000000..836cf3553 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros2.xtext/src/de/fraunhofer/ipa/ros2/validation/Ros2Validator.java @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros2.validation; + + +/** + * This class contains custom validation rules. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + */ +public class Ros2Validator extends AbstractRos2Validator { + +// 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", +// Ros2Package.Literals.GREETING__NAME, +// INVALID_NAME); +// } +// } + +} diff --git a/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DeploymentArtifactsGenerator.xtend b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DeploymentArtifactsGenerator.xtend index 832af512f..66ade27c4 100644 --- a/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DeploymentArtifactsGenerator.xtend +++ b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DeploymentArtifactsGenerator.xtend @@ -11,6 +11,7 @@ import de.fraunhofer.ipa.rossystem.deployment.RosInstallCompiler import de.fraunhofer.ipa.rossystem.deployment.DockerComposeCompiler import de.fraunhofer.ipa.rossystem.deployment.DockerContainerCompiler import de.fraunhofer.ipa.rossystem.deployment.GitActionCompiler +import de.fraunhofer.ipa.rossystem.deployment.DeploymentHelpers import rossystem.RosSystem; import java.util.HashMap import java.util.Map @@ -44,12 +45,12 @@ class DeploymentArtifactsGenerator extends AbstractGenerator { RosInstallCompiler rosintall_compiler = new RosInstallCompiler() DockerComposeCompiler dockercompose_compiler = new DockerComposeCompiler() GitActionCompiler gitaction_compiler = new GitActionCompiler() - + + DeploymentHelpers generator_helper = new DeploymentHelpers() String ros_distro + String system_folder_prefix Integer ros_version - String system_prefix - String stack_prefix Map> device_map = new HashMap> def get_ros_distro(String distro) { @@ -85,26 +86,26 @@ class DeploymentArtifactsGenerator extends AbstractGenerator { } ] for (system : resource.allContents.toIterable.filter(RosSystem)){ - system_prefix = create_system_prefix(system) + system_folder_prefix = create_system_prefix(system) if (system.componentStack.size==0){ - fsa.generateFile(system_prefix +"/Dockerfile",docker_compiler.compile_toDockerContainer(system, null, ros_distro, ros_version)) - fsa.generateFile(system_prefix +"/extra_layer/" + system.getName().toLowerCase + ".rosinstall",rosintall_compiler.compile_toRosInstall(system,null)) - fsa.generateFile(system_prefix +"/extra_layer/Dockerfile",docker_compiler.compile_toDockerImageExtraLayer(system, null,ros_distro, ros_version)) + fsa.generateFile(system_folder_prefix +"/Dockerfile",docker_compiler.compile_toDockerContainer(system, null, ros_distro, ros_version)) + fsa.generateFile(system_folder_prefix +"/extra_layer/" + system.getName().toLowerCase + ".rosinstall",rosintall_compiler.compile_toRosInstall(system,null)) + fsa.generateFile(system_folder_prefix +"/extra_layer/Dockerfile",docker_compiler.compile_toDockerImageExtraLayer(system, null,ros_distro, ros_version)) } else { for (stack : system.componentStack){ - stack_prefix = String.join("/", system_prefix, system.name.toLowerCase+'_'+stack.name.toLowerCase) - fsa.generateFile(String.join("/", stack_prefix, "Dockerfile"),docker_compiler.compile_toDockerContainer(system, stack, ros_distro, ros_version)) - fsa.generateFile(String.join("/", stack_prefix, "extra_layer", stack.name.toLowerCase+".rosinstall"),rosintall_compiler.compile_toRosInstall(system,stack)) - fsa.generateFile(String.join("/", stack_prefix, "extra_layer", "Dockerfile"),docker_compiler.compile_toDockerImageExtraLayer(system,stack, ros_distro, ros_version)) + val stack_folder_prefix = String.join("/", system_folder_prefix, system.name.toLowerCase+'_'+stack.name.toLowerCase) + fsa.generateFile(String.join("/", stack_folder_prefix, "Dockerfile"),docker_compiler.compile_toDockerContainer(system, stack, ros_distro, ros_version)) + fsa.generateFile(String.join("/", stack_folder_prefix, "extra_layer", stack.name.toLowerCase+".rosinstall"),rosintall_compiler.compile_toRosInstall(system,stack)) + fsa.generateFile(String.join("/", stack_folder_prefix, "extra_layer", "Dockerfile"),docker_compiler.compile_toDockerImageExtraLayer(system,stack, ros_distro, ros_version)) } } - fsa.generateFile(String.join("/", system_prefix, "docker-compose.yml"),dockercompose_compiler.compile_toDockerCompose(system, ros_distro, ros_version, device_map)) + fsa.generateFile(String.join("/", system_folder_prefix, "docker-compose.yml"),dockercompose_compiler.compile_toDockerCompose(system, ros_distro, ros_version, device_map)) } // git action workflow for (system : resource.allContents.toIterable.filter(RosSystem)){ - fsa.generateFile(String.join("/", system_prefix, system.getName().toLowerCase + "_workflow.yml") ,gitaction_compiler.compile_toGitAction(system, ros_version)) + fsa.generateFile(String.join("/", system_folder_prefix, generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro) + "_workflow.yml") ,gitaction_compiler.compile_toGitAction(system, ros_version, ros_distro)) } } diff --git a/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DeploymentHelpers.xtend b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DeploymentHelpers.xtend new file mode 100644 index 000000000..286e7d241 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DeploymentHelpers.xtend @@ -0,0 +1,61 @@ +package de.fraunhofer.ipa.rossystem.deployment + +import componentInterface.ComponentInterface +import de.fraunhofer.ipa.rossystem.generator.GeneratorHelpers +import java.util.ArrayList +import java.util.HashSet +import java.util.List +import java.util.Set +import ros.Dependency +import ros.PackageDependency +import ros.impl.PackageImpl +import rossystem.ComponentStack +import rossystem.RosSystem + +class DeploymentHelpers extends GeneratorHelpers { + List ComponentsList + PackageImpl component_package + Set Repos + + def get_uniqe_name(String prefix, String ros_distro) { + return prefix + "_" + ros_distro + } + + def get_folder_name(String prefix, String ros_distro) { + if(ros_distro=="foxy") { + return prefix + "_ros2" + } + else{ + return prefix + } + } + + def Set listOfRepos(Object subsystem) { + new ArrayList() + ComponentsList = new ArrayList(); + if (subsystem.class.toString.contains("RosSystemImpl")){ + ComponentsList = (subsystem as RosSystem).rosComponent + } else if (subsystem.class.toString.contains("ComponentStackImpl")) { + ComponentsList = (subsystem as ComponentStack).rosComponent + } + + Repos = new HashSet(); + for (ComponentInterface component: ComponentsList){ + component_package = null; + component_package = get_pkg(component); + if (component_package !== null){ + if (component_package.fromGitRepo !== null){ + Repos.add(component_package.fromGitRepo); + } + if (!component_package.dependency.empty){ + for (Dependency depend: component_package.dependency){ + if ((depend as PackageDependency).package !== null){ + if ((depend as PackageDependency).package.fromGitRepo !== null){ + Repos.add((depend as PackageDependency).package.fromGitRepo); + } + } + } + }}} + return Repos; + } +} diff --git a/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DockerComposeCompiler.xtend b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DockerComposeCompiler.xtend index a2df50e07..8c709e7dc 100644 --- a/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DockerComposeCompiler.xtend +++ b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DockerComposeCompiler.xtend @@ -1,13 +1,13 @@ package de.fraunhofer.ipa.rossystem.deployment import rossystem.RosSystem -import de.fraunhofer.ipa.rossystem.generator.GeneratorHelpers +import de.fraunhofer.ipa.rossystem.deployment.DeploymentHelpers import java.util.Map import java.util.List class DockerComposeCompiler { - GeneratorHelpers generator_helper = new GeneratorHelpers() + DeploymentHelpers generator_helper = new DeploymentHelpers() def create_devices(List ports)''' «IF ports.size() > 0» @@ -31,26 +31,26 @@ services: - ros «IF system.getComponentStack().isEmpty()» -«" "»«system.name.toLowerCase»: - image: "«system.name.toLowerCase»:latest" +«" "»«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»: + image: "«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»:latest" depends_on: - ros-master environment: - "ROS_MASTER_URI=http://ros-master:11311" - - "ROS_HOSTNAME=«system.name.toLowerCase»" + - "ROS_HOSTNAME=«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»" networks: - ros «create_devices(device_map.get(system.name))» command: stdbuf -o L roslaunch «system.name.toLowerCase» «system.name.toLowerCase».launch --wait «ELSE» «FOR stack:system.componentStack» -«" "»«system.name.toLowerCase»_«stack.name.toLowerCase»: - image: "«system.name.toLowerCase»_«stack.name.toLowerCase»:latest" +«" "»«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»_«stack.name.toLowerCase»: + image: "«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»_«stack.name.toLowerCase»:latest" depends_on: - ros-master environment: - "ROS_MASTER_URI=http://ros-master:11311" - - "ROS_HOSTNAME=«stack.name.toLowerCase»" + - "ROS_HOSTNAME=«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»_«stack.name.toLowerCase»" networks: - ros «create_devices(device_map.get(stack.name))» @@ -59,8 +59,22 @@ services: «ENDFOR» «ENDIF» «ELSE» -Todo: complete docker compose file for ros2 -«ENDIF» +version: "3.3" +services: +«IF system.getComponentStack().isEmpty()» +«" "»«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»: + image: "«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»:latest" + «create_devices(device_map.get(system.name))» + command: stdbuf -o L ros2 launch «system.name.toLowerCase» «system.name.toLowerCase».launch.py +«ELSE» +«FOR stack:system.componentStack» +«" "»«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»_«stack.name.toLowerCase»: + image: "«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»_«stack.name.toLowerCase»:latest" + «create_devices(device_map.get(stack.name))» + command: stdbuf -o L ros2 launch «system.name.toLowerCase»_«stack.name.toLowerCase» «stack.name.toLowerCase».launch.py +«ENDFOR» +«ENDIF» +«ENDIF» ''' } diff --git a/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DockerContainerCompiler.xtend b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DockerContainerCompiler.xtend index c48912e40..891a68123 100644 --- a/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DockerContainerCompiler.xtend +++ b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/DockerContainerCompiler.xtend @@ -2,16 +2,16 @@ package de.fraunhofer.ipa.rossystem.deployment import rossystem.RosSystem import rossystem.ComponentStack -import de.fraunhofer.ipa.rossystem.generator.GeneratorHelpers +import de.fraunhofer.ipa.rossystem.deployment.DeploymentHelpers class DockerContainerCompiler { - GeneratorHelpers generator_helper = new GeneratorHelpers() + DeploymentHelpers generator_helper = new DeploymentHelpers() def dockerfile_header(Integer ros_version) ''' # syntax=docker/dockerfile:experimental ARG SUFFIX= ARG BUILDER_SUFFIX=:ros«ros_version» -ARG PREFIX= +ARG PREFIX= ''' def compile_toDockerContainer(RosSystem system, ComponentStack stack, String ros_distro, Integer ros_version) '''«generator_helper.init_pkg()» «dockerfile_header(ros_version)» @@ -19,21 +19,22 @@ ARG PREFIX= «IF generator_helper.listOfRepos(system).isEmpty()» FROM ros:«ros_distro»-ros-core as base «ELSE» -FROM ${PREFIX}extra_layer_«system.name.toLowerCase»${SUFFIX} as base +FROM ${PREFIX}extra_layer_«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»${SUFFIX} as base «ENDIF» «ELSE» «IF generator_helper.listOfRepos(stack).isEmpty()» FROM ros:«ros_distro»-ros-core as base «ELSE» -FROM ${PREFIX}extra_layer_«stack.name.toLowerCase»${SUFFIX} as base +FROM ${PREFIX}extra_layer_«generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)»_«stack.name.toLowerCase»${SUFFIX} as base «ENDIF» «ENDIF» FROM ${PREFIX}builder${BUILDER_SUFFIX} as builder FROM base as build -COPY . /root/ws/src/«IF stack===null»«system.name.toLowerCase»«ELSE»«system.name.toLowerCase»_«stack.name.toLowerCase»«ENDIF»/ +COPY . /root/ws/src/«IF stack===null»«system.name.toLowerCase»«ELSE»«system.name.toLowerCase»_«stack.name.toLowerCase»«ENDIF»«IF ros_version===2»_ros2«ENDIF»/ RUN --mount=type=bind,from=builder,target=/builder \ apt-get update -qq && \ + «IF ros_version===2»/builder/workspace.bash builder_setup && \«ENDIF» /builder/workspace.bash build_workspace /root/ws && \ rm -rf /var/lib/apt/lists/* @@ -63,7 +64,11 @@ RUN --mount=type=bind,from=builder,target=/builder --mount=type=bind,target=/roo COPY --from=install /opt/ros/$ROS_DISTRO /opt/ros/$ROS_DISTRO FROM deploy as launch +«IF ros_version==1» «IF stack===null»CMD ["roslaunch", "«system.name»", "«system.name».launch"]«ELSE»CMD ["roslaunch", "«system.name.toLowerCase»_«stack.name.toLowerCase»", "«stack.name.toLowerCase».launch"]«ENDIF» +«ELSE» +«IF stack===null»CMD ["ros2", "launch", "«system.name.toLowerCase»", "«system.name.toLowerCase».launch.py"]«ELSE»CMD ["ros2", "launch", "«system.name.toLowerCase»_«stack.name.toLowerCase»", "«stack.name.toLowerCase».launch.py"]«ENDIF» +«ENDIF» ''' def compile_toDockerImageExtraLayer(RosSystem system, ComponentStack stack, String ros_distro, Integer ros_version) '''«generator_helper.init_pkg()» @@ -76,6 +81,7 @@ FROM base as pre_build COPY * /root/ws/src/ RUN --mount=type=bind,from=builder,target=/builder \ apt-get update -qq && \ + «IF ros_version===2»/builder/workspace.bash builder_setup && \«ENDIF» /builder/workspace.bash update_list /root/ws && \ rm -rf /var/lib/apt/lists/* @@ -103,7 +109,7 @@ RUN --mount=type=bind,from=builder,target=/builder \ /builder/workspace.bash install_depends /root/ws && \ rm -rf /var/lib/apt/lists/* -FROM pre_build as deploy +FROM build as deploy RUN --mount=type=bind,from=builder,target=/builder \ --mount=type=bind,target=/root/ws,from=install,source=/root/ws \ apt-get update -qq && \ diff --git a/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/GitActionCompiler.xtend b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/GitActionCompiler.xtend index 3c18c9719..c31a6ea11 100644 --- a/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/GitActionCompiler.xtend +++ b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/GitActionCompiler.xtend @@ -1,11 +1,11 @@ package de.fraunhofer.ipa.rossystem.deployment import rossystem.RosSystem -import de.fraunhofer.ipa.rossystem.generator.GeneratorHelpers +import de.fraunhofer.ipa.rossystem.deployment.DeploymentHelpers class GitActionCompiler { - GeneratorHelpers generator_helper = new GeneratorHelpers() + DeploymentHelpers generator_helper = new DeploymentHelpers() def default_part(String layer, String context_path, String needed_layer, String tag)''' «layer»: @@ -38,6 +38,10 @@ class GitActionCompiler { key: ${{ runner.os }}-buildx-${{ github.sha }} restore-keys: | ${{ runner.os }}-buildx- + - + name: Get Branch + id: extract_branch + run: echo ::set-output name=branch::$(echo ${GITHUB_REF#refs/heads/} | sed 's/[^a-zA-Z0-9-]/_/g') - name: Docker meta id: docker_meta @@ -47,10 +51,6 @@ class GitActionCompiler { tags: | «tag» type=raw,value=latest - - - name: Get Branch - id: extract_branch - run: echo ::set-output name=branch::$(echo ${GITHUB_REF} | cut -d'/' -f3) - name: Build and Push Docker Image uses: docker/build-push-action@v2 @@ -74,48 +74,52 @@ class GitActionCompiler { def build_layer()''' «default_part("builder", "./builder", null, "type=raw,value=${{ env.BUILDER_SUFFIX }}")» ''' - def extra_layer(String name, String path)''' - «default_part("extra_layer_"+name, String.join("/", ".",path,"extra_layer"), "builder", "type=ref,event=branch")» + def extra_layer(String sys_name, String ros_distro) +''' + «default_part("extra_layer_"+ generator_helper.get_uniqe_name(sys_name, ros_distro), String.join("/", ".",generator_helper.get_folder_name(sys_name, ros_distro),"extra_layer"), null, "type=raw,value=${{ steps.extract_branch.outputs.branch }}")» +''' + def extra_layer(String sys_name, String stack_name,String ros_distro) +''' + «default_part(String.join("_", "extra_layer", generator_helper.get_uniqe_name(sys_name, ros_distro), stack_name), String.join("/", ".",generator_helper.get_folder_name(sys_name, ros_distro), String.join("_", sys_name, stack_name),"extra_layer"), null, "type=raw,value=${{ steps.extract_branch.outputs.branch }}")» ''' - def system_layer(String sys_name, Boolean need_extra)''' + def system_layer(String sys_name, Boolean need_extra, String ros_distro)''' «IF need_extra» - «default_part(sys_name, "./"+sys_name, "extra_layer_"+sys_name, "type=ref,event=branch")» + «default_part(generator_helper.get_uniqe_name(sys_name, ros_distro), "./"+ generator_helper.get_folder_name(sys_name, ros_distro), "extra_layer_"+ generator_helper.get_uniqe_name(sys_name, ros_distro), "type=raw,value=${{ steps.extract_branch.outputs.branch }}")» «ELSE» - «default_part(sys_name, "./"+sys_name, "builder", "type=ref,event=branch")» + «default_part(generator_helper.get_uniqe_name(sys_name, ros_distro), "./"+ generator_helper.get_folder_name(sys_name, ros_distro), null, "type=raw,value=${{ steps.extract_branch.outputs.branch }}")» «ENDIF» ''' - def stack_layer(String sys_name, String stack_name, Boolean need_extra)''' + def stack_layer(String sys_name, String stack_name, String ros_distro, Boolean need_extra)''' «IF need_extra» - «default_part(sys_name+"_"+stack_name, String.join("/", ".",sys_name, sys_name+"_"+stack_name), "extra_layer_"+stack_name, "type=ref,event=branch")» + «default_part(generator_helper.get_uniqe_name(sys_name, ros_distro)+"_"+stack_name, String.join("/", ".",generator_helper.get_folder_name(sys_name, ros_distro), sys_name+"_"+stack_name), String.join("_", "extra_layer", generator_helper.get_uniqe_name(sys_name, ros_distro), stack_name), "type=raw,value=${{ steps.extract_branch.outputs.branch }}")» «ELSE» - «default_part(sys_name+"_"+stack_name, String.join("/", ".",sys_name, sys_name+"_"+stack_name), "builder", "type=ref,event=branch")» + «default_part(generator_helper.get_uniqe_name(sys_name, ros_distro)+"_"+stack_name, String.join("/", ".",generator_helper.get_folder_name(sys_name, ros_distro), sys_name+"_"+stack_name), null, "type=raw,value=${{ steps.extract_branch.outputs.branch }}")» «ENDIF» ''' - def compile_toGitAction(RosSystem system, Integer ros_version) '''«generator_helper.init_pkg()» -name: «system.name.toLowerCase» + def compile_toGitAction(RosSystem system, Integer ros_version, String ros_distro) '''«generator_helper.init_pkg()» +name: «generator_helper.get_uniqe_name(system.name.toLowerCase, ros_distro)» on: push: paths: - - '«system.name.toLowerCase»/**' + - '«generator_helper.get_folder_name(system.name.toLowerCase, ros_distro)»/**' env: PREFIX: "${{ secrets.DOCKER_USERNAME }}/" SUFFIX: "" ««« Todo: get distro from model BUILDER_SUFFIX: ros«ros_version» jobs: - «build_layer()» «IF system.getComponentStack().isEmpty()» «IF !generator_helper.listOfRepos(system).isEmpty()» - «extra_layer(system.name.toLowerCase, system.name.toLowerCase)» - «system_layer(system.name.toLowerCase, true)» + «extra_layer(system.name.toLowerCase, ros_distro)» + «system_layer(system.name.toLowerCase, true, ros_distro)» «ELSE» - «system_layer(system.name.toLowerCase, false)» + «system_layer(system.name.toLowerCase, false, ros_distro)» «ENDIF» «ELSE»«FOR stack : system.getComponentStack()»«IF !generator_helper.listOfRepos(stack).isEmpty()» - «extra_layer(stack.name.toLowerCase, String.join("/", system.name.toLowerCase, system.name.toLowerCase + "_" + stack.name.toLowerCase))» - «stack_layer(system.name.toLowerCase, stack.name.toLowerCase, true)» + «extra_layer(system.name.toLowerCase, stack.name.toLowerCase, ros_distro)» + «stack_layer(system.name.toLowerCase, stack.name.toLowerCase, ros_distro, true)» «ELSE» - «stack_layer(system.name.toLowerCase, stack.name.toLowerCase, false)» + «stack_layer(system.name.toLowerCase, stack.name.toLowerCase, ros_distro, false)» «ENDIF» «ENDFOR» «ENDIF» diff --git a/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/RosInstallCompiler.xtend b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/RosInstallCompiler.xtend index 1a840adf1..a283135a7 100644 --- a/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/RosInstallCompiler.xtend +++ b/plugins/de.fraunhofer.ipa.rossystem.deployment/src/de/fraunhofer/ipa/rossystem/deployment/RosInstallCompiler.xtend @@ -1,71 +1,42 @@ package de.fraunhofer.ipa.rossystem.deployment -import rossystem.RosSystem -import java.util.List -import componentInterface.ComponentInterface -import ros.impl.PackageImpl -import ros.Dependency -import ros.PackageDependency -import java.util.ArrayList -import java.util.Set -import java.util.HashSet import rossystem.ComponentStack -import de.fraunhofer.ipa.rossystem.generator.GeneratorHelpers +import rossystem.RosSystem +import de.fraunhofer.ipa.rossystem.deployment.DeploymentHelpers class RosInstallCompiler { - - PackageImpl component_package; - Set Repos; - List PkgsList - List ComponentsList - GeneratorHelpers generator_helper = new GeneratorHelpers() + DeploymentHelpers generator_helper = new DeploymentHelpers() + val repo_info = newLinkedHashMap('local_name' -> null, 'branch' -> null, 'uri' -> null) - def create_repo_link (String repo)''' -«IF repo.indexOf(":", repo.indexOf(":") + 1) > 1» -- git: {local-name: «repo.substring(0,repo.lastIndexOf(':')).substring(repo.lastIndexOf("/") + 1).replace(".git","")», uri: «repo.substring(0,repo.lastIndexOf(':'))», version: «repo.substring(repo.lastIndexOf(':') + 1)»} -«ELSE» -- git: {local-name: «repo.substring(repo.lastIndexOf("/") + 1).replace(".git","")», uri: «repo»} -«ENDIF» +def get_repo_info(String repo){ + repo_info.put('branch', null) + repo_info.put('local_name', null) + repo_info.put('uri', null) + if(repo.indexOf(":", repo.indexOf(":") + 1) > 1) { + repo_info.put('branch', repo.substring(repo.lastIndexOf(':')+ 1)) + val uri = repo.substring(0,repo.lastIndexOf(':')) + repo_info.put('uri', uri) + repo_info.put('local_name', uri.substring(uri.lastIndexOf("/") + 1).replace(".git","")) + } + else { + repo_info.put('branch', null) + repo_info.put('uri', repo) + repo_info.put('local_name', repo.substring(repo.lastIndexOf("/") + 1).replace(".git","")) + } +} + + def create_repo_link (String repo) + '''«get_repo_info(repo)» +- git: {local-name: «repo_info.get('local_name')», uri: «repo_info.get('uri')»«IF repo_info.get('branch')!==null», version: «repo_info.get('branch')»«ENDIF»} ''' def compile_toRosInstall (RosSystem system,ComponentStack stack) '''«generator_helper.init_pkg()» -«IF stack===null»«FOR repo:system.listOfRepos» +«IF stack===null»«FOR repo: generator_helper.listOfRepos(system)» «create_repo_link(repo)» «ENDFOR» -«ELSE»«FOR repo:stack.listOfRepos» +«ELSE»«FOR repo: generator_helper.listOfRepos(stack)» «create_repo_link(repo)» «ENDFOR» «ENDIF» ''' - - def Set listOfRepos(Object subsystem) { - PkgsList = new ArrayList() - ComponentsList = new ArrayList(); - if (subsystem.class.toString.contains("RosSystemImpl")){ - ComponentsList = (subsystem as RosSystem).rosComponent - } else if (subsystem.class.toString.contains("ComponentStackImpl")) { - ComponentsList = (subsystem as ComponentStack).rosComponent - } - - - Repos = new HashSet(); - for (ComponentInterface component: ComponentsList){ - component_package = null; - component_package = generator_helper.get_pkg(component); - if (component_package !== null){ - if (component_package.fromGitRepo !== null){ - Repos.add(component_package.fromGitRepo); - } - if (!component_package.dependency.empty){ - for (Dependency depend: component_package.dependency){ - if ((depend as PackageDependency).package !== null){ - if ((depend as PackageDependency).package.fromGitRepo !== null){ - Repos.add((depend as PackageDependency).package.fromGitRepo); - } - } - } - }}} - return Repos; - } - } diff --git a/plugins/de.fraunhofer.ipa.rossystem.xtext.ide/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.rossystem.xtext.ide/META-INF/MANIFEST.MF index 140e8a440..64f1fc556 100644 --- a/plugins/de.fraunhofer.ipa.rossystem.xtext.ide/META-INF/MANIFEST.MF +++ b/plugins/de.fraunhofer.ipa.rossystem.xtext.ide/META-INF/MANIFEST.MF @@ -9,7 +9,7 @@ Require-Bundle: de.fraunhofer.ipa.rossystem.xtext, de.fraunhofer.ipa.rossystem, org.eclipse.xtext.ide, org.eclipse.xtext.xbase.ide, - org.antlr.runtime + org.antlr.runtime;bundle-version="[3.2.0,3.2.1)" Bundle-RequiredExecutionEnvironment: JavaSE-1.8 Export-Package: de.fraunhofer.ipa.rossystem.ide.contentassist.antlr.internal, de.fraunhofer.ipa.rossystem.ide.contentassist.antlr diff --git a/plugins/de.fraunhofer.ipa.rossystem.xtext.ui/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.rossystem.xtext.ui/META-INF/MANIFEST.MF index 4fb86836a..f1e34fca6 100644 --- a/plugins/de.fraunhofer.ipa.rossystem.xtext.ui/META-INF/MANIFEST.MF +++ b/plugins/de.fraunhofer.ipa.rossystem.xtext.ui/META-INF/MANIFEST.MF @@ -16,8 +16,8 @@ Require-Bundle: de.fraunhofer.ipa.rossystem.xtext, org.eclipse.ui, org.eclipse.compare, org.eclipse.xtext.builder, - org.eclipse.xtend.lib, - org.eclipse.xtext.xbase.lib + org.eclipse.xtend.lib;bundle-version="2.14.0", + org.eclipse.xtext.xbase.lib;bundle-version="2.14.0" Import-Package: org.apache.log4j Bundle-RequiredExecutionEnvironment: JavaSE-1.8 Export-Package: de.fraunhofer.ipa.rossystem.ui.contentassist, diff --git a/plugins/de.fraunhofer.ipa.rossystem.xtext/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.rossystem.xtext/META-INF/MANIFEST.MF index d5de93ef7..6489fba2f 100644 --- a/plugins/de.fraunhofer.ipa.rossystem.xtext/META-INF/MANIFEST.MF +++ b/plugins/de.fraunhofer.ipa.rossystem.xtext/META-INF/MANIFEST.MF @@ -9,8 +9,8 @@ Require-Bundle: de.fraunhofer.ipa.rossystem, org.eclipse.xtext, org.eclipse.xtext.xbase, org.eclipse.equinox.common, - org.eclipse.xtext.xbase.lib, - org.antlr.runtime, + org.eclipse.xtext.xbase.lib;bundle-version="2.14.0", + org.antlr.runtime;bundle-version="[3.2.0,3.2.1)", org.eclipse.xtext.util, org.eclipse.xtend.lib;bundle-version="2.14.0" Bundle-RequiredExecutionEnvironment: JavaSE-1.8 diff --git a/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/GeneratorHelpers.xtend b/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/GeneratorHelpers.xtend index 24e04c53e..c32a821ec 100644 --- a/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/GeneratorHelpers.xtend +++ b/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/GeneratorHelpers.xtend @@ -28,8 +28,6 @@ class GeneratorHelpers { List PkgsList String Pkg List ComponentsList - PackageImpl component_package - Set Repos def void init_pkg(){ PackageSet=false @@ -122,37 +120,6 @@ class GeneratorHelpers { package_impl = node.eContainer.eContainer as PackageImpl; return package_impl; } - - -def Set listOfRepos(Object subsystem) { - PkgsList = new ArrayList() - ComponentsList = new ArrayList(); - if (subsystem.class.toString.contains("RosSystemImpl")){ - ComponentsList = (subsystem as RosSystem).rosComponent - } else if (subsystem.class.toString.contains("ComponentStackImpl")) { - ComponentsList = (subsystem as ComponentStack).rosComponent - } - - - Repos = new HashSet(); - for (ComponentInterface component: ComponentsList){ - component_package = null; - component_package = get_pkg(component); - if (component_package !== null){ - if (component_package.fromGitRepo !== null){ - Repos.add(component_package.fromGitRepo); - } - if (!component_package.dependency.empty){ - for (Dependency depend: component_package.dependency){ - if ((depend as PackageDependency).package !== null){ - if ((depend as PackageDependency).package.fromGitRepo !== null){ - Repos.add((depend as PackageDependency).package.fromGitRepo); - } - } - } - }}} - return Repos; -} //Launch files generators def check_ns(ComponentInterface component){ diff --git a/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/RosSystemGenerator.xtend b/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/RosSystemGenerator.xtend index 559c9c54f..aa5af9918 100644 --- a/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/RosSystemGenerator.xtend +++ b/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/RosSystemGenerator.xtend @@ -98,8 +98,8 @@ class RosSystemGenerator extends AbstractGenerator { if (Ros2Components.size()>0){ fsa.generateFile(system.getName().toLowerCase+"_ros2/package.xml",compile_package_xml_format3 (system, null)) fsa.generateFile(system.getName().toLowerCase+"_ros2/CMakeLists.txt",compile_CMakeLists_ROS2(system, null)) - fsa.generateFile(system.getName().toLowerCase+"_ros2/launch/"+system.getName()+".launch",compile_toROS2launch(system, null).toString().replace("\t"," ")) - fsa.generateFile(system.getName().toLowerCase+"_ros2/setup.py",system.compile_setup_py) + fsa.generateFile(system.getName().toLowerCase+"_ros2/launch/"+system.getName()+".launch.py",compile_toROS2launch(system, null).toString().replace("\t"," ")) + fsa.generateFile(system.getName().toLowerCase+"_ros2/setup.py",compile_setup_py(system, null)) fsa.generateFile(system.getName().toLowerCase+"_ros2/resource/" + system.getName().toLowerCase, "") fsa.generateFile(system.getName().toLowerCase+"_ros2/" + system.getName().toLowerCase + "/__init__.py", "") } @@ -115,10 +115,10 @@ class RosSystemGenerator extends AbstractGenerator { if (!Collections.disjoint(stack.rosComponent, Ros2Components)) { fsa.generateFile(String.join("/", system.getName().toLowerCase+"_ros2", system.name.toLowerCase+'_'+stack.name.toLowerCase, "package.xml"),compile_package_xml_format3(system, stack)) fsa.generateFile(String.join("/", system.getName().toLowerCase+"_ros2", system.name.toLowerCase+'_'+stack.name.toLowerCase, "CMakeLists.txt"),compile_CMakeLists_ROS2(system, stack)) - fsa.generateFile(String.join("/", system.getName().toLowerCase+"_ros2", system.name.toLowerCase+'_'+stack.name.toLowerCase, "launch", stack.getName()+".launch"), compile_toROS2launch(system, stack).toString().replace("\t"," ")) - fsa.generateFile(String.join("/", system.getName().toLowerCase+"_ros2", system.name.toLowerCase+'_'+stack.name.toLowerCase, "setup.py"),system.compile_setup_py) + fsa.generateFile(String.join("/", system.getName().toLowerCase+"_ros2", system.name.toLowerCase+'_'+stack.name.toLowerCase, "launch", stack.getName()+".launch.py"), compile_toROS2launch(system, stack).toString().replace("\t"," ")) + fsa.generateFile(String.join("/", system.getName().toLowerCase+"_ros2", system.name.toLowerCase+'_'+stack.name.toLowerCase, "setup.py"),compile_setup_py(system, stack)) fsa.generateFile(String.join("/", system.getName().toLowerCase+"_ros2", system.name.toLowerCase+'_'+stack.name.toLowerCase, "resource/" + system.name.toLowerCase+'_'+stack.name.toLowerCase.toLowerCase), "") - fsa.generateFile(String.join("/", system.getName().toLowerCase+"_ros2", system.name.toLowerCase+'_'+stack.name.toLowerCase, "/__init__.py"), "") + fsa.generateFile(String.join("/", system.getName().toLowerCase+"_ros2", system.name.toLowerCase+'_'+stack.name.toLowerCase, system.name.toLowerCase+'_'+stack.name.toLowerCase, "__init__.py"), "") } } diff --git a/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/SetupPyCompiler.xtend b/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/SetupPyCompiler.xtend index 069581892..f58f0b042 100644 --- a/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/SetupPyCompiler.xtend +++ b/plugins/de.fraunhofer.ipa.rossystem.xtext/src/de/fraunhofer/ipa/rossystem/generator/SetupPyCompiler.xtend @@ -2,18 +2,19 @@ package de.fraunhofer.ipa.rossystem.generator import rossystem.RosSystem import com.google.inject.Inject +import rossystem.ComponentStack class SetupPyCompile{ @Inject extension GeneratorHelpers - def compile_setup_py(RosSystem system) '''«init_pkg()» + def compile_setup_py(RosSystem system,ComponentStack stack) '''«init_pkg()» import os from glob import glob from setuptools import setup -PACKAGE_NAME = '«system.name.toLowerCase»' +PACKAGE_NAME = '«IF stack===null»«system.name.toLowerCase»«ELSE»«system.name.toLowerCase»_«stack.name.toLowerCase»«ENDIF»' setup( name=PACKAGE_NAME,